test: added test coverage for infra-config

Co-authored-by: jamesgeorge007 <jamesgeorge998001@gmail.com>
Co-authored-by: nivedin <nivedinp@gmail.com>

docker-compose.yml

@@ -112,7 +112,7 @@ services:
     build:
       dockerfile: packages/hoppscotch-backend/Dockerfile
       context: .
-      target: prod
+      target: dev
     env_file:
       - ./.env
     restart: always
@@ -122,7 +122,7 @@ services:
       - PORT=3000
     volumes:
       # Uncomment the line below when modifying code. Only applicable when using the "dev" target.
-      # - ./packages/hoppscotch-backend/:/usr/src/app
+      - ./packages/hoppscotch-backend/:/usr/src/app
       - /usr/src/app/node_modules/
     depends_on:
       hoppscotch-db:

packages/hoppscotch-backend/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hoppscotch-backend",
-  "version": "2023.12.4",
+  "version": "2023.12.6",
   "description": "",
   "author": "",
   "private": true,
@@ -34,12 +34,14 @@
     "@nestjs/jwt": "^10.1.1",
     "@nestjs/passport": "^10.0.2",
     "@nestjs/platform-express": "^10.2.6",
+    "@nestjs/schedule": "^4.0.1",
     "@nestjs/throttler": "^5.0.0",
     "@prisma/client": "^5.8.0",
     "argon2": "^0.30.3",
     "bcrypt": "^5.1.0",
     "cookie": "^0.5.0",
     "cookie-parser": "^1.4.6",
+    "cron": "^3.1.6",
     "express": "^4.17.1",
     "express-session": "^1.17.3",
     "fp-ts": "^2.13.1",
@@ -57,6 +59,7 @@
     "passport-jwt": "^4.0.1",
     "passport-local": "^1.0.0",
     "passport-microsoft": "^1.0.0",
+    "posthog-node": "^3.6.3",
     "prisma": "^5.8.0",
     "reflect-metadata": "^0.1.13",
     "rimraf": "^3.0.2",

packages/hoppscotch-backend/prisma/migrations/20240226053141_full_text_search_additions/migration.sql

@@ -0,0 +1,17 @@
+-- AlterTable
+ALTER TABLE
+  "TeamCollection"
+ADD
+  titleSearch tsvector GENERATED ALWAYS AS (to_tsvector('english', title)) STORED;
+
+-- AlterTable
+ALTER TABLE
+  "TeamRequest"
+ADD
+  titleSearch tsvector GENERATED ALWAYS AS (to_tsvector('english', title)) STORED;
+
+-- CreateIndex
+CREATE INDEX "TeamCollection_textSearch_idx" ON "TeamCollection" USING GIN (titleSearch);
+
+-- CreateIndex
+CREATE INDEX "TeamRequest_textSearch_idx" ON "TeamRequest" USING GIN (titleSearch);

packages/hoppscotch-backend/prisma/schema.prisma

@@ -41,31 +41,31 @@ model TeamInvitation {
 }
 
 model TeamCollection {
-  id         String           @id @default(cuid())
+  id         String                   @id @default(cuid())
   parentID   String?
   data       Json?
-  parent     TeamCollection?  @relation("TeamCollectionChildParent", fields: [parentID], references: [id])
-  children   TeamCollection[] @relation("TeamCollectionChildParent")
+  parent     TeamCollection?          @relation("TeamCollectionChildParent", fields: [parentID], references: [id])
+  children   TeamCollection[]         @relation("TeamCollectionChildParent")
   requests   TeamRequest[]
   teamID     String
-  team       Team             @relation(fields: [teamID], references: [id], onDelete: Cascade)
+  team       Team                     @relation(fields: [teamID], references: [id], onDelete: Cascade)
   title      String
   orderIndex Int
-  createdOn  DateTime         @default(now()) @db.Timestamp(3)
-  updatedOn  DateTime         @updatedAt @db.Timestamp(3)
+  createdOn  DateTime                 @default(now()) @db.Timestamp(3)
+  updatedOn  DateTime                 @updatedAt @db.Timestamp(3)
 }
 
 model TeamRequest {
-  id           String         @id @default(cuid())
+  id           String                   @id @default(cuid())
   collectionID String
-  collection   TeamCollection @relation(fields: [collectionID], references: [id], onDelete: Cascade)
+  collection   TeamCollection           @relation(fields: [collectionID], references: [id], onDelete: Cascade)
   teamID       String
-  team         Team           @relation(fields: [teamID], references: [id], onDelete: Cascade)
+  team         Team                     @relation(fields: [teamID], references: [id], onDelete: Cascade)
   title        String
   request      Json
   orderIndex   Int
-  createdOn    DateTime       @default(now()) @db.Timestamp(3)
-  updatedOn    DateTime       @updatedAt @db.Timestamp(3)
+  createdOn    DateTime                 @default(now()) @db.Timestamp(3)
+  updatedOn    DateTime                 @updatedAt @db.Timestamp(3)
 }
 
 model Shortcode {

packages/hoppscotch-backend/src/admin/admin.resolver.ts

@@ -27,9 +27,7 @@ import {
 } from './input-types.args';
 import { GqlThrottlerGuard } from 'src/guards/gql-throttler.guard';
 import { SkipThrottle } from '@nestjs/throttler';
-import { User } from 'src/user/user.model';
-import { PaginationArgs } from 'src/types/input-types.args';
-import { TeamInvitation } from 'src/team-invitation/team-invitation.model';
+import { UserDeletionResult } from 'src/user/user.model';
 
 @UseGuards(GqlThrottlerGuard)
 @Resolver(() => Admin)
@@ -49,203 +47,6 @@ export class AdminResolver {
     return admin;
   }
 
-  @ResolveField(() => [User], {
-    description: 'Returns a list of all admin users in infra',
-    deprecationReason: 'Use `infra` query instead',
-  })
-  @UseGuards(GqlAuthGuard, GqlAdminGuard)
-  async admins() {
-    const admins = await this.adminService.fetchAdmins();
-    return admins;
-  }
-  @ResolveField(() => User, {
-    description: 'Returns a user info by UID',
-    deprecationReason: 'Use `infra` query instead',
-  })
-  @UseGuards(GqlAuthGuard, GqlAdminGuard)
-  async userInfo(
-    @Args({
-      name: 'userUid',
-      type: () => ID,
-      description: 'The user UID',
-    })
-    userUid: string,
-  ): Promise<AuthUser> {
-    const user = await this.adminService.fetchUserInfo(userUid);
-    if (E.isLeft(user)) throwErr(user.left);
-    return user.right;
-  }
-
-  @ResolveField(() => [User], {
-    description: 'Returns a list of all the users in infra',
-    deprecationReason: 'Use `infra` query instead',
-  })
-  @UseGuards(GqlAuthGuard, GqlAdminGuard)
-  async allUsers(
-    @Parent() admin: Admin,
-    @Args() args: PaginationArgs,
-  ): Promise<AuthUser[]> {
-    const users = await this.adminService.fetchUsers(args.cursor, args.take);
-    return users;
-  }
-
-  @ResolveField(() => [InvitedUser], {
-    description: 'Returns a list of all the invited users',
-    deprecationReason: 'Use `infra` query instead',
-  })
-  async invitedUsers(@Parent() admin: Admin): Promise<InvitedUser[]> {
-    const users = await this.adminService.fetchInvitedUsers();
-    return users;
-  }
-
-  @ResolveField(() => [Team], {
-    description: 'Returns a list of all the teams in the infra',
-    deprecationReason: 'Use `infra` query instead',
-  })
-  async allTeams(
-    @Parent() admin: Admin,
-    @Args() args: PaginationArgs,
-  ): Promise<Team[]> {
-    const teams = await this.adminService.fetchAllTeams(args.cursor, args.take);
-    return teams;
-  }
-  @ResolveField(() => Team, {
-    description: 'Returns a team info by ID when requested by Admin',
-    deprecationReason: 'Use `infra` query instead',
-  })
-  async teamInfo(
-    @Parent() admin: Admin,
-    @Args({
-      name: 'teamID',
-      type: () => ID,
-      description: 'Team ID for which info to fetch',
-    })
-    teamID: string,
-  ): Promise<Team> {
-    const team = await this.adminService.getTeamInfo(teamID);
-    if (E.isLeft(team)) throwErr(team.left);
-    return team.right;
-  }
-
-  @ResolveField(() => Number, {
-    description: 'Return count of all the members in a team',
-    deprecationReason: 'Use `infra` query instead',
-  })
-  async membersCountInTeam(
-    @Parent() admin: Admin,
-    @Args({
-      name: 'teamID',
-      type: () => ID,
-      description: 'Team ID for which team members to fetch',
-      nullable: false,
-    })
-    teamID: string,
-  ): Promise<number> {
-    const teamMembersCount = await this.adminService.membersCountInTeam(teamID);
-    return teamMembersCount;
-  }
-
-  @ResolveField(() => Number, {
-    description: 'Return count of all the stored collections in a team',
-    deprecationReason: 'Use `infra` query instead',
-  })
-  async collectionCountInTeam(
-    @Parent() admin: Admin,
-    @Args({
-      name: 'teamID',
-      type: () => ID,
-      description: 'Team ID for which team members to fetch',
-    })
-    teamID: string,
-  ): Promise<number> {
-    const teamCollCount = await this.adminService.collectionCountInTeam(teamID);
-    return teamCollCount;
-  }
-  @ResolveField(() => Number, {
-    description: 'Return count of all the stored requests in a team',
-    deprecationReason: 'Use `infra` query instead',
-  })
-  async requestCountInTeam(
-    @Parent() admin: Admin,
-    @Args({
-      name: 'teamID',
-      type: () => ID,
-      description: 'Team ID for which team members to fetch',
-    })
-    teamID: string,
-  ): Promise<number> {
-    const teamReqCount = await this.adminService.requestCountInTeam(teamID);
-    return teamReqCount;
-  }
-
-  @ResolveField(() => Number, {
-    description: 'Return count of all the stored environments in a team',
-    deprecationReason: 'Use `infra` query instead',
-  })
-  async environmentCountInTeam(
-    @Parent() admin: Admin,
-    @Args({
-      name: 'teamID',
-      type: () => ID,
-      description: 'Team ID for which team members to fetch',
-    })
-    teamID: string,
-  ): Promise<number> {
-    const envsCount = await this.adminService.environmentCountInTeam(teamID);
-    return envsCount;
-  }
-
-  @ResolveField(() => [TeamInvitation], {
-    description: 'Return all the pending invitations in a team',
-    deprecationReason: 'Use `infra` query instead',
-  })
-  async pendingInvitationCountInTeam(
-    @Parent() admin: Admin,
-    @Args({
-      name: 'teamID',
-      type: () => ID,
-      description: 'Team ID for which team members to fetch',
-    })
-    teamID: string,
-  ) {
-    const invitations = await this.adminService.pendingInvitationCountInTeam(
-      teamID,
-    );
-    return invitations;
-  }
-
-  @ResolveField(() => Number, {
-    description: 'Return total number of Users in organization',
-    deprecationReason: 'Use `infra` query instead',
-  })
-  async usersCount() {
-    return this.adminService.getUsersCount();
-  }
-
-  @ResolveField(() => Number, {
-    description: 'Return total number of Teams in organization',
-    deprecationReason: 'Use `infra` query instead',
-  })
-  async teamsCount() {
-    return this.adminService.getTeamsCount();
-  }
-
-  @ResolveField(() => Number, {
-    description: 'Return total number of Team Collections in organization',
-    deprecationReason: 'Use `infra` query instead',
-  })
-  async teamCollectionsCount() {
-    return this.adminService.getTeamCollectionsCount();
-  }
-
-  @ResolveField(() => Number, {
-    description: 'Return total number of Team Requests in organization',
-    deprecationReason: 'Use `infra` query instead',
-  })
-  async teamRequestsCount() {
-    return this.adminService.getTeamRequestsCount();
-  }
-
   /* Mutations */
 
   @Mutation(() => InvitedUser, {
@@ -269,8 +70,26 @@ export class AdminResolver {
     return invitedUser.right;
   }
 
+  @Mutation(() => Boolean, {
+    description: 'Revoke a user invites by invitee emails',
+  })
+  @UseGuards(GqlAuthGuard, GqlAdminGuard)
+  async revokeUserInvitationsByAdmin(
+    @Args({
+      name: 'inviteeEmails',
+      description: 'Invitee Emails',
+      type: () => [String],
+    })
+    inviteeEmails: string[],
+  ): Promise<boolean> {
+    const invite = await this.adminService.revokeUserInvitations(inviteeEmails);
+    if (E.isLeft(invite)) throwErr(invite.left);
+    return invite.right;
+  }
+
   @Mutation(() => Boolean, {
     description: 'Delete an user account from infra',
+    deprecationReason: 'Use removeUsersByAdmin instead',
   })
   @UseGuards(GqlAuthGuard, GqlAdminGuard)
   async removeUserByAdmin(
@@ -281,12 +100,33 @@ export class AdminResolver {
     })
     userUID: string,
   ): Promise<boolean> {
-    const invitedUser = await this.adminService.removeUserAccount(userUID);
-    if (E.isLeft(invitedUser)) throwErr(invitedUser.left);
-    return invitedUser.right;
+    const removedUser = await this.adminService.removeUserAccount(userUID);
+    if (E.isLeft(removedUser)) throwErr(removedUser.left);
+    return removedUser.right;
   }
+
+  @Mutation(() => [UserDeletionResult], {
+    description: 'Delete user accounts from infra',
+  })
+  @UseGuards(GqlAuthGuard, GqlAdminGuard)
+  async removeUsersByAdmin(
+    @Args({
+      name: 'userUIDs',
+      description: 'users UID',
+      type: () => [ID],
+    })
+    userUIDs: string[],
+  ): Promise<UserDeletionResult[]> {
+    const deletionResults = await this.adminService.removeUserAccounts(
+      userUIDs,
+    );
+    if (E.isLeft(deletionResults)) throwErr(deletionResults.left);
+    return deletionResults.right;
+  }
+
   @Mutation(() => Boolean, {
     description: 'Make user an admin',
+    deprecationReason: 'Use makeUsersAdmin instead',
   })
   @UseGuards(GqlAuthGuard, GqlAdminGuard)
   async makeUserAdmin(
@@ -302,8 +142,51 @@ export class AdminResolver {
     return admin.right;
   }
 
+  @Mutation(() => Boolean, {
+    description: 'Make users an admin',
+  })
+  @UseGuards(GqlAuthGuard, GqlAdminGuard)
+  async makeUsersAdmin(
+    @Args({
+      name: 'userUIDs',
+      description: 'users UID',
+      type: () => [ID],
+    })
+    userUIDs: string[],
+  ): Promise<boolean> {
+    const isUpdated = await this.adminService.makeUsersAdmin(userUIDs);
+    if (E.isLeft(isUpdated)) throwErr(isUpdated.left);
+    return isUpdated.right;
+  }
+
+  @Mutation(() => Boolean, {
+    description: 'Update user display name',
+  })
+  @UseGuards(GqlAuthGuard, GqlAdminGuard)
+  async updateUserDisplayNameByAdmin(
+    @Args({
+      name: 'userUID',
+      description: 'users UID',
+      type: () => ID,
+    })
+    userUID: string,
+    @Args({
+      name: 'displayName',
+      description: 'users display name',
+    })
+    displayName: string,
+  ): Promise<boolean> {
+    const isUpdated = await this.adminService.updateUserDisplayName(
+      userUID,
+      displayName,
+    );
+    if (E.isLeft(isUpdated)) throwErr(isUpdated.left);
+    return isUpdated.right;
+  }
+
   @Mutation(() => Boolean, {
     description: 'Remove user as admin',
+    deprecationReason: 'Use demoteUsersByAdmin instead',
   })
   @UseGuards(GqlAuthGuard, GqlAdminGuard)
   async removeUserAsAdmin(
@@ -319,6 +202,23 @@ export class AdminResolver {
     return admin.right;
   }
 
+  @Mutation(() => Boolean, {
+    description: 'Remove users as admin',
+  })
+  @UseGuards(GqlAuthGuard, GqlAdminGuard)
+  async demoteUsersByAdmin(
+    @Args({
+      name: 'userUIDs',
+      description: 'users UID',
+      type: () => [ID],
+    })
+    userUIDs: string[],
+  ): Promise<boolean> {
+    const isUpdated = await this.adminService.demoteUsersByAdmin(userUIDs);
+    if (E.isLeft(isUpdated)) throwErr(isUpdated.left);
+    return isUpdated.right;
+  }
+
   @Mutation(() => Team, {
     description:
       'Create a new team by providing the user uid to nominate as Team owner',

packages/hoppscotch-backend/src/admin/admin.service.spec.ts

@@ -1,7 +1,7 @@
 import { AdminService } from './admin.service';
 import { PubSubService } from '../pubsub/pubsub.service';
 import { mockDeep } from 'jest-mock-extended';
-import { InvitedUsers } from '@prisma/client';
+import { InvitedUsers, User as DbUser } from '@prisma/client';
 import { UserService } from '../user/user.service';
 import { TeamService } from '../team/team.service';
 import { TeamEnvironmentsService } from '../team-environments/team-environments.service';
@@ -13,10 +13,15 @@ import { PrismaService } from 'src/prisma/prisma.service';
 import {
   DUPLICATE_EMAIL,
   INVALID_EMAIL,
+  ONLY_ONE_ADMIN_ACCOUNT,
   USER_ALREADY_INVITED,
+  USER_INVITATION_DELETION_FAILED,
+  USER_NOT_FOUND,
 } from '../errors';
 import { ShortcodeService } from 'src/shortcode/shortcode.service';
 import { ConfigService } from '@nestjs/config';
+import { OffsetPaginationArgs } from 'src/types/input-types.args';
+import * as E from 'fp-ts/Either';
 
 const mockPrisma = mockDeep<PrismaService>();
 const mockPubSub = mockDeep<PubSubService>();
@@ -58,20 +63,87 @@ const invitedUsers: InvitedUsers[] = [
     invitedOn: new Date(),
   },
 ];
+
+const dbAdminUsers: DbUser[] = [
+  {
+    uid: 'uid 1',
+    displayName: 'displayName',
+    email: 'email@email.com',
+    photoURL: 'photoURL',
+    isAdmin: true,
+    refreshToken: 'refreshToken',
+    currentRESTSession: '',
+    currentGQLSession: '',
+    createdOn: new Date(),
+  },
+  {
+    uid: 'uid 2',
+    displayName: 'displayName',
+    email: 'email@email.com',
+    photoURL: 'photoURL',
+    isAdmin: true,
+    refreshToken: 'refreshToken',
+    currentRESTSession: '',
+    currentGQLSession: '',
+    createdOn: new Date(),
+  },
+];
+const dbNonAminUser: DbUser = {
+  uid: 'uid 3',
+  displayName: 'displayName',
+  email: 'email@email.com',
+  photoURL: 'photoURL',
+  isAdmin: false,
+  refreshToken: 'refreshToken',
+  currentRESTSession: '',
+  currentGQLSession: '',
+  createdOn: new Date(),
+};
+
 describe('AdminService', () => {
   describe('fetchInvitedUsers', () => {
-    test('should resolve right and return an array of invited users', async () => {
+    test('should resolve right and apply pagination correctly', async () => {
       // eslint-disable-next-line @typescript-eslint/ban-ts-comment
       // @ts-ignore
+      mockPrisma.user.findMany.mockResolvedValue([dbAdminUsers[0]]);
+      // @ts-ignore
       mockPrisma.invitedUsers.findMany.mockResolvedValue(invitedUsers);
 
-      const results = await adminService.fetchInvitedUsers();
+      const paginationArgs: OffsetPaginationArgs = { take: 5, skip: 2 };
+      const results = await adminService.fetchInvitedUsers(paginationArgs);
+
+      expect(mockPrisma.invitedUsers.findMany).toHaveBeenCalledWith({
+        ...paginationArgs,
+        orderBy: {
+          invitedOn: 'desc',
+        },
+        where: {
+          NOT: {
+            inviteeEmail: {
+              in: [dbAdminUsers[0].email],
+            },
+          },
+        },
+      });
+    });
+    test('should resolve right and return an array of invited users', async () => {
+      const paginationArgs: OffsetPaginationArgs = { take: 10, skip: 0 };
+
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      mockPrisma.user.findMany.mockResolvedValue([dbAdminUsers[0]]);
+      // @ts-ignore
+      mockPrisma.invitedUsers.findMany.mockResolvedValue(invitedUsers);
+
+      const results = await adminService.fetchInvitedUsers(paginationArgs);
       expect(results).toEqual(invitedUsers);
     });
     test('should resolve left and return an empty array if invited users not found', async () => {
+      const paginationArgs: OffsetPaginationArgs = { take: 10, skip: 0 };
+
       mockPrisma.invitedUsers.findMany.mockResolvedValue([]);
 
-      const results = await adminService.fetchInvitedUsers();
+      const results = await adminService.fetchInvitedUsers(paginationArgs);
       expect(results).toEqual([]);
     });
   });
@@ -134,6 +206,58 @@ describe('AdminService', () => {
     });
   });
 
+  describe('revokeUserInvitations', () => {
+    test('should resolve left and return error if email not invited', async () => {
+      mockPrisma.invitedUsers.deleteMany.mockRejectedValueOnce(
+        'RecordNotFound',
+      );
+
+      const result = await adminService.revokeUserInvitations([
+        'test@gmail.com',
+      ]);
+
+      expect(result).toEqualLeft(USER_INVITATION_DELETION_FAILED);
+    });
+
+    test('should resolve right and return deleted invitee email', async () => {
+      const adminUid = 'adminUid';
+      mockPrisma.invitedUsers.deleteMany.mockResolvedValueOnce({ count: 1 });
+
+      const result = await adminService.revokeUserInvitations([
+        invitedUsers[0].inviteeEmail,
+      ]);
+
+      expect(mockPrisma.invitedUsers.deleteMany).toHaveBeenCalledWith({
+        where: {
+          inviteeEmail: { in: [invitedUsers[0].inviteeEmail] },
+        },
+      });
+      expect(result).toEqualRight(true);
+    });
+  });
+
+  describe('removeUsersAsAdmin', () => {
+    test('should resolve right and make admins to users', async () => {
+      mockUserService.fetchAdminUsers.mockResolvedValueOnce(dbAdminUsers);
+      mockUserService.removeUsersAsAdmin.mockResolvedValueOnce(E.right(true));
+
+      return expect(
+        await adminService.demoteUsersByAdmin([dbAdminUsers[0].uid]),
+      ).toEqualRight(true);
+    });
+
+    test('should resolve left and return error if only one admin in the infra', async () => {
+      mockUserService.fetchAdminUsers.mockResolvedValueOnce(dbAdminUsers);
+      mockUserService.removeUsersAsAdmin.mockResolvedValueOnce(E.right(true));
+
+      return expect(
+        await adminService.demoteUsersByAdmin(
+          dbAdminUsers.map((user) => user.uid),
+        ),
+      ).toEqualLeft(ONLY_ONE_ADMIN_ACCOUNT);
+    });
+  });
+
   describe('getUsersCount', () => {
     test('should return count of all users in the organization', async () => {
       mockUserService.getUsersCount.mockResolvedValueOnce(10);

packages/hoppscotch-backend/src/admin/admin.service.ts

@@ -6,13 +6,16 @@ import * as E from 'fp-ts/Either';
 import * as O from 'fp-ts/Option';
 import { validateEmail } from '../utils';
 import {
+  ADMIN_CAN_NOT_BE_DELETED,
   DUPLICATE_EMAIL,
   EMAIL_FAILED,
   INVALID_EMAIL,
   ONLY_ONE_ADMIN_ACCOUNT,
   TEAM_INVITE_ALREADY_MEMBER,
   TEAM_INVITE_NO_INVITE_FOUND,
+  USERS_NOT_FOUND,
   USER_ALREADY_INVITED,
+  USER_INVITATION_DELETION_FAILED,
   USER_IS_ADMIN,
   USER_NOT_FOUND,
 } from '../errors';
@@ -26,6 +29,8 @@ import { TeamInvitationService } from '../team-invitation/team-invitation.servic
 import { TeamMemberRole } from '../team/team.model';
 import { ShortcodeService } from 'src/shortcode/shortcode.service';
 import { ConfigService } from '@nestjs/config';
+import { OffsetPaginationArgs } from 'src/types/input-types.args';
+import { UserDeletionResult } from 'src/user/user.model';
 
 @Injectable()
 export class AdminService {
@@ -48,12 +53,30 @@ export class AdminService {
    * @param cursorID Users uid
    * @param take number of users to fetch
    * @returns an Either of array of user or error
+   * @deprecated use fetchUsersV2 instead
    */
   async fetchUsers(cursorID: string, take: number) {
     const allUsers = await this.userService.fetchAllUsers(cursorID, take);
     return allUsers;
   }
 
+  /**
+   * Fetch all the users in the infra.
+   * @param searchString search on users displayName or email
+   * @param paginationOption pagination options
+   * @returns an Either of array of user or error
+   */
+  async fetchUsersV2(
+    searchString: string,
+    paginationOption: OffsetPaginationArgs,
+  ) {
+    const allUsers = await this.userService.fetchAllUsersV2(
+      searchString,
+      paginationOption,
+    );
+    return allUsers;
+  }
+
   /**
    * Invite a user to join the infra.
    * @param adminUID Admin's UID
@@ -110,14 +133,68 @@ export class AdminService {
     return E.right(invitedUser);
   }
 
+  /**
+   * Update the display name of a user
+   * @param userUid Who's display name is being updated
+   * @param displayName New display name of the user
+   * @returns an Either of boolean or error
+   */
+  async updateUserDisplayName(userUid: string, displayName: string) {
+    const updatedUser = await this.userService.updateUserDisplayName(
+      userUid,
+      displayName,
+    );
+    if (E.isLeft(updatedUser)) return E.left(updatedUser.left);
+
+    return E.right(true);
+  }
+
+  /**
+   * Revoke infra level user invitations
+   * @param inviteeEmails Invitee's emails
+   * @param adminUid Admin Uid
+   * @returns an Either of boolean or error string
+   */
+  async revokeUserInvitations(inviteeEmails: string[]) {
+    try {
+      await this.prisma.invitedUsers.deleteMany({
+        where: {
+          inviteeEmail: { in: inviteeEmails },
+        },
+      });
+      return E.right(true);
+    } catch (error) {
+      return E.left(USER_INVITATION_DELETION_FAILED);
+    }
+  }
+
   /**
    * Fetch the list of invited users by the admin.
    * @returns an Either of array of `InvitedUser` object or error
    */
-  async fetchInvitedUsers() {
-    const invitedUsers = await this.prisma.invitedUsers.findMany();
+  async fetchInvitedUsers(paginationOption: OffsetPaginationArgs) {
+    const userEmailObjs = await this.prisma.user.findMany({
+      select: {
+        email: true,
+      },
+    });
 
-    const users: InvitedUser[] = invitedUsers.map(
+    const pendingInvitedUsers = await this.prisma.invitedUsers.findMany({
+      take: paginationOption.take,
+      skip: paginationOption.skip,
+      orderBy: {
+        invitedOn: 'desc',
+      },
+      where: {
+        NOT: {
+          inviteeEmail: {
+            in: userEmailObjs.map((user) => user.email),
+          },
+        },
+      },
+    });
+
+    const users: InvitedUser[] = pendingInvitedUsers.map(
       (user) => <InvitedUser>{ ...user },
     );
 
@@ -337,6 +414,7 @@ export class AdminService {
    * Remove a user account by UID
    * @param userUid User UID
    * @returns an Either of boolean or error
+   * @deprecated use removeUserAccounts instead
    */
   async removeUserAccount(userUid: string) {
     const user = await this.userService.findUserById(userUid);
@@ -349,10 +427,73 @@ export class AdminService {
     return E.right(delUser.right);
   }
 
+  /**
+   * Remove user (not Admin) accounts by UIDs
+   * @param userUIDs User UIDs
+   * @returns an Either of boolean or error
+   */
+  async removeUserAccounts(userUIDs: string[]) {
+    const userDeleteResult: UserDeletionResult[] = [];
+
+    // step 1: fetch all users
+    const allUsersList = await this.userService.findUsersByIds(userUIDs);
+    if (allUsersList.length === 0) return E.left(USERS_NOT_FOUND);
+
+    // step 2: admin user can not be deleted without removing admin status/role
+    allUsersList.forEach((user) => {
+      if (user.isAdmin) {
+        userDeleteResult.push({
+          userUID: user.uid,
+          isDeleted: false,
+          errorMessage: ADMIN_CAN_NOT_BE_DELETED,
+        });
+      }
+    });
+
+    const nonAdminUsers = allUsersList.filter((user) => !user.isAdmin);
+    let deletedUserEmails: string[] = [];
+
+    // step 3: delete non-admin users
+    const deletionPromises = nonAdminUsers.map((user) => {
+      return this.userService
+        .deleteUserByUID(user)()
+        .then((res) => {
+          if (E.isLeft(res)) {
+            return {
+              userUID: user.uid,
+              isDeleted: false,
+              errorMessage: res.left,
+            } as UserDeletionResult;
+          }
+
+          deletedUserEmails.push(user.email);
+          return {
+            userUID: user.uid,
+            isDeleted: true,
+            errorMessage: null,
+          } as UserDeletionResult;
+        });
+    });
+    const promiseResult = await Promise.allSettled(deletionPromises);
+
+    // step 4: revoke all the invites sent to the deleted users
+    await this.revokeUserInvitations(deletedUserEmails);
+
+    // step 5: return the result
+    promiseResult.forEach((result) => {
+      if (result.status === 'fulfilled') {
+        userDeleteResult.push(result.value);
+      }
+    });
+
+    return E.right(userDeleteResult);
+  }
+
   /**
    * Make a user an admin
    * @param userUid User UID
    * @returns an Either of boolean or error
+   * @deprecated use makeUsersAdmin instead
    */
   async makeUserAdmin(userUID: string) {
     const admin = await this.userService.makeAdmin(userUID);
@@ -360,10 +501,22 @@ export class AdminService {
     return E.right(true);
   }
 
+  /**
+   * Make users to admin
+   * @param userUid User UIDs
+   * @returns an Either of boolean or error
+   */
+  async makeUsersAdmin(userUIDs: string[]) {
+    const isUpdated = await this.userService.makeAdmins(userUIDs);
+    if (E.isLeft(isUpdated)) return E.left(isUpdated.left);
+    return E.right(true);
+  }
+
   /**
    * Remove user as admin
    * @param userUid User UID
    * @returns an Either of boolean or error
+   * @deprecated use demoteUsersByAdmin instead
    */
   async removeUserAsAdmin(userUID: string) {
     const adminUsers = await this.userService.fetchAdminUsers();
@@ -374,6 +527,26 @@ export class AdminService {
     return E.right(true);
   }
 
+  /**
+   * Remove users as admin
+   * @param userUIDs User UIDs
+   * @returns an Either of boolean or error
+   */
+  async demoteUsersByAdmin(userUIDs: string[]) {
+    const adminUsers = await this.userService.fetchAdminUsers();
+
+    const remainingAdmins = adminUsers.filter(
+      (adminUser) => !userUIDs.includes(adminUser.uid),
+    );
+    if (remainingAdmins.length < 1) {
+      return E.left(ONLY_ONE_ADMIN_ACCOUNT);
+    }
+
+    const isUpdated = await this.userService.removeUsersAsAdmin(userUIDs);
+    if (E.isLeft(isUpdated)) return E.left(isUpdated.left);
+    return E.right(isUpdated.right);
+  }
+
   /**
    * Fetch list of all the Users in org
    * @returns number of users in the org

packages/hoppscotch-backend/src/admin/guards/rest-admin.guard.ts

@@ -0,0 +1,11 @@
+import { Injectable, ExecutionContext, CanActivate } from '@nestjs/common';
+
+@Injectable()
+export class RESTAdminGuard implements CanActivate {
+  canActivate(context: ExecutionContext): boolean {
+    const request = context.switchToHttp().getRequest();
+    const user = request.user;
+
+    return user.isAdmin;
+  }
+}

packages/hoppscotch-backend/src/admin/infra.resolver.ts

@@ -17,7 +17,10 @@ import { AuthUser } from 'src/types/AuthUser';
 import { throwErr } from 'src/utils';
 import * as E from 'fp-ts/Either';
 import { Admin } from './admin.model';
-import { PaginationArgs } from 'src/types/input-types.args';
+import {
+  OffsetPaginationArgs,
+  PaginationArgs,
+} from 'src/types/input-types.args';
 import { InvitedUser } from './invited-user.model';
 import { Team } from 'src/team/team.model';
 import { TeamInvitation } from 'src/team-invitation/team-invitation.model';
@@ -29,7 +32,8 @@ import {
   EnableAndDisableSSOArgs,
   InfraConfigArgs,
 } from 'src/infra-config/input-args';
-import { InfraConfigEnumForClient } from 'src/types/InfraConfig';
+import { InfraConfigEnum } from 'src/types/InfraConfig';
+import { ServiceStatus } from 'src/infra-config/helper';
 
 @UseGuards(GqlThrottlerGuard)
 @Resolver(() => Infra)
@@ -76,6 +80,7 @@ export class InfraResolver {
 
   @ResolveField(() => [User], {
     description: 'Returns a list of all the users in infra',
+    deprecationReason: 'Use allUsersV2 instead',
   })
   @UseGuards(GqlAuthGuard, GqlAdminGuard)
   async allUsers(@Args() args: PaginationArgs): Promise<AuthUser[]> {
@@ -83,11 +88,33 @@ export class InfraResolver {
     return users;
   }
 
+  @ResolveField(() => [User], {
+    description: 'Returns a list of all the users in infra',
+  })
+  @UseGuards(GqlAuthGuard, GqlAdminGuard)
+  async allUsersV2(
+    @Args({
+      name: 'searchString',
+      nullable: true,
+      description: 'Search on users displayName or email',
+    })
+    searchString: string,
+    @Args() paginationOption: OffsetPaginationArgs,
+  ): Promise<AuthUser[]> {
+    const users = await this.adminService.fetchUsersV2(
+      searchString,
+      paginationOption,
+    );
+    return users;
+  }
+
   @ResolveField(() => [InvitedUser], {
     description: 'Returns a list of all the invited users',
   })
-  async invitedUsers(): Promise<InvitedUser[]> {
-    const users = await this.adminService.fetchInvitedUsers();
+  async invitedUsers(
+    @Args() args: OffsetPaginationArgs,
+  ): Promise<InvitedUser[]> {
+    const users = await this.adminService.fetchInvitedUsers(args);
     return users;
   }
 
@@ -247,10 +274,10 @@ export class InfraResolver {
   async infraConfigs(
     @Args({
       name: 'configNames',
-      type: () => [InfraConfigEnumForClient],
+      type: () => [InfraConfigEnum],
       description: 'Configs to fetch',
     })
-    names: InfraConfigEnumForClient[],
+    names: InfraConfigEnum[],
   ) {
     const infraConfigs = await this.infraConfigService.getMany(names);
     if (E.isLeft(infraConfigs)) throwErr(infraConfigs.left);
@@ -284,6 +311,25 @@ export class InfraResolver {
     return updatedRes.right;
   }
 
+  @Mutation(() => Boolean, {
+    description: 'Enable or disable analytics collection',
+  })
+  @UseGuards(GqlAuthGuard, GqlAdminGuard)
+  async toggleAnalyticsCollection(
+    @Args({
+      name: 'status',
+      type: () => ServiceStatus,
+      description: 'Toggle analytics collection',
+    })
+    analyticsCollectionStatus: ServiceStatus,
+  ) {
+    const res = await this.infraConfigService.toggleAnalyticsCollection(
+      analyticsCollectionStatus,
+    );
+    if (E.isLeft(res)) throwErr(res.left);
+    return res.right;
+  }
+
   @Mutation(() => Boolean, {
     description: 'Reset Infra Configs with default values (.env)',
   })
@@ -306,7 +352,9 @@ export class InfraResolver {
     })
     providerInfo: EnableAndDisableSSOArgs[],
   ) {
-    const isUpdated = await this.infraConfigService.enableAndDisableSSO(providerInfo);
+    const isUpdated = await this.infraConfigService.enableAndDisableSSO(
+      providerInfo,
+    );
     if (E.isLeft(isUpdated)) throwErr(isUpdated.left);
 
     return true;

packages/hoppscotch-backend/src/app.module.ts

@@ -24,6 +24,8 @@ import { ConfigModule, ConfigService } from '@nestjs/config';
 import { InfraConfigModule } from './infra-config/infra-config.module';
 import { loadInfraConfiguration } from './infra-config/helper';
 import { MailerModule } from './mailer/mailer.module';
+import { PosthogModule } from './posthog/posthog.module';
+import { ScheduleModule } from '@nestjs/schedule';
 
 @Module({
   imports: [
@@ -96,6 +98,8 @@ import { MailerModule } from './mailer/mailer.module';
     UserCollectionModule,
     ShortcodeModule,
     InfraConfigModule,
+    PosthogModule,
+    ScheduleModule.forRoot(),
   ],
   providers: [GQLComplexityPlugin],
   controllers: [AppController],

packages/hoppscotch-backend/src/auth/auth.controller.ts

@@ -18,12 +18,7 @@ import { JwtAuthGuard } from './guards/jwt-auth.guard';
 import { GqlUser } from 'src/decorators/gql-user.decorator';
 import { AuthUser } from 'src/types/AuthUser';
 import { RTCookie } from 'src/decorators/rt-cookie.decorator';
-import {
-  AuthProvider,
-  authCookieHandler,
-  authProviderCheck,
-  throwHTTPErr,
-} from './helper';
+import { AuthProvider, authCookieHandler, authProviderCheck } from './helper';
 import { GoogleSSOGuard } from './guards/google-sso.guard';
 import { GithubSSOGuard } from './guards/github-sso.guard';
 import { MicrosoftSSOGuard } from './guards/microsoft-sso-.guard';
@@ -31,6 +26,7 @@ import { ThrottlerBehindProxyGuard } from 'src/guards/throttler-behind-proxy.gua
 import { SkipThrottle } from '@nestjs/throttler';
 import { AUTH_PROVIDER_NOT_SPECIFIED } from 'src/errors';
 import { ConfigService } from '@nestjs/config';
+import { throwHTTPErr } from 'src/utils';
 
 @UseGuards(ThrottlerBehindProxyGuard)
 @Controller({ path: 'auth', version: '1' })

packages/hoppscotch-backend/src/auth/auth.module.ts

@@ -12,7 +12,10 @@ import { GithubStrategy } from './strategies/github.strategy';
 import { MicrosoftStrategy } from './strategies/microsoft.strategy';
 import { AuthProvider, authProviderCheck } from './helper';
 import { ConfigModule, ConfigService } from '@nestjs/config';
-import { loadInfraConfiguration } from 'src/infra-config/helper';
+import {
+  isInfraConfigTablePopulated,
+  loadInfraConfiguration,
+} from 'src/infra-config/helper';
 import { InfraConfigModule } from 'src/infra-config/infra-config.module';
 
 @Module({
@@ -34,6 +37,11 @@ import { InfraConfigModule } from 'src/infra-config/infra-config.module';
 })
 export class AuthModule {
   static async register() {
+    const isInfraConfigPopulated = await isInfraConfigTablePopulated();
+    if (!isInfraConfigPopulated) {
+      return { module: AuthModule };
+    }
+
     const env = await loadInfraConfiguration();
     const allowedAuthProviders = env.INFRA.VITE_ALLOWED_AUTH_PROVIDERS;
 

packages/hoppscotch-backend/src/auth/auth.service.ts

@@ -24,7 +24,7 @@ import {
   RefreshTokenPayload,
 } from 'src/types/AuthTokens';
 import { JwtService } from '@nestjs/jwt';
-import { AuthError } from 'src/types/AuthError';
+import { RESTError } from 'src/types/RESTError';
 import { AuthUser, IsAdmin } from 'src/types/AuthUser';
 import { VerificationToken } from '@prisma/client';
 import { Origin } from './helper';
@@ -117,7 +117,7 @@ export class AuthService {
       userUid,
     );
     if (E.isLeft(updatedUser))
-      return E.left(<AuthError>{
+      return E.left(<RESTError>{
         message: updatedUser.left,
         statusCode: HttpStatus.NOT_FOUND,
       });
@@ -255,7 +255,7 @@ export class AuthService {
    */
   async verifyMagicLinkTokens(
     magicLinkIDTokens: VerifyMagicDto,
-  ): Promise<E.Right<AuthTokens> | E.Left<AuthError>> {
+  ): Promise<E.Right<AuthTokens> | E.Left<RESTError>> {
     const passwordlessTokens = await this.validatePasswordlessTokens(
       magicLinkIDTokens,
     );
@@ -373,7 +373,7 @@ export class AuthService {
     if (usersCount === 1) {
       const elevatedUser = await this.usersService.makeAdmin(user.uid);
       if (E.isLeft(elevatedUser))
-        return E.left(<AuthError>{
+        return E.left(<RESTError>{
           message: elevatedUser.left,
           statusCode: HttpStatus.NOT_FOUND,
         });

packages/hoppscotch-backend/src/auth/guards/github-sso.guard.ts

@@ -1,9 +1,10 @@
 import { CanActivate, ExecutionContext, Injectable } from '@nestjs/common';
 import { AuthGuard } from '@nestjs/passport';
-import { AuthProvider, authProviderCheck, throwHTTPErr } from '../helper';
+import { AuthProvider, authProviderCheck } from '../helper';
 import { Observable } from 'rxjs';
 import { AUTH_PROVIDER_NOT_SPECIFIED } from 'src/errors';
 import { ConfigService } from '@nestjs/config';
+import { throwHTTPErr } from 'src/utils';
 
 @Injectable()
 export class GithubSSOGuard extends AuthGuard('github') implements CanActivate {

packages/hoppscotch-backend/src/auth/guards/google-sso.guard.ts

@@ -1,9 +1,10 @@
 import { CanActivate, ExecutionContext, Injectable } from '@nestjs/common';
 import { AuthGuard } from '@nestjs/passport';
-import { AuthProvider, authProviderCheck, throwHTTPErr } from '../helper';
+import { AuthProvider, authProviderCheck } from '../helper';
 import { Observable } from 'rxjs';
 import { AUTH_PROVIDER_NOT_SPECIFIED } from 'src/errors';
 import { ConfigService } from '@nestjs/config';
+import { throwHTTPErr } from 'src/utils';
 
 @Injectable()
 export class GoogleSSOGuard extends AuthGuard('google') implements CanActivate {

packages/hoppscotch-backend/src/auth/guards/microsoft-sso-.guard.ts

@@ -1,9 +1,10 @@
 import { CanActivate, ExecutionContext, Injectable } from '@nestjs/common';
 import { AuthGuard } from '@nestjs/passport';
-import { AuthProvider, authProviderCheck, throwHTTPErr } from '../helper';
+import { AuthProvider, authProviderCheck } from '../helper';
 import { Observable } from 'rxjs';
 import { AUTH_PROVIDER_NOT_SPECIFIED } from 'src/errors';
 import { ConfigService } from '@nestjs/config';
+import { throwHTTPErr } from 'src/utils';
 
 @Injectable()
 export class MicrosoftSSOGuard

packages/hoppscotch-backend/src/auth/helper.ts

@@ -1,6 +1,5 @@
 import { HttpException, HttpStatus } from '@nestjs/common';
 import { DateTime } from 'luxon';
-import { AuthError } from 'src/types/AuthError';
 import { AuthTokens } from 'src/types/AuthTokens';
 import { Response } from 'express';
 import * as cookie from 'cookie';
@@ -25,15 +24,6 @@ export enum AuthProvider {
   EMAIL = 'EMAIL',
 }
 
-/**
- * This function allows throw to be used as an expression
- * @param errMessage Message present in the error message
- */
-export function throwHTTPErr(errorData: AuthError): never {
-  const { message, statusCode } = errorData;
-  throw new HttpException(message, statusCode);
-}
-
 /**
  * Sets and returns the cookies in the response object on successful authentication
  * @param res Express Response Object

packages/hoppscotch-backend/src/auth/strategies/github.strategy.ts

@@ -17,8 +17,8 @@ export class GithubStrategy extends PassportStrategy(Strategy) {
     super({
       clientID: configService.get('INFRA.GITHUB_CLIENT_ID'),
       clientSecret: configService.get('INFRA.GITHUB_CLIENT_SECRET'),
-      callbackURL: configService.get('GITHUB_CALLBACK_URL'),
-      scope: [configService.get('GITHUB_SCOPE')],
+      callbackURL: configService.get('INFRA.GITHUB_CALLBACK_URL'),
+      scope: [configService.get('INFRA.GITHUB_SCOPE')],
       store: true,
     });
   }

packages/hoppscotch-backend/src/auth/strategies/google.strategy.ts

@@ -17,8 +17,8 @@ export class GoogleStrategy extends PassportStrategy(Strategy) {
     super({
       clientID: configService.get('INFRA.GOOGLE_CLIENT_ID'),
       clientSecret: configService.get('INFRA.GOOGLE_CLIENT_SECRET'),
-      callbackURL: configService.get('GOOGLE_CALLBACK_URL'),
-      scope: configService.get('GOOGLE_SCOPE').split(','),
+      callbackURL: configService.get('INFRA.GOOGLE_CALLBACK_URL'),
+      scope: configService.get('INFRA.GOOGLE_SCOPE').split(','),
       passReqToCallback: true,
       store: true,
     });

packages/hoppscotch-backend/src/auth/strategies/microsoft.strategy.ts

@@ -17,9 +17,9 @@ export class MicrosoftStrategy extends PassportStrategy(Strategy) {
     super({
       clientID: configService.get('INFRA.MICROSOFT_CLIENT_ID'),
       clientSecret: configService.get('INFRA.MICROSOFT_CLIENT_SECRET'),
-      callbackURL: configService.get('MICROSOFT_CALLBACK_URL'),
-      scope: [configService.get('MICROSOFT_SCOPE')],
-      tenant: configService.get('MICROSOFT_TENANT'),
+      callbackURL: configService.get('INFRA.MICROSOFT_CALLBACK_URL'),
+      scope: [configService.get('INFRA.MICROSOFT_SCOPE')],
+      tenant: configService.get('INFRA.MICROSOFT_TENANT'),
       store: true,
     });
   }

packages/hoppscotch-backend/src/errors.ts

@@ -10,6 +10,14 @@ export const DUPLICATE_EMAIL = 'email/both_emails_cannot_be_same' as const;
 export const ONLY_ONE_ADMIN_ACCOUNT =
   'admin/only_one_admin_account_found' as const;
 
+/**
+ * Admin user can not be deleted
+ * To delete the admin user, first make the Admin user a normal user
+ * (AdminService)
+ */
+export const ADMIN_CAN_NOT_BE_DELETED =
+  'admin/admin_can_not_be_deleted' as const;
+
 /**
  * Token Authorization failed (Check 'Authorization' Header)
  * (GqlAuthGuard)
@@ -99,6 +107,13 @@ export const USER_IS_OWNER = 'user/is_owner' as const;
  */
 export const USER_IS_ADMIN = 'user/is_admin' as const;
 
+/**
+ * User invite deletion failure error due to invitation not found
+ * (AdminService)
+ */
+export const USER_INVITATION_DELETION_FAILED =
+  'user/invitation_deletion_failed' as const;
+
 /**
  * Teams not found
  * (TeamsService)
@@ -213,6 +228,12 @@ export const TEAM_COL_NOT_SAME_PARENT =
 export const TEAM_COL_SAME_NEXT_COLL =
   'team_coll/collection_and_next_collection_are_same';
 
+/**
+ * Team Collection search failed
+ * (TeamCollectionService)
+ */
+export const TEAM_COL_SEARCH_FAILED = 'team_coll/team_collection_search_failed';
+
 /**
  * Team Collection Re-Ordering Failed
  * (TeamCollectionService)
@@ -268,6 +289,13 @@ export const TEAM_NOT_OWNER = 'team_coll/team_not_owner' as const;
 export const TEAM_COLL_DATA_INVALID =
   'team_coll/team_coll_data_invalid' as const;
 
+/**
+ * Team Collection parent tree generation failed
+ * (TeamCollectionService)
+ */
+export const TEAM_COLL_PARENT_TREE_GEN_FAILED =
+  'team_coll/team_coll_parent_tree_generation_failed';
+
 /**
  * Tried to perform an action on a request that doesn't accept their member role level
  * (GqlRequestTeamMemberGuard)
@@ -293,6 +321,19 @@ export const TEAM_REQ_INVALID_TARGET_COLL_ID =
  */
 export const TEAM_REQ_REORDERING_FAILED = 'team_req/reordering_failed' as const;
 
+/**
+ * Team Request search failed
+ * (TeamRequestService)
+ */
+export const TEAM_REQ_SEARCH_FAILED = 'team_req/team_request_search_failed';
+
+/**
+ * Team Request parent tree generation failed
+ * (TeamRequestService)
+ */
+export const TEAM_REQ_PARENT_TREE_GEN_FAILED =
+  'team_req/team_req_parent_tree_generation_failed';
+
 /**
  * No Postmark Sender Email defined
  * (AuthService)
@@ -690,9 +731,22 @@ export const INFRA_CONFIG_INVALID_INPUT = 'infra_config/invalid_input' as const;
 export const INFRA_CONFIG_SERVICE_NOT_CONFIGURED =
   'infra_config/service_not_configured' as const;
 
+/**
+ * Infra Config update/fetch operation not allowed
+ * (InfraConfigService)
+ */
+export const INFRA_CONFIG_OPERATION_NOT_ALLOWED =
+  'infra_config/operation_not_allowed';
+
 /**
  * Error message for when the database table does not exist
  * (InfraConfigService)
  */
 export const DATABASE_TABLE_NOT_EXIST =
   'Database migration not found. Please check the documentation for assistance: https://docs.hoppscotch.io/documentation/self-host/community-edition/install-and-build#running-migrations';
+
+/**
+ * PostHog client is not initialized
+ * (InfraConfigService)
+ */
+export const POSTHOG_CLIENT_NOT_INITIALIZED = 'posthog/client_not_initialized';

packages/hoppscotch-backend/src/infra-config/helper.ts

@@ -1,8 +1,12 @@
 import { AuthProvider } from 'src/auth/helper';
-import { AUTH_PROVIDER_NOT_CONFIGURED } from 'src/errors';
+import {
+  AUTH_PROVIDER_NOT_CONFIGURED,
+  DATABASE_TABLE_NOT_EXIST,
+} from 'src/errors';
 import { PrismaService } from 'src/prisma/prisma.service';
 import { InfraConfigEnum } from 'src/types/InfraConfig';
 import { throwErr } from 'src/utils';
+import { randomBytes } from 'crypto';
 
 export enum ServiceStatus {
   ENABLE = 'ENABLE',
@@ -13,14 +17,21 @@ const AuthProviderConfigurations = {
   [AuthProvider.GOOGLE]: [
     InfraConfigEnum.GOOGLE_CLIENT_ID,
     InfraConfigEnum.GOOGLE_CLIENT_SECRET,
+    InfraConfigEnum.GOOGLE_CALLBACK_URL,
+    InfraConfigEnum.GOOGLE_SCOPE,
   ],
   [AuthProvider.GITHUB]: [
     InfraConfigEnum.GITHUB_CLIENT_ID,
     InfraConfigEnum.GITHUB_CLIENT_SECRET,
+    InfraConfigEnum.GITHUB_CALLBACK_URL,
+    InfraConfigEnum.GITHUB_SCOPE,
   ],
   [AuthProvider.MICROSOFT]: [
     InfraConfigEnum.MICROSOFT_CLIENT_ID,
     InfraConfigEnum.MICROSOFT_CLIENT_SECRET,
+    InfraConfigEnum.MICROSOFT_CALLBACK_URL,
+    InfraConfigEnum.MICROSOFT_SCOPE,
+    InfraConfigEnum.MICROSOFT_TENANT,
   ],
   [AuthProvider.EMAIL]: [
     InfraConfigEnum.MAILER_SMTP_URL,
@@ -53,6 +64,125 @@ export async function loadInfraConfiguration() {
   }
 }
 
+/**
+ * Read the default values from .env file and return them as an array
+ * @returns Array of default infra configs
+ */
+export async function getDefaultInfraConfigs(): Promise<
+  { name: InfraConfigEnum; value: string }[]
+> {
+  const prisma = new PrismaService();
+
+  // Prepare rows for 'infra_config' table with default values (from .env) for each 'name'
+  const infraConfigDefaultObjs: { name: InfraConfigEnum; value: string }[] = [
+    {
+      name: InfraConfigEnum.MAILER_SMTP_URL,
+      value: process.env.MAILER_SMTP_URL,
+    },
+    {
+      name: InfraConfigEnum.MAILER_ADDRESS_FROM,
+      value: process.env.MAILER_ADDRESS_FROM,
+    },
+    {
+      name: InfraConfigEnum.GOOGLE_CLIENT_ID,
+      value: process.env.GOOGLE_CLIENT_ID,
+    },
+    {
+      name: InfraConfigEnum.GOOGLE_CLIENT_SECRET,
+      value: process.env.GOOGLE_CLIENT_SECRET,
+    },
+    {
+      name: InfraConfigEnum.GOOGLE_CALLBACK_URL,
+      value: process.env.GOOGLE_CALLBACK_URL,
+    },
+    {
+      name: InfraConfigEnum.GOOGLE_SCOPE,
+      value: process.env.GOOGLE_SCOPE,
+    },
+    {
+      name: InfraConfigEnum.GITHUB_CLIENT_ID,
+      value: process.env.GITHUB_CLIENT_ID,
+    },
+    {
+      name: InfraConfigEnum.GITHUB_CLIENT_SECRET,
+      value: process.env.GITHUB_CLIENT_SECRET,
+    },
+    {
+      name: InfraConfigEnum.GITHUB_CALLBACK_URL,
+      value: process.env.GITHUB_CALLBACK_URL,
+    },
+    {
+      name: InfraConfigEnum.GITHUB_SCOPE,
+      value: process.env.GITHUB_SCOPE,
+    },
+    {
+      name: InfraConfigEnum.MICROSOFT_CLIENT_ID,
+      value: process.env.MICROSOFT_CLIENT_ID,
+    },
+    {
+      name: InfraConfigEnum.MICROSOFT_CLIENT_SECRET,
+      value: process.env.MICROSOFT_CLIENT_SECRET,
+    },
+    {
+      name: InfraConfigEnum.MICROSOFT_CALLBACK_URL,
+      value: process.env.MICROSOFT_CALLBACK_URL,
+    },
+    {
+      name: InfraConfigEnum.MICROSOFT_SCOPE,
+      value: process.env.MICROSOFT_SCOPE,
+    },
+    {
+      name: InfraConfigEnum.MICROSOFT_TENANT,
+      value: process.env.MICROSOFT_TENANT,
+    },
+    {
+      name: InfraConfigEnum.VITE_ALLOWED_AUTH_PROVIDERS,
+      value: getConfiguredSSOProviders(),
+    },
+    {
+      name: InfraConfigEnum.ALLOW_ANALYTICS_COLLECTION,
+      value: false.toString(),
+    },
+    {
+      name: InfraConfigEnum.ANALYTICS_USER_ID,
+      value: generateAnalyticsUserId(),
+    },
+    {
+      name: InfraConfigEnum.IS_FIRST_TIME_INFRA_SETUP,
+      value: (await prisma.infraConfig.count()) === 0 ? 'true' : 'false',
+    },
+  ];
+
+  return infraConfigDefaultObjs;
+}
+
+/**
+ * Verify if 'infra_config' table is loaded with all entries
+ * @returns boolean
+ */
+export async function isInfraConfigTablePopulated(): Promise<boolean> {
+  const prisma = new PrismaService();
+  try {
+    const dbInfraConfigs = await prisma.infraConfig.findMany();
+    const infraConfigDefaultObjs = await getDefaultInfraConfigs();
+
+    const propsRemainingToInsert = infraConfigDefaultObjs.filter(
+      (p) => !dbInfraConfigs.find((e) => e.name === p.name),
+    );
+
+    if (propsRemainingToInsert.length > 0) {
+      console.log(
+        'Infra Config table is not populated with all entries. Populating now...',
+      );
+      return false;
+    }
+
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+
 /**
  * Stop the app after 5 seconds
  * (Docker will re-start the app)
@@ -104,3 +234,12 @@ export function getConfiguredSSOProviders() {
 
   return configuredAuthProviders.join(',');
 }
+
+/**
+ * Generate a hashed valued for analytics
+ * @returns Generated hashed value
+ */
+export function generateAnalyticsUserId() {
+  const hashedUserID = randomBytes(20).toString('hex');
+  return hashedUserID;
+}

packages/hoppscotch-backend/src/infra-config/infra-config.controller.ts

@@ -0,0 +1,47 @@
+import { Controller, Get, HttpStatus, Put, UseGuards } from '@nestjs/common';
+import { ThrottlerBehindProxyGuard } from 'src/guards/throttler-behind-proxy.guard';
+import { InfraConfigService } from './infra-config.service';
+import * as E from 'fp-ts/Either';
+import { JwtAuthGuard } from 'src/auth/guards/jwt-auth.guard';
+import { RESTAdminGuard } from 'src/admin/guards/rest-admin.guard';
+import { RESTError } from 'src/types/RESTError';
+import { InfraConfigEnum } from 'src/types/InfraConfig';
+import { throwHTTPErr } from 'src/utils';
+
+@UseGuards(ThrottlerBehindProxyGuard)
+@Controller({ path: 'site', version: '1' })
+export class SiteController {
+  constructor(private infraConfigService: InfraConfigService) {}
+
+  @Get('setup')
+  @UseGuards(JwtAuthGuard, RESTAdminGuard)
+  async fetchSetupInfo() {
+    const status = await this.infraConfigService.get(
+      InfraConfigEnum.IS_FIRST_TIME_INFRA_SETUP,
+    );
+
+    if (E.isLeft(status))
+      throwHTTPErr(<RESTError>{
+        message: status.left,
+        statusCode: HttpStatus.NOT_FOUND,
+      });
+    return status.right;
+  }
+
+  @Put('setup')
+  @UseGuards(JwtAuthGuard, RESTAdminGuard)
+  async setSetupAsComplete() {
+    const res = await this.infraConfigService.update(
+      InfraConfigEnum.IS_FIRST_TIME_INFRA_SETUP,
+      false.toString(),
+      false,
+    );
+
+    if (E.isLeft(res))
+      throwHTTPErr(<RESTError>{
+        message: res.left,
+        statusCode: HttpStatus.FORBIDDEN,
+      });
+    return res.right;
+  }
+}

packages/hoppscotch-backend/src/infra-config/infra-config.model.ts

@@ -1,6 +1,6 @@
 import { Field, ObjectType, registerEnumType } from '@nestjs/graphql';
 import { AuthProvider } from 'src/auth/helper';
-import { InfraConfigEnumForClient } from 'src/types/InfraConfig';
+import { InfraConfigEnum } from 'src/types/InfraConfig';
 import { ServiceStatus } from './helper';
 
 @ObjectType()
@@ -8,7 +8,7 @@ export class InfraConfig {
   @Field({
     description: 'Infra Config Name',
   })
-  name: InfraConfigEnumForClient;
+  name: InfraConfigEnum;
 
   @Field({
     description: 'Infra Config Value',
@@ -16,7 +16,7 @@ export class InfraConfig {
   value: string;
 }
 
-registerEnumType(InfraConfigEnumForClient, {
+registerEnumType(InfraConfigEnum, {
   name: 'InfraConfigEnum',
 });
 

packages/hoppscotch-backend/src/infra-config/infra-config.module.ts

@@ -1,10 +1,12 @@
 import { Module } from '@nestjs/common';
 import { InfraConfigService } from './infra-config.service';
 import { PrismaModule } from 'src/prisma/prisma.module';
+import { SiteController } from './infra-config.controller';
 
 @Module({
   imports: [PrismaModule],
   providers: [InfraConfigService],
   exports: [InfraConfigService],
+  controllers: [SiteController],
 })
 export class InfraConfigModule {}

packages/hoppscotch-backend/src/infra-config/infra-config.service.spec.ts

@@ -1,13 +1,16 @@
 import { mockDeep, mockReset } from 'jest-mock-extended';
 import { PrismaService } from 'src/prisma/prisma.service';
 import { InfraConfigService } from './infra-config.service';
+import { InfraConfigEnum } from 'src/types/InfraConfig';
 import {
-  InfraConfigEnum,
-  InfraConfigEnumForClient,
-} from 'src/types/InfraConfig';
-import { INFRA_CONFIG_NOT_FOUND, INFRA_CONFIG_UPDATE_FAILED } from 'src/errors';
+  INFRA_CONFIG_NOT_FOUND,
+  INFRA_CONFIG_OPERATION_NOT_ALLOWED,
+  INFRA_CONFIG_UPDATE_FAILED,
+} from 'src/errors';
 import { ConfigService } from '@nestjs/config';
 import * as helper from './helper';
+import { InfraConfig as dbInfraConfig } from '@prisma/client';
+import { InfraConfig } from './infra-config.model';
 
 const mockPrisma = mockDeep<PrismaService>();
 const mockConfigService = mockDeep<ConfigService>();
@@ -19,12 +22,82 @@ const infraConfigService = new InfraConfigService(
   mockConfigService,
 );
 
+const INITIALIZED_DATE_CONST = new Date();
+const dbInfraConfigs: dbInfraConfig[] = [
+  {
+    id: '3',
+    name: InfraConfigEnum.GOOGLE_CLIENT_ID,
+    value: 'abcdefghijkl',
+    active: true,
+    createdOn: INITIALIZED_DATE_CONST,
+    updatedOn: INITIALIZED_DATE_CONST,
+  },
+  {
+    id: '4',
+    name: InfraConfigEnum.VITE_ALLOWED_AUTH_PROVIDERS,
+    value: 'google',
+    active: true,
+    createdOn: INITIALIZED_DATE_CONST,
+    updatedOn: INITIALIZED_DATE_CONST,
+  },
+];
+const infraConfigs: InfraConfig[] = [
+  {
+    name: dbInfraConfigs[0].name as InfraConfigEnum,
+    value: dbInfraConfigs[0].value,
+  },
+  {
+    name: dbInfraConfigs[1].name as InfraConfigEnum,
+    value: dbInfraConfigs[1].value,
+  },
+];
+
 beforeEach(() => {
   mockReset(mockPrisma);
 });
 
 describe('InfraConfigService', () => {
   describe('update', () => {
+    it('should update the infra config without backend server restart', async () => {
+      const name = InfraConfigEnum.GOOGLE_CLIENT_ID;
+      const value = 'true';
+
+      mockPrisma.infraConfig.update.mockResolvedValueOnce({
+        id: '',
+        name,
+        value,
+        active: true,
+        createdOn: new Date(),
+        updatedOn: new Date(),
+      });
+
+      jest.spyOn(helper, 'stopApp').mockReturnValueOnce();
+      const result = await infraConfigService.update(name, value);
+
+      expect(helper.stopApp).not.toHaveBeenCalled();
+      expect(result).toEqualRight({ name, value });
+    });
+
+    it('should update the infra config with backend server restart', async () => {
+      const name = InfraConfigEnum.GOOGLE_CLIENT_ID;
+      const value = 'true';
+
+      mockPrisma.infraConfig.update.mockResolvedValueOnce({
+        id: '',
+        name,
+        value,
+        active: true,
+        createdOn: new Date(),
+        updatedOn: new Date(),
+      });
+      jest.spyOn(helper, 'stopApp').mockReturnValueOnce();
+
+      const result = await infraConfigService.update(name, value, true);
+
+      expect(helper.stopApp).toHaveBeenCalledTimes(1);
+      expect(result).toEqualRight({ name, value });
+    });
+
     it('should update the infra config', async () => {
       const name = InfraConfigEnum.GOOGLE_CLIENT_ID;
       const value = 'true';
@@ -71,7 +144,7 @@ describe('InfraConfigService', () => {
 
   describe('get', () => {
     it('should get the infra config', async () => {
-      const name = InfraConfigEnumForClient.GOOGLE_CLIENT_ID;
+      const name = InfraConfigEnum.GOOGLE_CLIENT_ID;
       const value = 'true';
 
       mockPrisma.infraConfig.findUniqueOrThrow.mockResolvedValueOnce({
@@ -87,7 +160,7 @@ describe('InfraConfigService', () => {
     });
 
     it('should pass correct params to prisma findUnique', async () => {
-      const name = InfraConfigEnumForClient.GOOGLE_CLIENT_ID;
+      const name = InfraConfigEnum.GOOGLE_CLIENT_ID;
 
       await infraConfigService.get(name);
 
@@ -98,7 +171,7 @@ describe('InfraConfigService', () => {
     });
 
     it('should throw an error if the infra config does not exist', async () => {
-      const name = InfraConfigEnumForClient.GOOGLE_CLIENT_ID;
+      const name = InfraConfigEnum.GOOGLE_CLIENT_ID;
 
       mockPrisma.infraConfig.findUniqueOrThrow.mockRejectedValueOnce('null');
 
@@ -106,4 +179,45 @@ describe('InfraConfigService', () => {
       expect(result).toEqualLeft(INFRA_CONFIG_NOT_FOUND);
     });
   });
+
+  describe('getMany', () => {
+    it('should throw error if any disallowed names are provided', async () => {
+      const disallowedNames = [InfraConfigEnum.VITE_ALLOWED_AUTH_PROVIDERS];
+      const result = await infraConfigService.getMany(disallowedNames);
+
+      expect(result).toEqualLeft(INFRA_CONFIG_OPERATION_NOT_ALLOWED);
+    });
+    it('should resolve right with disallowed names if `checkDisallowed` parameter passed', async () => {
+      const disallowedNames = [InfraConfigEnum.VITE_ALLOWED_AUTH_PROVIDERS];
+
+      const dbInfraConfigResponses = dbInfraConfigs.filter((dbConfig) =>
+        disallowedNames.includes(dbConfig.name as InfraConfigEnum),
+      );
+      mockPrisma.infraConfig.findMany.mockResolvedValueOnce(
+        dbInfraConfigResponses,
+      );
+
+      const result = await infraConfigService.getMany(disallowedNames, false);
+
+      expect(result).toEqualRight(
+        infraConfigs.filter((i) => disallowedNames.includes(i.name)),
+      );
+    });
+
+    it('should return right with infraConfigs if Prisma query succeeds', async () => {
+      const allowedNames = [InfraConfigEnum.GOOGLE_CLIENT_ID];
+
+      const dbInfraConfigResponses = dbInfraConfigs.filter((dbConfig) =>
+        allowedNames.includes(dbConfig.name as InfraConfigEnum),
+      );
+      mockPrisma.infraConfig.findMany.mockResolvedValueOnce(
+        dbInfraConfigResponses,
+      );
+
+      const result = await infraConfigService.getMany(allowedNames);
+      expect(result).toEqualRight(
+        infraConfigs.filter((i) => allowedNames.includes(i.name)),
+      );
+    });
+  });
 });

packages/hoppscotch-backend/src/infra-config/infra-config.service.ts

@@ -3,23 +3,25 @@ import { InfraConfig } from './infra-config.model';
 import { PrismaService } from 'src/prisma/prisma.service';
 import { InfraConfig as DBInfraConfig } from '@prisma/client';
 import * as E from 'fp-ts/Either';
-import {
-  InfraConfigEnum,
-  InfraConfigEnumForClient,
-} from 'src/types/InfraConfig';
+import { InfraConfigEnum } from 'src/types/InfraConfig';
 import {
   AUTH_PROVIDER_NOT_SPECIFIED,
   DATABASE_TABLE_NOT_EXIST,
   INFRA_CONFIG_INVALID_INPUT,
   INFRA_CONFIG_NOT_FOUND,
-  INFRA_CONFIG_NOT_LISTED,
   INFRA_CONFIG_RESET_FAILED,
   INFRA_CONFIG_UPDATE_FAILED,
   INFRA_CONFIG_SERVICE_NOT_CONFIGURED,
+  INFRA_CONFIG_OPERATION_NOT_ALLOWED,
 } from 'src/errors';
-import { throwErr, validateSMTPEmail, validateSMTPUrl } from 'src/utils';
+import {
+  throwErr,
+  validateSMTPEmail,
+  validateSMTPUrl,
+  validateUrl,
+} from 'src/utils';
 import { ConfigService } from '@nestjs/config';
-import { ServiceStatus, getConfiguredSSOProviders, stopApp } from './helper';
+import { ServiceStatus, getDefaultInfraConfigs, stopApp } from './helper';
 import { EnableAndDisableSSOArgs, InfraConfigArgs } from './input-args';
 import { AuthProvider } from 'src/auth/helper';
 
@@ -30,70 +32,32 @@ export class InfraConfigService implements OnModuleInit {
     private readonly configService: ConfigService,
   ) {}
 
+  // Following fields are not updatable by `infraConfigs` Mutation. Use dedicated mutations for these fields instead.
+  EXCLUDE_FROM_UPDATE_CONFIGS = [
+    InfraConfigEnum.VITE_ALLOWED_AUTH_PROVIDERS,
+    InfraConfigEnum.ALLOW_ANALYTICS_COLLECTION,
+    InfraConfigEnum.ANALYTICS_USER_ID,
+    InfraConfigEnum.IS_FIRST_TIME_INFRA_SETUP,
+  ];
+  // Following fields can not be fetched by `infraConfigs` Query. Use dedicated queries for these fields instead.
+  EXCLUDE_FROM_FETCH_CONFIGS = [
+    InfraConfigEnum.VITE_ALLOWED_AUTH_PROVIDERS,
+    InfraConfigEnum.ANALYTICS_USER_ID,
+    InfraConfigEnum.IS_FIRST_TIME_INFRA_SETUP,
+  ];
+
   async onModuleInit() {
     await this.initializeInfraConfigTable();
   }
 
-  getDefaultInfraConfigs(): { name: InfraConfigEnum; value: string }[] {
-    // Prepare rows for 'infra_config' table with default values (from .env) for each 'name'
-    const infraConfigDefaultObjs: { name: InfraConfigEnum; value: string }[] = [
-      {
-        name: InfraConfigEnum.MAILER_SMTP_URL,
-        value: process.env.MAILER_SMTP_URL,
-      },
-      {
-        name: InfraConfigEnum.MAILER_ADDRESS_FROM,
-        value: process.env.MAILER_ADDRESS_FROM,
-      },
-      {
-        name: InfraConfigEnum.GOOGLE_CLIENT_ID,
-        value: process.env.GOOGLE_CLIENT_ID,
-      },
-      {
-        name: InfraConfigEnum.GOOGLE_CLIENT_SECRET,
-        value: process.env.GOOGLE_CLIENT_SECRET,
-      },
-      {
-        name: InfraConfigEnum.GITHUB_CLIENT_ID,
-        value: process.env.GITHUB_CLIENT_ID,
-      },
-      {
-        name: InfraConfigEnum.GITHUB_CLIENT_SECRET,
-        value: process.env.GITHUB_CLIENT_SECRET,
-      },
-      {
-        name: InfraConfigEnum.MICROSOFT_CLIENT_ID,
-        value: process.env.MICROSOFT_CLIENT_ID,
-      },
-      {
-        name: InfraConfigEnum.MICROSOFT_CLIENT_SECRET,
-        value: process.env.MICROSOFT_CLIENT_SECRET,
-      },
-      {
-        name: InfraConfigEnum.VITE_ALLOWED_AUTH_PROVIDERS,
-        value: getConfiguredSSOProviders(),
-      },
-    ];
-
-    return infraConfigDefaultObjs;
-  }
-
   /**
    * Initialize the 'infra_config' table with values from .env
    * @description This function create rows 'infra_config' in very first time (only once)
    */
   async initializeInfraConfigTable() {
     try {
-      // Get all the 'names' of the properties to be saved in the 'infra_config' table
-      const enumValues = Object.values(InfraConfigEnum);
-
       // Fetch the default values (value in .env) for configs to be saved in 'infra_config' table
-      const infraConfigDefaultObjs = this.getDefaultInfraConfigs();
-
-      // Check if all the 'names' are listed in the default values
-      if (enumValues.length !== infraConfigDefaultObjs.length) {
-        throw new Error(INFRA_CONFIG_NOT_LISTED);
-      }
+      const infraConfigDefaultObjs = await getDefaultInfraConfigs();
 
       // Eliminate the rows (from 'infraConfigDefaultObjs') that are already present in the database table
       const dbInfraConfigs = await this.prisma.infraConfig.findMany();
@@ -147,12 +111,10 @@ export class InfraConfigService implements OnModuleInit {
    * Update InfraConfig by name
    * @param name Name of the InfraConfig
    * @param value Value of the InfraConfig
+   * @param restartEnabled If true, restart the app after updating the InfraConfig
    * @returns InfraConfig model
    */
-  async update(
-    name: InfraConfigEnumForClient | InfraConfigEnum,
-    value: string,
-  ) {
+  async update(name: InfraConfigEnum, value: string, restartEnabled = false) {
     const isValidate = this.validateEnvValues([{ name, value }]);
     if (E.isLeft(isValidate)) return E.left(isValidate.left);
 
@@ -162,7 +124,7 @@ export class InfraConfigService implements OnModuleInit {
         data: { value },
       });
 
-      stopApp();
+      if (restartEnabled) stopApp();
 
       return E.right(this.cast(infraConfig));
     } catch (e) {
@@ -176,6 +138,11 @@ export class InfraConfigService implements OnModuleInit {
    * @returns InfraConfig model
    */
   async updateMany(infraConfigs: InfraConfigArgs[]) {
+    for (let i = 0; i < infraConfigs.length; i++) {
+      if (this.EXCLUDE_FROM_UPDATE_CONFIGS.includes(infraConfigs[i].name))
+        return E.left(INFRA_CONFIG_OPERATION_NOT_ALLOWED);
+    }
+
     const isValidate = this.validateEnvValues(infraConfigs);
     if (E.isLeft(isValidate)) return E.left(isValidate.left);
 
@@ -209,12 +176,26 @@ export class InfraConfigService implements OnModuleInit {
   ) {
     switch (service) {
       case AuthProvider.GOOGLE:
-        return configMap.GOOGLE_CLIENT_ID && configMap.GOOGLE_CLIENT_SECRET;
+        return (
+          configMap.GOOGLE_CLIENT_ID &&
+          configMap.GOOGLE_CLIENT_SECRET &&
+          configMap.GOOGLE_CALLBACK_URL &&
+          configMap.GOOGLE_SCOPE
+        );
       case AuthProvider.GITHUB:
-        return configMap.GITHUB_CLIENT_ID && configMap.GITHUB_CLIENT_SECRET;
+        return (
+          configMap.GITHUB_CLIENT_ID &&
+          configMap.GITHUB_CLIENT_SECRET &&
+          configMap.GITHUB_CALLBACK_URL &&
+          configMap.GITHUB_SCOPE
+        );
       case AuthProvider.MICROSOFT:
         return (
-          configMap.MICROSOFT_CLIENT_ID && configMap.MICROSOFT_CLIENT_SECRET
+          configMap.MICROSOFT_CLIENT_ID &&
+          configMap.MICROSOFT_CLIENT_SECRET &&
+          configMap.MICROSOFT_CALLBACK_URL &&
+          configMap.MICROSOFT_SCOPE &&
+          configMap.MICROSOFT_TENANT
         );
       case AuthProvider.EMAIL:
         return configMap.MAILER_SMTP_URL && configMap.MAILER_ADDRESS_FROM;
@@ -223,6 +204,22 @@ export class InfraConfigService implements OnModuleInit {
     }
   }
 
+  /**
+   * Enable or Disable Analytics Collection
+   *
+   * @param status Status to enable or disable
+   * @returns Boolean of status of analytics collection
+   */
+  async toggleAnalyticsCollection(status: ServiceStatus) {
+    const isUpdated = await this.update(
+      InfraConfigEnum.ALLOW_ANALYTICS_COLLECTION,
+      status === ServiceStatus.ENABLE ? 'true' : 'false',
+    );
+
+    if (E.isLeft(isUpdated)) return E.left(isUpdated.left);
+    return E.right(isUpdated.right.value === 'true');
+  }
+
   /**
    * Enable or Disable SSO for login/signup
    * @param provider Auth Provider to enable or disable
@@ -261,6 +258,7 @@ export class InfraConfigService implements OnModuleInit {
     const isUpdated = await this.update(
       InfraConfigEnum.VITE_ALLOWED_AUTH_PROVIDERS,
       updatedAuthProviders.join(','),
+      true,
     );
     if (E.isLeft(isUpdated)) return E.left(isUpdated.left);
 
@@ -272,7 +270,7 @@ export class InfraConfigService implements OnModuleInit {
    * @param name Name of the InfraConfig
    * @returns InfraConfig model
    */
-  async get(name: InfraConfigEnumForClient) {
+  async get(name: InfraConfigEnum) {
     try {
       const infraConfig = await this.prisma.infraConfig.findUniqueOrThrow({
         where: { name },
@@ -289,7 +287,15 @@ export class InfraConfigService implements OnModuleInit {
    * @param names Names of the InfraConfigs
    * @returns InfraConfig model
    */
-  async getMany(names: InfraConfigEnumForClient[]) {
+  async getMany(names: InfraConfigEnum[], checkDisallowedKeys: boolean = true) {
+    if (checkDisallowedKeys) {
+      // Check if the names are allowed to fetch by client
+      for (let i = 0; i < names.length; i++) {
+        if (this.EXCLUDE_FROM_FETCH_CONFIGS.includes(names[i]))
+          return E.left(INFRA_CONFIG_OPERATION_NOT_ALLOWED);
+      }
+    }
+
     try {
       const infraConfigs = await this.prisma.infraConfig.findMany({
         where: { name: { in: names } },
@@ -316,13 +322,24 @@ export class InfraConfigService implements OnModuleInit {
    */
   async reset() {
     try {
-      const infraConfigDefaultObjs = this.getDefaultInfraConfigs();
+      const infraConfigDefaultObjs = await getDefaultInfraConfigs();
 
       await this.prisma.infraConfig.deleteMany({
         where: { name: { in: infraConfigDefaultObjs.map((p) => p.name) } },
       });
+
+      // Hardcode t
+      const updatedInfraConfigDefaultObjs = infraConfigDefaultObjs.filter(
+        (obj) => obj.name !== InfraConfigEnum.IS_FIRST_TIME_INFRA_SETUP,
+      );
       await this.prisma.infraConfig.createMany({
-        data: infraConfigDefaultObjs,
+        data: [
+          ...updatedInfraConfigDefaultObjs,
+          {
+            name: InfraConfigEnum.IS_FIRST_TIME_INFRA_SETUP,
+            value: 'true',
+          },
+        ],
       });
 
       stopApp();
@@ -338,36 +355,60 @@ export class InfraConfigService implements OnModuleInit {
    */
   validateEnvValues(
     infraConfigs: {
-      name: InfraConfigEnumForClient | InfraConfigEnum;
+      name: InfraConfigEnum;
       value: string;
     }[],
   ) {
     for (let i = 0; i < infraConfigs.length; i++) {
       switch (infraConfigs[i].name) {
-        case InfraConfigEnumForClient.MAILER_SMTP_URL:
+        case InfraConfigEnum.MAILER_SMTP_URL:
           const isValidUrl = validateSMTPUrl(infraConfigs[i].value);
           if (!isValidUrl) return E.left(INFRA_CONFIG_INVALID_INPUT);
           break;
-        case InfraConfigEnumForClient.MAILER_ADDRESS_FROM:
+        case InfraConfigEnum.MAILER_ADDRESS_FROM:
           const isValidEmail = validateSMTPEmail(infraConfigs[i].value);
           if (!isValidEmail) return E.left(INFRA_CONFIG_INVALID_INPUT);
           break;
-        case InfraConfigEnumForClient.GOOGLE_CLIENT_ID:
+        case InfraConfigEnum.GOOGLE_CLIENT_ID:
           if (!infraConfigs[i].value) return E.left(INFRA_CONFIG_INVALID_INPUT);
           break;
-        case InfraConfigEnumForClient.GOOGLE_CLIENT_SECRET:
+        case InfraConfigEnum.GOOGLE_CLIENT_SECRET:
           if (!infraConfigs[i].value) return E.left(INFRA_CONFIG_INVALID_INPUT);
           break;
-        case InfraConfigEnumForClient.GITHUB_CLIENT_ID:
+        case InfraConfigEnum.GOOGLE_CALLBACK_URL:
+          if (!validateUrl(infraConfigs[i].value))
+            return E.left(INFRA_CONFIG_INVALID_INPUT);
+          break;
+        case InfraConfigEnum.GOOGLE_SCOPE:
           if (!infraConfigs[i].value) return E.left(INFRA_CONFIG_INVALID_INPUT);
           break;
-        case InfraConfigEnumForClient.GITHUB_CLIENT_SECRET:
+        case InfraConfigEnum.GITHUB_CLIENT_ID:
           if (!infraConfigs[i].value) return E.left(INFRA_CONFIG_INVALID_INPUT);
           break;
-        case InfraConfigEnumForClient.MICROSOFT_CLIENT_ID:
+        case InfraConfigEnum.GITHUB_CLIENT_SECRET:
           if (!infraConfigs[i].value) return E.left(INFRA_CONFIG_INVALID_INPUT);
           break;
-        case InfraConfigEnumForClient.MICROSOFT_CLIENT_SECRET:
+        case InfraConfigEnum.GITHUB_CALLBACK_URL:
+          if (!validateUrl(infraConfigs[i].value))
+            return E.left(INFRA_CONFIG_INVALID_INPUT);
+          break;
+        case InfraConfigEnum.GITHUB_SCOPE:
+          if (!infraConfigs[i].value) return E.left(INFRA_CONFIG_INVALID_INPUT);
+          break;
+        case InfraConfigEnum.MICROSOFT_CLIENT_ID:
+          if (!infraConfigs[i].value) return E.left(INFRA_CONFIG_INVALID_INPUT);
+          break;
+        case InfraConfigEnum.MICROSOFT_CLIENT_SECRET:
+          if (!infraConfigs[i].value) return E.left(INFRA_CONFIG_INVALID_INPUT);
+          break;
+        case InfraConfigEnum.MICROSOFT_CALLBACK_URL:
+          if (!validateUrl(infraConfigs[i].value))
+            return E.left(INFRA_CONFIG_INVALID_INPUT);
+          break;
+        case InfraConfigEnum.MICROSOFT_SCOPE:
+          if (!infraConfigs[i].value) return E.left(INFRA_CONFIG_INVALID_INPUT);
+          break;
+        case InfraConfigEnum.MICROSOFT_TENANT:
           if (!infraConfigs[i].value) return E.left(INFRA_CONFIG_INVALID_INPUT);
           break;
         default:

packages/hoppscotch-backend/src/infra-config/input-args.ts

@@ -1,14 +1,14 @@
 import { Field, InputType } from '@nestjs/graphql';
-import { InfraConfigEnumForClient } from 'src/types/InfraConfig';
+import { InfraConfigEnum } from 'src/types/InfraConfig';
 import { ServiceStatus } from './helper';
 import { AuthProvider } from 'src/auth/helper';
 
 @InputType()
 export class InfraConfigArgs {
-  @Field(() => InfraConfigEnumForClient, {
+  @Field(() => InfraConfigEnum, {
     description: 'Infra Config Name',
   })
-  name: InfraConfigEnumForClient;
+  name: InfraConfigEnum;
 
   @Field({
     description: 'Infra Config Value',

packages/hoppscotch-backend/src/mailer/mailer.service.ts

@@ -25,7 +25,7 @@ export class MailerService {
   ): string {
     switch (mailDesc.template) {
       case 'team-invitation':
-        return `${mailDesc.variables.invitee} invited you to join ${mailDesc.variables.invite_team_name} in Hoppscotch`;
+        return `A user has invited you to join a team workspace in Hoppscotch`;
 
       case 'user-invitation':
         return 'Sign in to Hoppscotch';

packages/hoppscotch-backend/src/mailer/templates/team-invitation.hbs

@@ -27,6 +27,12 @@
       color: #3869D4;
     }
 
+    a.nohighlight {
+      color: inherit !important;
+      text-decoration: none !important;
+      cursor: default !important;
+    }
+
     a img {
       border: none;
     }
@@ -458,7 +464,7 @@
                     <td class="content-cell">
                       <div class="f-fallback">
 <h1>Hi there,</h1>
-<p>{{invitee}} with {{invite_team_name}} has invited you to use Hoppscotch to collaborate with them. Click the button below to set up your account and get started:</p>
+<p><a class="nohighlight" name="invitee" href="#">{{invitee}}</a> with <a class="nohighlight" name="invite_team_name" href="#">{{invite_team_name}}</a> has invited you to use Hoppscotch to collaborate with them. Click the button below to set up your account and get started:</p>
 <!-- Action -->
 <table class="body-action" align="center" width="100%" cellpadding="0" cellspacing="0">
   <tr>
@@ -484,7 +490,7 @@
   Welcome aboard, <br />
   Your friends at Hoppscotch
 </p>
-<p><strong>P.S.</strong> If you don't associate with {{invitee}} or {{invite_team_name}}, just ignore this email.</p>
+<p><strong>P.S.</strong> If you don't associate with <a class="nohighlight" name="invitee" href="#">{{invitee}}</a> or <a class="nohighlight" name="invite_team_name" href="#">{{invite_team_name}}</a>, just ignore this email.</p>
 <!-- Sub copy -->
 <table class="body-sub">
   <tr>

packages/hoppscotch-backend/src/mailer/templates/user-invitation.hbs

@@ -14,7 +14,7 @@
   -->
     <style type="text/css" rel="stylesheet" media="all">
     /* Base ------------------------------ */
-    
+
     @import url("https://fonts.googleapis.com/css?family=Nunito+Sans:400,700&display=swap");
     body {
       width: 100% !important;
@@ -22,19 +22,25 @@
       margin: 0;
       -webkit-text-size-adjust: none;
     }
-    
+
     a {
       color: #3869D4;
     }
-    
+
+    a.nohighlight {
+      color: inherit !important;
+      text-decoration: none !important;
+      cursor: default !important;
+    }
+
     a img {
       border: none;
     }
-    
+
     td {
       word-break: break-word;
     }
-    
+
     .preheader {
       display: none !important;
       visibility: hidden;
@@ -47,13 +53,13 @@
       overflow: hidden;
     }
     /* Type ------------------------------ */
-    
+
     body,
     td,
     th {
       font-family: "Nunito Sans", Helvetica, Arial, sans-serif;
     }
-    
+
     h1 {
       margin-top: 0;
       color: #333333;
@@ -61,7 +67,7 @@
       font-weight: bold;
       text-align: left;
     }
-    
+
     h2 {
       margin-top: 0;
       color: #333333;
@@ -69,7 +75,7 @@
       font-weight: bold;
       text-align: left;
     }
-    
+
     h3 {
       margin-top: 0;
       color: #333333;
@@ -77,12 +83,12 @@
       font-weight: bold;
       text-align: left;
     }
-    
+
     td,
     th {
       font-size: 16px;
     }
-    
+
     p,
     ul,
     ol,
@@ -91,25 +97,25 @@
       font-size: 16px;
       line-height: 1.625;
     }
-    
+
     p.sub {
       font-size: 13px;
     }
     /* Utilities ------------------------------ */
-    
+
     .align-right {
       text-align: right;
     }
-    
+
     .align-left {
       text-align: left;
     }
-    
+
     .align-center {
       text-align: center;
     }
     /* Buttons ------------------------------ */
-    
+
     .button {
       background-color: #3869D4;
       border-top: 10px solid #3869D4;
@@ -124,7 +130,7 @@
       -webkit-text-size-adjust: none;
       box-sizing: border-box;
     }
-    
+
     .button--green {
       background-color: #22BC66;
       border-top: 10px solid #22BC66;
@@ -132,7 +138,7 @@
       border-bottom: 10px solid #22BC66;
       border-left: 18px solid #22BC66;
     }
-    
+
     .button--red {
       background-color: #FF6136;
       border-top: 10px solid #FF6136;
@@ -140,7 +146,7 @@
       border-bottom: 10px solid #FF6136;
       border-left: 18px solid #FF6136;
     }
-    
+
     @media only screen and (max-width: 500px) {
       .button {
         width: 100% !important;
@@ -148,21 +154,21 @@
       }
     }
     /* Attribute list ------------------------------ */
-    
+
     .attributes {
       margin: 0 0 21px;
     }
-    
+
     .attributes_content {
       background-color: #F4F4F7;
       padding: 16px;
     }
-    
+
     .attributes_item {
       padding: 0;
     }
     /* Related Items ------------------------------ */
-    
+
     .related {
       width: 100%;
       margin: 0;
@@ -171,31 +177,31 @@
       -premailer-cellpadding: 0;
       -premailer-cellspacing: 0;
     }
-    
+
     .related_item {
       padding: 10px 0;
       color: #CBCCCF;
       font-size: 15px;
       line-height: 18px;
     }
-    
+
     .related_item-title {
       display: block;
       margin: .5em 0 0;
     }
-    
+
     .related_item-thumb {
       display: block;
       padding-bottom: 10px;
     }
-    
+
     .related_heading {
       border-top: 1px solid #CBCCCF;
       text-align: center;
       padding: 25px 0 10px;
     }
     /* Discount Code ------------------------------ */
-    
+
     .discount {
       width: 100%;
       margin: 0;
@@ -206,33 +212,33 @@
       background-color: #F4F4F7;
       border: 2px dashed #CBCCCF;
     }
-    
+
     .discount_heading {
       text-align: center;
     }
-    
+
     .discount_body {
       text-align: center;
       font-size: 15px;
     }
     /* Social Icons ------------------------------ */
-    
+
     .social {
       width: auto;
     }
-    
+
     .social td {
       padding: 0;
       width: auto;
     }
-    
+
     .social_icon {
       height: 20px;
       margin: 0 8px 10px 8px;
       padding: 0;
     }
     /* Data table ------------------------------ */
-    
+
     .purchase {
       width: 100%;
       margin: 0;
@@ -241,7 +247,7 @@
       -premailer-cellpadding: 0;
       -premailer-cellspacing: 0;
     }
-    
+
     .purchase_content {
       width: 100%;
       margin: 0;
@@ -250,50 +256,50 @@
       -premailer-cellpadding: 0;
       -premailer-cellspacing: 0;
     }
-    
+
     .purchase_item {
       padding: 10px 0;
       color: #51545E;
       font-size: 15px;
       line-height: 18px;
     }
-    
+
     .purchase_heading {
       padding-bottom: 8px;
       border-bottom: 1px solid #EAEAEC;
     }
-    
+
     .purchase_heading p {
       margin: 0;
       color: #85878E;
       font-size: 12px;
     }
-    
+
     .purchase_footer {
       padding-top: 15px;
       border-top: 1px solid #EAEAEC;
     }
-    
+
     .purchase_total {
       margin: 0;
       text-align: right;
       font-weight: bold;
       color: #333333;
     }
-    
+
     .purchase_total--label {
       padding: 0 15px 0 0;
     }
-    
+
     body {
       background-color: #F2F4F6;
       color: #51545E;
     }
-    
+
     p {
       color: #51545E;
     }
-    
+
     .email-wrapper {
       width: 100%;
       margin: 0;
@@ -303,7 +309,7 @@
       -premailer-cellspacing: 0;
       background-color: #F2F4F6;
     }
-    
+
     .email-content {
       width: 100%;
       margin: 0;
@@ -313,16 +319,16 @@
       -premailer-cellspacing: 0;
     }
     /* Masthead ----------------------- */
-    
+
     .email-masthead {
       padding: 25px 0;
       text-align: center;
     }
-    
+
     .email-masthead_logo {
       width: 94px;
     }
-    
+
     .email-masthead_name {
       font-size: 16px;
       font-weight: bold;
@@ -331,7 +337,7 @@
       text-shadow: 0 1px 0 white;
     }
     /* Body ------------------------------ */
-    
+
     .email-body {
       width: 100%;
       margin: 0;
@@ -340,7 +346,7 @@
       -premailer-cellpadding: 0;
       -premailer-cellspacing: 0;
     }
-    
+
     .email-body_inner {
       width: 570px;
       margin: 0 auto;
@@ -350,7 +356,7 @@
       -premailer-cellspacing: 0;
       background-color: #FFFFFF;
     }
-    
+
     .email-footer {
       width: 570px;
       margin: 0 auto;
@@ -360,11 +366,11 @@
       -premailer-cellspacing: 0;
       text-align: center;
     }
-    
+
     .email-footer p {
       color: #A8AAAF;
     }
-    
+
     .body-action {
       width: 100%;
       margin: 30px auto;
@@ -374,25 +380,25 @@
       -premailer-cellspacing: 0;
       text-align: center;
     }
-    
+
     .body-sub {
       margin-top: 25px;
       padding-top: 25px;
       border-top: 1px solid #EAEAEC;
     }
-    
+
     .content-cell {
       padding: 45px;
     }
     /*Media Queries ------------------------------ */
-    
+
     @media only screen and (max-width: 600px) {
       .email-body_inner,
       .email-footer {
         width: 100% !important;
       }
     }
-    
+
     @media (prefers-color-scheme: dark) {
       body,
       .email-body,

packages/hoppscotch-backend/src/posthog/posthog.module.ts

@@ -0,0 +1,9 @@
+import { Module } from '@nestjs/common';
+import { PosthogService } from './posthog.service';
+import { PrismaModule } from 'src/prisma/prisma.module';
+
+@Module({
+  imports: [PrismaModule],
+  providers: [PosthogService],
+})
+export class PosthogModule {}

packages/hoppscotch-backend/src/posthog/posthog.service.ts

@@ -0,0 +1,58 @@
+import { Injectable } from '@nestjs/common';
+import { PostHog } from 'posthog-node';
+import { Cron, CronExpression, SchedulerRegistry } from '@nestjs/schedule';
+import { ConfigService } from '@nestjs/config';
+import { PrismaService } from 'src/prisma/prisma.service';
+import { CronJob } from 'cron';
+import { POSTHOG_CLIENT_NOT_INITIALIZED } from 'src/errors';
+import { throwErr } from 'src/utils';
+@Injectable()
+export class PosthogService {
+  private postHogClient: PostHog;
+  private POSTHOG_API_KEY = 'phc_9CipPajQC22mSkk2wxe2TXsUA0Ysyupe8dt5KQQELqx';
+
+  constructor(
+    private readonly configService: ConfigService,
+    private readonly prismaService: PrismaService,
+    private schedulerRegistry: SchedulerRegistry,
+  ) {}
+
+  async onModuleInit() {
+    if (this.configService.get('INFRA.ALLOW_ANALYTICS_COLLECTION') === 'true') {
+      console.log('Initializing PostHog');
+      this.postHogClient = new PostHog(this.POSTHOG_API_KEY, {
+        host: 'https://eu.posthog.com',
+      });
+
+      // Schedule the cron job only if analytics collection is allowed
+      this.scheduleCronJob();
+    }
+  }
+
+  private scheduleCronJob() {
+    const job = new CronJob(CronExpression.EVERY_WEEK, async () => {
+      await this.capture();
+    });
+
+    this.schedulerRegistry.addCronJob('captureAnalytics', job);
+    job.start();
+  }
+
+  async capture() {
+    if (!this.postHogClient) {
+      throwErr(POSTHOG_CLIENT_NOT_INITIALIZED);
+    }
+
+    this.postHogClient.capture({
+      distinctId: this.configService.get('INFRA.ANALYTICS_USER_ID'),
+      event: 'sh_instance',
+      properties: {
+        type: 'COMMUNITY',
+        total_user_count: await this.prismaService.user.count(),
+        total_workspace_count: await this.prismaService.team.count(),
+        version: this.configService.get('npm_package_version'),
+      },
+    });
+    console.log('Sent event to PostHog');
+  }
+}

packages/hoppscotch-backend/src/team-collection/helper.ts

@@ -0,0 +1,14 @@
+// Type of data returned from the query to obtain all search results
+export type SearchQueryReturnType = {
+  id: string;
+  title: string;
+  type: 'collection' | 'request';
+  method?: string;
+};
+
+// Type of data returned from the query to obtain all parents
+export type ParentTreeQueryReturnType = {
+  id: string;
+  parentID: string;
+  title: string;
+};

packages/hoppscotch-backend/src/team-collection/team-collection.controller.ts

@@ -0,0 +1,38 @@
+import { Controller, Get, Param, Query, UseGuards } from '@nestjs/common';
+import { TeamCollectionService } from './team-collection.service';
+import * as E from 'fp-ts/Either';
+import { ThrottlerBehindProxyGuard } from 'src/guards/throttler-behind-proxy.guard';
+import { JwtAuthGuard } from 'src/auth/guards/jwt-auth.guard';
+import { RequiresTeamRole } from 'src/team/decorators/requires-team-role.decorator';
+import { TeamMemberRole } from '@prisma/client';
+import { RESTTeamMemberGuard } from 'src/team/guards/rest-team-member.guard';
+import { throwHTTPErr } from 'src/utils';
+
+@UseGuards(ThrottlerBehindProxyGuard)
+@Controller({ path: 'team-collection', version: '1' })
+export class TeamCollectionController {
+  constructor(private readonly teamCollectionService: TeamCollectionService) {}
+
+  @Get('search/:teamID/:searchQuery')
+  @RequiresTeamRole(
+    TeamMemberRole.VIEWER,
+    TeamMemberRole.EDITOR,
+    TeamMemberRole.OWNER,
+  )
+  @UseGuards(JwtAuthGuard, RESTTeamMemberGuard)
+  async searchByTitle(
+    @Param('searchQuery') searchQuery: string,
+    @Param('teamID') teamID: string,
+    @Query('take') take: string,
+    @Query('skip') skip: string,
+  ) {
+    const res = await this.teamCollectionService.searchByTitle(
+      searchQuery,
+      teamID,
+      parseInt(take),
+      parseInt(skip),
+    );
+    if (E.isLeft(res)) throwHTTPErr(res.left);
+    return res.right;
+  }
+}

packages/hoppscotch-backend/src/team-collection/team-collection.module.ts

@@ -6,6 +6,7 @@ import { GqlCollectionTeamMemberGuard } from './guards/gql-collection-team-membe
 import { TeamModule } from '../team/team.module';
 import { UserModule } from '../user/user.module';
 import { PubSubModule } from '../pubsub/pubsub.module';
+import { TeamCollectionController } from './team-collection.controller';
 
 @Module({
   imports: [PrismaModule, TeamModule, UserModule, PubSubModule],
@@ -15,5 +16,6 @@ import { PubSubModule } from '../pubsub/pubsub.module';
     GqlCollectionTeamMemberGuard,
   ],
   exports: [TeamCollectionService, GqlCollectionTeamMemberGuard],
+  controllers: [TeamCollectionController],
 })
 export class TeamCollectionModule {}

packages/hoppscotch-backend/src/team-collection/team-collection.service.ts

@@ -1,4 +1,4 @@
-import { Injectable } from '@nestjs/common';
+import { HttpStatus, Injectable } from '@nestjs/common';
 import { PrismaService } from '../prisma/prisma.service';
 import { TeamCollection } from './team-collection.model';
 import {
@@ -14,6 +14,10 @@ import {
   TEAM_COL_SAME_NEXT_COLL,
   TEAM_COL_REORDERING_FAILED,
   TEAM_COLL_DATA_INVALID,
+  TEAM_REQ_SEARCH_FAILED,
+  TEAM_COL_SEARCH_FAILED,
+  TEAM_REQ_PARENT_TREE_GEN_FAILED,
+  TEAM_COLL_PARENT_TREE_GEN_FAILED,
 } from '../errors';
 import { PubSubService } from '../pubsub/pubsub.service';
 import { isValidLength } from 'src/utils';
@@ -22,6 +26,9 @@ import * as O from 'fp-ts/Option';
 import { Prisma, TeamCollection as DBTeamCollection } from '@prisma/client';
 import { CollectionFolder } from 'src/types/CollectionFolder';
 import { stringToJson } from 'src/utils';
+import { CollectionSearchNode } from 'src/types/CollectionSearchNode';
+import { ParentTreeQueryReturnType, SearchQueryReturnType } from './helper';
+import { RESTError } from 'src/types/RESTError';
 
 @Injectable()
 export class TeamCollectionService {
@@ -1056,4 +1063,266 @@ export class TeamCollectionService {
       return E.left(TEAM_COLL_NOT_FOUND);
     }
   }
+
+  /**
+   * Search for TeamCollections and TeamRequests by title
+   *
+   * @param searchQuery The search query
+   * @param teamID The Team ID
+   * @param take Number of items we want returned
+   * @param skip Number of items we want to skip
+   * @returns An Either of the search results
+   */
+  async searchByTitle(
+    searchQuery: string,
+    teamID: string,
+    take = 10,
+    skip = 0,
+  ) {
+    // Fetch all collections and requests that match the search query
+    const searchResults: SearchQueryReturnType[] = [];
+
+    const matchedCollections = await this.searchCollections(
+      searchQuery,
+      teamID,
+      take,
+      skip,
+    );
+    if (E.isLeft(matchedCollections))
+      return E.left(<RESTError>{
+        message: matchedCollections.left,
+        statusCode: HttpStatus.NOT_FOUND,
+      });
+    searchResults.push(...matchedCollections.right);
+
+    const matchedRequests = await this.searchRequests(
+      searchQuery,
+      teamID,
+      take,
+      skip,
+    );
+    if (E.isLeft(matchedRequests))
+      return E.left(<RESTError>{
+        message: matchedRequests.left,
+        statusCode: HttpStatus.NOT_FOUND,
+      });
+    searchResults.push(...matchedRequests.right);
+
+    // Generate the parent tree for searchResults
+    const searchResultsWithTree: CollectionSearchNode[] = [];
+
+    for (let i = 0; i < searchResults.length; i++) {
+      const fetchedParentTree = await this.fetchParentTree(searchResults[i]);
+      if (E.isLeft(fetchedParentTree))
+        return E.left(<RESTError>{
+          message: fetchedParentTree.left,
+          statusCode: HttpStatus.NOT_FOUND,
+        });
+      searchResultsWithTree.push({
+        type: searchResults[i].type,
+        title: searchResults[i].title,
+        method: searchResults[i].method,
+        id: searchResults[i].id,
+        path: !fetchedParentTree
+          ? []
+          : ([fetchedParentTree.right] as CollectionSearchNode[]),
+      });
+    }
+
+    return E.right({ data: searchResultsWithTree });
+  }
+
+  /**
+   * Search for TeamCollections by title
+   *
+   * @param searchQuery The search query
+   * @param teamID The Team ID
+   * @param take Number of items we want returned
+   * @param skip Number of items we want to skip
+   * @returns An Either of the search results
+   */
+  private async searchCollections(
+    searchQuery: string,
+    teamID: string,
+    take: number,
+    skip: number,
+  ) {
+    const query = Prisma.sql`
+    select id,title,'collection' AS type
+    from "TeamCollection"
+    where "TeamCollection"."teamID"=${teamID}
+    and titlesearch @@ to_tsquery(${searchQuery})
+    order by ts_rank(titlesearch,to_tsquery(${searchQuery}))
+    limit ${take}
+    OFFSET ${skip === 0 ? 0 : (skip - 1) * take};
+  `;
+    try {
+      const res = await this.prisma.$queryRaw<SearchQueryReturnType[]>(query);
+      return E.right(res);
+    } catch (error) {
+      return E.left(TEAM_COL_SEARCH_FAILED);
+    }
+  }
+
+  /**
+   * Search for TeamRequests by title
+   *
+   * @param searchQuery The search query
+   * @param teamID The Team ID
+   * @param take Number of items we want returned
+   * @param skip Number of items we want to skip
+   * @returns An Either of the search results
+   */
+  private async searchRequests(
+    searchQuery: string,
+    teamID: string,
+    take: number,
+    skip: number,
+  ) {
+    const query = Prisma.sql`
+    select id,title,request->>'method' as method,'request' AS type
+    from "TeamRequest"
+    where "TeamRequest"."teamID"=${teamID}
+    and titlesearch @@ to_tsquery(${searchQuery})
+    order by ts_rank(titlesearch,to_tsquery(${searchQuery}))
+    limit ${take}
+    OFFSET ${skip === 0 ? 0 : (skip - 1) * take};
+  `;
+
+    try {
+      const res = await this.prisma.$queryRaw<SearchQueryReturnType[]>(query);
+      return E.right(res);
+    } catch (error) {
+      return E.left(TEAM_REQ_SEARCH_FAILED);
+    }
+  }
+
+  /**
+   * Generate the parent tree of a search result
+   *
+   * @param searchResult The search result for which we want to generate the parent tree
+   * @returns The parent tree of the search result
+   */
+  private async fetchParentTree(searchResult: SearchQueryReturnType) {
+    return searchResult.type === 'collection'
+      ? await this.fetchCollectionParentTree(searchResult.id)
+      : await this.fetchRequestParentTree(searchResult.id);
+  }
+
+  /**
+   * Generate the parent tree of a collection
+   *
+   * @param id The ID of the collection
+   * @returns The parent tree of the collection
+   */
+  private async fetchCollectionParentTree(id: string) {
+    try {
+      const query = Prisma.sql`
+      WITH RECURSIVE collection_tree AS (
+        SELECT tc.id, tc."parentID", tc.title
+        FROM "TeamCollection" AS tc
+        JOIN "TeamCollection" AS tr ON tc.id = tr."parentID"
+        WHERE tr.id = ${id}
+
+        UNION ALL
+
+        SELECT parent.id,  parent."parentID", parent.title
+        FROM "TeamCollection" AS parent
+        JOIN collection_tree AS ct ON parent.id = ct."parentID"
+      )
+      SELECT * FROM collection_tree;
+      `;
+      const res = await this.prisma.$queryRaw<ParentTreeQueryReturnType[]>(
+        query,
+      );
+
+      const collectionParentTree = this.generateParentTree(res);
+      return E.right(collectionParentTree);
+    } catch (error) {
+      E.left(TEAM_COLL_PARENT_TREE_GEN_FAILED);
+    }
+  }
+
+  /**
+   * Generate the parent tree from the collections
+   *
+   * @param parentCollections The parent collections
+   * @returns The parent tree of the parent collections
+   */
+  private generateParentTree(parentCollections: ParentTreeQueryReturnType[]) {
+    function findChildren(id) {
+      const collection = parentCollections.filter((item) => item.id === id)[0];
+      if (collection.parentID == null) {
+        return {
+          id: collection.id,
+          title: collection.title,
+          type: 'collection',
+          path: [],
+        };
+      }
+
+      const res = {
+        id: collection.id,
+        title: collection.title,
+        type: 'collection',
+        path: findChildren(collection.parentID),
+      };
+      return res;
+    }
+
+    if (parentCollections.length > 0) {
+      if (parentCollections[0].parentID == null) {
+        return {
+          id: parentCollections[0].id,
+          title: parentCollections[0].title,
+          type: 'collection',
+          path: [],
+        };
+      }
+
+      return {
+        id: parentCollections[0].id,
+        title: parentCollections[0].title,
+        type: 'collection',
+        path: findChildren(parentCollections[0].parentID),
+      };
+    }
+
+    return null;
+  }
+
+  /**
+   * Generate the parent tree of a request
+   *
+   * @param id The ID of the request
+   * @returns The parent tree of the request
+   */
+  private async fetchRequestParentTree(id: string) {
+    try {
+      const query = Prisma.sql`
+      WITH RECURSIVE request_collection_tree AS (
+        SELECT tc.id, tc."parentID", tc.title
+        FROM "TeamCollection" AS tc
+        JOIN "TeamRequest" AS tr ON tc.id = tr."collectionID"
+        WHERE tr.id = ${id}
+
+        UNION ALL
+
+        SELECT parent.id, parent."parentID", parent.title
+        FROM "TeamCollection" AS parent
+        JOIN request_collection_tree AS ct ON parent.id = ct."parentID"
+      )
+      SELECT * FROM request_collection_tree;
+
+      `;
+      const res = await this.prisma.$queryRaw<ParentTreeQueryReturnType[]>(
+        query,
+      );
+
+      const requestParentTree = this.generateParentTree(res);
+      return E.right(requestParentTree);
+    } catch (error) {
+      return E.left(TEAM_REQ_PARENT_TREE_GEN_FAILED);
+    }
+  }
 }

packages/hoppscotch-backend/src/team/guards/rest-team-member.guard.ts

@@ -0,0 +1,47 @@
+import { CanActivate, ExecutionContext, Injectable } from '@nestjs/common';
+import { Reflector } from '@nestjs/core';
+import { TeamService } from '../../team/team.service';
+import { TeamMemberRole } from '../../team/team.model';
+import {
+  BUG_TEAM_NO_REQUIRE_TEAM_ROLE,
+  BUG_AUTH_NO_USER_CTX,
+  BUG_TEAM_NO_TEAM_ID,
+  TEAM_MEMBER_NOT_FOUND,
+  TEAM_NOT_REQUIRED_ROLE,
+} from 'src/errors';
+import { throwHTTPErr } from 'src/utils';
+
+@Injectable()
+export class RESTTeamMemberGuard implements CanActivate {
+  constructor(
+    private readonly reflector: Reflector,
+    private readonly teamService: TeamService,
+  ) {}
+
+  async canActivate(context: ExecutionContext): Promise<boolean> {
+    const requireRoles = this.reflector.get<TeamMemberRole[]>(
+      'requiresTeamRole',
+      context.getHandler(),
+    );
+    if (!requireRoles)
+      throwHTTPErr({ message: BUG_TEAM_NO_REQUIRE_TEAM_ROLE, statusCode: 400 });
+
+    const request = context.switchToHttp().getRequest();
+
+    const { user } = request;
+    if (user == undefined)
+      throwHTTPErr({ message: BUG_AUTH_NO_USER_CTX, statusCode: 400 });
+
+    const teamID = request.params.teamID;
+    if (!teamID)
+      throwHTTPErr({ message: BUG_TEAM_NO_TEAM_ID, statusCode: 400 });
+
+    const teamMember = await this.teamService.getTeamMember(teamID, user.uid);
+    if (!teamMember)
+      throwHTTPErr({ message: TEAM_MEMBER_NOT_FOUND, statusCode: 404 });
+
+    if (requireRoles.includes(teamMember.role)) return true;
+
+    throwHTTPErr({ message: TEAM_NOT_REQUIRED_ROLE, statusCode: 403 });
+  }
+}

packages/hoppscotch-backend/src/types/CollectionSearchNode.ts

@@ -0,0 +1,17 @@
+// Response type of results from the search query
+export type CollectionSearchNode = {
+  /** Encodes the hierarchy of where the node is **/
+  path: CollectionSearchNode[];
+} & (
+  | {
+      type: 'request';
+      title: string;
+      method: string;
+      id: string;
+    }
+  | {
+      type: 'collection';
+      title: string;
+      id: string;
+    }
+);

packages/hoppscotch-backend/src/types/InfraConfig.ts

@@ -4,26 +4,23 @@ export enum InfraConfigEnum {
 
   GOOGLE_CLIENT_ID = 'GOOGLE_CLIENT_ID',
   GOOGLE_CLIENT_SECRET = 'GOOGLE_CLIENT_SECRET',
+  GOOGLE_CALLBACK_URL = 'GOOGLE_CALLBACK_URL',
+  GOOGLE_SCOPE = 'GOOGLE_SCOPE',
 
   GITHUB_CLIENT_ID = 'GITHUB_CLIENT_ID',
   GITHUB_CLIENT_SECRET = 'GITHUB_CLIENT_SECRET',
+  GITHUB_CALLBACK_URL = 'GITHUB_CALLBACK_URL',
+  GITHUB_SCOPE = 'GITHUB_SCOPE',
 
   MICROSOFT_CLIENT_ID = 'MICROSOFT_CLIENT_ID',
   MICROSOFT_CLIENT_SECRET = 'MICROSOFT_CLIENT_SECRET',
+  MICROSOFT_CALLBACK_URL = 'MICROSOFT_CALLBACK_URL',
+  MICROSOFT_SCOPE = 'MICROSOFT_SCOPE',
+  MICROSOFT_TENANT = 'MICROSOFT_TENANT',
 
   VITE_ALLOWED_AUTH_PROVIDERS = 'VITE_ALLOWED_AUTH_PROVIDERS',
-}
-
-export enum InfraConfigEnumForClient {
-  MAILER_SMTP_URL = 'MAILER_SMTP_URL',
-  MAILER_ADDRESS_FROM = 'MAILER_ADDRESS_FROM',
-
-  GOOGLE_CLIENT_ID = 'GOOGLE_CLIENT_ID',
-  GOOGLE_CLIENT_SECRET = 'GOOGLE_CLIENT_SECRET',
-
-  GITHUB_CLIENT_ID = 'GITHUB_CLIENT_ID',
-  GITHUB_CLIENT_SECRET = 'GITHUB_CLIENT_SECRET',
-
-  MICROSOFT_CLIENT_ID = 'MICROSOFT_CLIENT_ID',
-  MICROSOFT_CLIENT_SECRET = 'MICROSOFT_CLIENT_SECRET',
+
+  ALLOW_ANALYTICS_COLLECTION = 'ALLOW_ANALYTICS_COLLECTION',
+  ANALYTICS_USER_ID = 'ANALYTICS_USER_ID',
+  IS_FIRST_TIME_INFRA_SETUP = 'IS_FIRST_TIME_INFRA_SETUP',
 }

packages/hoppscotch-backend/src/types/RESTError.ts

@@ -1,10 +1,10 @@
 import { HttpStatus } from '@nestjs/common';
 
 /**
- ** Custom interface to handle errors specific to Auth module
+ ** Custom interface to handle errors for REST modules such as Auth, Admin modules
  ** Since its REST we need to return the HTTP status code along with the error message
  */
-export type AuthError = {
+export type RESTError = {
   message: string;
   statusCode: HttpStatus;
 };

packages/hoppscotch-backend/src/types/input-types.args.ts

@@ -17,3 +17,21 @@ export class PaginationArgs {
   })
   take: number;
 }
+
+@ArgsType()
+@InputType()
+export class OffsetPaginationArgs {
+  @Field({
+    nullable: true,
+    defaultValue: 0,
+    description: 'Number of items to skip',
+  })
+  skip: number;
+
+  @Field({
+    nullable: true,
+    defaultValue: 10,
+    description: 'Number of items to fetch',
+  })
+  take: number;
+}

packages/hoppscotch-backend/src/user/user.model.ts

@@ -56,3 +56,22 @@ export enum SessionType {
 registerEnumType(SessionType, {
   name: 'SessionType',
 });
+
+@ObjectType()
+export class UserDeletionResult {
+  @Field(() => ID, {
+    description: 'UID of the user',
+  })
+  userUID: string;
+
+  @Field(() => Boolean, {
+    description: 'Flag to determine if user deletion was successful or not',
+  })
+  isDeleted: Boolean;
+
+  @Field({
+    nullable: true,
+    description: 'Error message if user deletion was not successful',
+  })
+  errorMessage: String;
+}

packages/hoppscotch-backend/src/user/user.service.spec.ts

@@ -1,4 +1,4 @@
-import { JSON_INVALID, USER_NOT_FOUND } from 'src/errors';
+import { JSON_INVALID, USERS_NOT_FOUND, USER_NOT_FOUND } from 'src/errors';
 import { mockDeep, mockReset } from 'jest-mock-extended';
 import { PrismaService } from 'src/prisma/prisma.service';
 import { AuthUser } from 'src/types/AuthUser';
@@ -176,6 +176,26 @@ describe('UserService', () => {
     });
   });
 
+  describe('findUsersByIds', () => {
+    test('should successfully return users given valid user UIDs', async () => {
+      mockPrisma.user.findMany.mockResolvedValueOnce(users);
+
+      const result = await userService.findUsersByIds([
+        '123344',
+        '5555',
+        '6666',
+      ]);
+      expect(result).toEqual(users);
+    });
+
+    test('should return empty array of users given a invalid user UIDs', async () => {
+      mockPrisma.user.findMany.mockResolvedValueOnce([]);
+
+      const result = await userService.findUsersByIds(['sdcvbdbr']);
+      expect(result).toEqual([]);
+    });
+  });
+
   describe('createUserViaMagicLink', () => {
     test('should successfully create user and account for magic-link given valid inputs', async () => {
       mockPrisma.user.create.mockResolvedValueOnce(user);
@@ -414,6 +434,54 @@ describe('UserService', () => {
     });
   });
 
+  describe('updateUserDisplayName', () => {
+    test('should resolve right and update user display name', async () => {
+      const newDisplayName = 'New Name';
+      mockPrisma.user.update.mockResolvedValueOnce({
+        ...user,
+        displayName: newDisplayName,
+      });
+
+      const result = await userService.updateUserDisplayName(
+        user.uid,
+        newDisplayName,
+      );
+      expect(result).toEqualRight({
+        ...user,
+        displayName: newDisplayName,
+        currentGQLSession: JSON.stringify(user.currentGQLSession),
+        currentRESTSession: JSON.stringify(user.currentRESTSession),
+      });
+    });
+    test('should resolve right and publish user updated subscription', async () => {
+      const newDisplayName = 'New Name';
+      mockPrisma.user.update.mockResolvedValueOnce({
+        ...user,
+        displayName: newDisplayName,
+      });
+
+      await userService.updateUserDisplayName(user.uid, user.displayName);
+      expect(mockPubSub.publish).toHaveBeenCalledWith(
+        `user/${user.uid}/updated`,
+        {
+          ...user,
+          displayName: newDisplayName,
+          currentGQLSession: JSON.stringify(user.currentGQLSession),
+          currentRESTSession: JSON.stringify(user.currentRESTSession),
+        },
+      );
+    });
+    test('should resolve left and error when invalid user uid is passed', async () => {
+      mockPrisma.user.update.mockRejectedValueOnce('NotFoundError');
+
+      const result = await userService.updateUserDisplayName(
+        'invalidUserUid',
+        user.displayName,
+      );
+      expect(result).toEqualLeft(USER_NOT_FOUND);
+    });
+  });
+
   describe('fetchAllUsers', () => {
     test('should resolve right and return 20 users when cursor is null', async () => {
       mockPrisma.user.findMany.mockResolvedValueOnce(users);
@@ -435,6 +503,36 @@ describe('UserService', () => {
     });
   });
 
+  describe('fetchAllUsersV2', () => {
+    test('should resolve right and return first 20 users when searchString is null', async () => {
+      mockPrisma.user.findMany.mockResolvedValueOnce(users);
+
+      const result = await userService.fetchAllUsersV2(null, {
+        take: 20,
+        skip: 0,
+      });
+      expect(result).toEqual(users);
+    });
+    test('should resolve right and return next 20 users when searchString is provided', async () => {
+      mockPrisma.user.findMany.mockResolvedValueOnce(users);
+
+      const result = await userService.fetchAllUsersV2('.com', {
+        take: 20,
+        skip: 0,
+      });
+      expect(result).toEqual(users);
+    });
+    test('should resolve left and return an empty array when users not found', async () => {
+      mockPrisma.user.findMany.mockResolvedValueOnce([]);
+
+      const result = await userService.fetchAllUsersV2('Unknown entry', {
+        take: 20,
+        skip: 0,
+      });
+      expect(result).toEqual([]);
+    });
+  });
+
   describe('fetchAdminUsers', () => {
     test('should return a list of admin users', async () => {
       mockPrisma.user.findMany.mockResolvedValueOnce(adminUsers);
@@ -556,4 +654,17 @@ describe('UserService', () => {
       expect(result).toEqual(10);
     });
   });
+
+  describe('removeUsersAsAdmin', () => {
+    test('should resolve right and return true for valid user UIDs', async () => {
+      mockPrisma.user.updateMany.mockResolvedValueOnce({ count: 1 });
+      const result = await userService.removeUsersAsAdmin(['123344']);
+      expect(result).toEqualRight(true);
+    });
+    test('should resolve right and return false for invalid user UIDs', async () => {
+      mockPrisma.user.updateMany.mockResolvedValueOnce({ count: 0 });
+      const result = await userService.removeUsersAsAdmin(['123344']);
+      expect(result).toEqualLeft(USERS_NOT_FOUND);
+    });
+  });
 });

packages/hoppscotch-backend/src/user/user.service.ts

@@ -8,13 +8,14 @@ import * as T from 'fp-ts/Task';
 import * as A from 'fp-ts/Array';
 import { pipe, constVoid } from 'fp-ts/function';
 import { AuthUser } from 'src/types/AuthUser';
-import { USER_NOT_FOUND } from 'src/errors';
+import { USERS_NOT_FOUND, USER_NOT_FOUND } from 'src/errors';
 import { SessionType, User } from './user.model';
 import { USER_UPDATE_FAILED } from 'src/errors';
 import { PubSubService } from 'src/pubsub/pubsub.service';
 import { stringToJson, taskEitherValidateArraySeq } from 'src/utils';
 import { UserDataHandler } from './user.data.handler';
 import { User as DbUser } from '@prisma/client';
+import { OffsetPaginationArgs } from 'src/types/input-types.args';
 
 @Injectable()
 export class UserService {
@@ -88,6 +89,20 @@ export class UserService {
     }
   }
 
+  /**
+   * Find users with given IDs
+   * @param userUIDs User IDs
+   * @returns Array of found Users
+   */
+  async findUsersByIds(userUIDs: string[]): Promise<AuthUser[]> {
+    const users = await this.prisma.user.findMany({
+      where: {
+        uid: { in: userUIDs },
+      },
+    });
+    return users;
+  }
+
   /**
    * Update User with new generated hashed refresh token
    *
@@ -269,6 +284,30 @@ export class UserService {
     }
   }
 
+  /**
+   * Update a user's data
+   * @param userUID User UID
+   * @param displayName User's displayName
+   * @returns a Either of User or error
+   */
+  async updateUserDisplayName(userUID: string, displayName: string) {
+    try {
+      const dbUpdatedUser = await this.prisma.user.update({
+        where: { uid: userUID },
+        data: { displayName },
+      });
+
+      const updatedUser = this.convertDbUserToUser(dbUpdatedUser);
+
+      // Publish subscription for user updates
+      await this.pubsub.publish(`user/${updatedUser.uid}/updated`, updatedUser);
+
+      return E.right(updatedUser);
+    } catch (error) {
+      return E.left(USER_NOT_FOUND);
+    }
+  }
+
   /**
    * Validate and parse currentRESTSession and currentGQLSession
    * @param sessionData string of the session
@@ -286,6 +325,7 @@ export class UserService {
    * @param cursorID string of userUID or null
    * @param take number of users to query
    * @returns an array of `User` object
+   * @deprecated use fetchAllUsersV2 instead
    */
   async fetchAllUsers(cursorID: string, take: number) {
     const fetchedUsers = await this.prisma.user.findMany({
@@ -296,6 +336,43 @@ export class UserService {
     return fetchedUsers;
   }
 
+  /**
+   * Fetch all the users in the `User` table based on cursor
+   * @param searchString search on user's displayName or email
+   * @param paginationOption pagination options
+   * @returns an array of `User` object
+   */
+  async fetchAllUsersV2(
+    searchString: string,
+    paginationOption: OffsetPaginationArgs,
+  ) {
+    const fetchedUsers = await this.prisma.user.findMany({
+      skip: paginationOption.skip,
+      take: paginationOption.take,
+      where: searchString
+        ? {
+            OR: [
+              {
+                displayName: {
+                  contains: searchString,
+                  mode: 'insensitive',
+                },
+              },
+              {
+                email: {
+                  contains: searchString,
+                  mode: 'insensitive',
+                },
+              },
+            ],
+          }
+        : undefined,
+      orderBy: [{ isAdmin: 'desc' }, { displayName: 'asc' }],
+    });
+
+    return fetchedUsers;
+  }
+
   /**
    * Fetch the number of users in db
    * @returns a count (Int) of user records in DB
@@ -326,6 +403,23 @@ export class UserService {
     }
   }
 
+  /**
+   * Change users to admins by toggling isAdmin param to true
+   * @param userUID user UIDs
+   * @returns a Either of true or error
+   */
+  async makeAdmins(userUIDs: string[]) {
+    try {
+      await this.prisma.user.updateMany({
+        where: { uid: { in: userUIDs } },
+        data: { isAdmin: true },
+      });
+      return E.right(true);
+    } catch (error) {
+      return E.left(USER_UPDATE_FAILED);
+    }
+  }
+
   /**
    * Fetch all the admin users
    * @returns an array of admin users
@@ -444,4 +538,22 @@ export class UserService {
       return E.left(USER_NOT_FOUND);
     }
   }
+
+  /**
+   * Change users from an admin by toggling isAdmin param to false
+   * @param userUIDs user UIDs
+   * @returns a Either of true or error
+   */
+  async removeUsersAsAdmin(userUIDs: string[]) {
+    const data = await this.prisma.user.updateMany({
+      where: { uid: { in: userUIDs } },
+      data: { isAdmin: false },
+    });
+
+    if (data.count === 0) {
+      return E.left(USERS_NOT_FOUND);
+    }
+
+    return E.right(true);
+  }
 }

packages/hoppscotch-backend/src/utils.ts

@@ -1,4 +1,4 @@
-import { ExecutionContext } from '@nestjs/common';
+import { ExecutionContext, HttpException } from '@nestjs/common';
 import { Reflector } from '@nestjs/core';
 import { GqlExecutionContext } from '@nestjs/graphql';
 import { pipe } from 'fp-ts/lib/function';
@@ -16,6 +16,7 @@ import {
   JSON_INVALID,
 } from './errors';
 import { AuthProvider } from './auth/helper';
+import { RESTError } from './types/RESTError';
 
 /**
  * A workaround to throw an exception in an expression.
@@ -27,6 +28,15 @@ export function throwErr(errMessage: string): never {
   throw new Error(errMessage);
 }
 
+/**
+ * This function allows throw to be used as an expression
+ * @param errMessage Message present in the error message
+ */
+export function throwHTTPErr(errorData: RESTError): never {
+  const { message, statusCode } = errorData;
+  throw new HttpException(message, statusCode);
+}
+
 /**
  * Prints the given value to log and returns the same value.
  * Used for debugging functional pipelines.
@@ -173,6 +183,16 @@ export const validateSMTPUrl = (url: string) => {
   return false;
 };
 
+/**
+ * Checks to see if the URL is valid or not
+ * @param url The URL to validate
+ * @returns boolean
+ */
+export const validateUrl = (url: string) => {
+  const urlRegex = /^(http|https):\/\/[^ "]+$/;
+  return urlRegex.test(url);
+};
+
 /**
  * String to JSON parser
  * @param {str} str The string to parse

packages/hoppscotch-cli/bin/hopp

@@ -1,3 +0,0 @@
-#!/usr/bin/env node
-// * The entry point of the CLI
-require("../dist").cli(process.argv);

packages/hoppscotch-cli/bin/hopp.js

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+// * The entry point of the CLI
+
+import { cli } from "../dist/index.js";
+
+cli(process.argv);

packages/hoppscotch-cli/package.json

@@ -3,9 +3,10 @@
   "version": "0.6.0",
   "description": "A CLI to run Hoppscotch test scripts in CI environments.",
   "homepage": "https://hoppscotch.io",
+  "type": "module",
   "main": "dist/index.js",
   "bin": {
-    "hopp": "bin/hopp"
+    "hopp": "bin/hopp.js"
   },
   "publishConfig": {
     "access": "public"
@@ -39,27 +40,30 @@
   },
   "license": "MIT",
   "private": false,
+  "dependencies": {
+    "axios": "^1.6.6",
+    "chalk": "^5.3.0",
+    "commander": "^11.1.0",
+    "lodash-es": "^4.17.21",
+    "qs": "^6.11.2",
+    "zod": "^3.22.4"
+  },
   "devDependencies": {
     "@hoppscotch/data": "workspace:^",
     "@hoppscotch/js-sandbox": "workspace:^",
     "@relmify/jest-fp-ts": "^2.1.1",
-    "@swc/core": "^1.3.92",
-    "@types/jest": "^29.5.5",
-    "@types/lodash": "^4.14.199",
-    "@types/qs": "^6.9.8",
-    "axios": "^0.21.4",
-    "chalk": "^4.1.2",
-    "commander": "^11.0.0",
-    "esm": "^3.2.25",
-    "fp-ts": "^2.16.1",
-    "io-ts": "^2.2.20",
+    "@swc/core": "^1.3.105",
+    "@types/jest": "^29.5.11",
+    "@types/lodash-es": "^4.17.12",
+    "@types/qs": "^6.9.11",
+    "fp-ts": "^2.16.2",
     "jest": "^29.7.0",
     "lodash": "^4.17.21",
-    "prettier": "^3.0.3",
+    "prettier": "^3.2.4",
     "qs": "^6.11.2",
-    "ts-jest": "^29.1.1",
-    "tsup": "^7.2.0",
-    "typescript": "^5.2.2",
+    "ts-jest": "^29.1.2",
+    "tsup": "^8.0.1",
+    "typescript": "^5.3.3",
     "verzod": "^0.2.2",
     "zod": "^3.22.4"
   }

packages/hoppscotch-cli/src/index.ts

@@ -1,5 +1,5 @@
 import chalk from "chalk";
-import { program } from "commander";
+import { Command } from "commander";
 import * as E from "fp-ts/Either";
 import { version } from "../package.json";
 import { test } from "./commands/test";
@@ -20,6 +20,8 @@ const CLI_AFTER_ALL_TXT = `\nFor more help, head on to ${accent(
   "https://docs.hoppscotch.io/documentation/clients/cli"
 )}`;
 
+const program = new Command()
+
 program
   .name("hopp")
   .version(version, "-v, --ver", "see the current version of hopp-cli")

packages/hoppscotch-cli/src/utils/collections.ts

@@ -1,9 +1,9 @@
 import { HoppCollection, HoppRESTRequest } from "@hoppscotch/data";
-import { bold } from "chalk";
+import chalk from "chalk";
 import { log } from "console";
 import * as A from "fp-ts/Array";
 import { pipe } from "fp-ts/function";
-import round from "lodash/round";
+import { round } from "lodash-es";
 
 import { CollectionRunnerParam } from "../types/collections";
 import {
@@ -68,7 +68,7 @@ export const collectionsRunner = async (
         };
 
         // Request processing initiated message.
-        log(WARN(`\nRunning: ${bold(requestPath)}`));
+        log(WARN(`\nRunning: ${chalk.bold(requestPath)}`));
 
       // Processing current request.
       const result = await processRequest(processRequestParams)();

packages/hoppscotch-cli/src/utils/display.ts

@@ -1,4 +1,4 @@
-import { bold } from "chalk";
+import chalk from "chalk";
 import { groupEnd, group, log } from "console";
 import { handleError } from "../handlers/error";
 import { RequestConfig } from "../interfaces/request";
@@ -120,7 +120,7 @@ export const printErrorsReport = (
   errorsReport: HoppCLIError[]
 ) => {
   if (errorsReport.length > 0) {
-    const REPORTED_ERRORS_TITLE = FAIL(`\n${bold(path)} reported errors:`);
+    const REPORTED_ERRORS_TITLE = FAIL(`\n${chalk.bold(path)} reported errors:`);
 
     group(REPORTED_ERRORS_TITLE);
     for (const errorReport of errorsReport) {
@@ -143,7 +143,7 @@ export const printFailedTestsReport = (
 
   // Only printing test-reports with failed test-cases.
   if (failedTestsReport.length > 0) {
-    const FAILED_TESTS_PATH = FAIL(`\n${bold(path)} failed tests:`);
+    const FAILED_TESTS_PATH = FAIL(`\n${chalk.bold(path)} failed tests:`);
     group(FAILED_TESTS_PATH);
 
     for (const failedTestReport of failedTestsReport) {

packages/hoppscotch-cli/src/utils/functions/array.ts

@@ -1,4 +1,4 @@
-import { clone } from "lodash";
+import { clone } from "lodash-es";
 
 /**
  * Sorts the array based on the sort func.

packages/hoppscotch-cli/src/utils/getters.ts

@@ -11,7 +11,7 @@ import * as E from "fp-ts/Either";
 import * as S from "fp-ts/string";
 import * as O from "fp-ts/Option";
 import { error } from "../types/errors";
-import round from "lodash/round";
+import { round } from "lodash-es";
 import { DEFAULT_DURATION_PRECISION } from "./constants";
 
 /**

packages/hoppscotch-cli/tsconfig.json

@@ -1,7 +1,7 @@
 {
   "compilerOptions": {
-    "target": "ES6",
-    "module": "commonjs",
+    "target": "ESNext",
+    "module": "ESNext",
     "outDir": ".",
     "rootDir": ".",
     "strict": true,

packages/hoppscotch-cli/tsup.config.ts

@@ -3,17 +3,14 @@ import { defineConfig } from "tsup";
 export default defineConfig({
   entry: [ "./src/index.ts" ],
   outDir: "./dist/",
-  format: ["cjs"],
+  format: ["esm"],
   platform: "node",
   sourcemap: true,
   bundle: true,
-  target: "node12",
+  target: "esnext",
   skipNodeModulesBundle: false,
   esbuildOptions(options) {
     options.bundle = true
   },
-  noExternal:  [
-    /\w+/
-  ],
   clean: true,
 });

packages/hoppscotch-common/assets/scss/styles.scss

@@ -429,6 +429,11 @@ pre.ace_editor {
   }
 }
 
+.splitpanes__pane {
+  @apply will-change-auto;
+  transform: translateZ(0);
+}
+
 .smart-splitter .splitpanes__splitter {
   @apply relative;
   @apply before:absolute;

packages/hoppscotch-common/locales/en.json

@@ -315,7 +315,8 @@
     "proxy_error": "Proxy error",
     "script_fail": "Could not execute pre-request script",
     "something_went_wrong": "Something went wrong",
-    "test_script_fail": "Could not execute post-request script"
+    "test_script_fail": "Could not execute post-request script",
+    "reading_files": "Error while reading one or more files."
   },
   "export": {
     "as_json": "Export as JSON",
@@ -413,7 +414,10 @@
     "json_description": "Import collections from a Hoppscotch Collections JSON file",
     "postman_environment": "Postman Environment",
     "postman_environment_description": "Import Postman Environment from a JSON file",
-    "title": "Import"
+    "title": "Import",
+    "file_size_limit_exceeded_warning_multiple_files": "Chosen files exceed the recommended limit of 10MB. Only the first {files} selected will be imported",
+    "file_size_limit_exceeded_warning_single_file": "The currently chosen file exceeds the recommended limit of 10MB. Please select another file.",
+    "success": "Successfully imported"
   },
   "inspections": {
     "description": "Inspect possible errors",

packages/hoppscotch-common/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@hoppscotch/common",
   "private": true,
-  "version": "2023.12.4",
+  "version": "2023.12.6",
   "scripts": {
     "dev": "pnpm exec npm-run-all -p -l dev:*",
     "test": "vitest --run",

packages/hoppscotch-common/src/components/collections/ImportExport.vue

@@ -263,7 +263,7 @@ const HoppOpenAPIImporter: ImporterOrExporter = {
       step: UrlSource({
         caption: "import.from_url",
         onImportFromURL: async (content) => {
-          const res = await hoppOpenAPIImporter(content)()
+          const res = await hoppOpenAPIImporter([content])()
 
           if (E.isRight(res)) {
             handleImportToStore(res.right)

packages/hoppscotch-common/src/components/collections/MyCollections.vue

@@ -694,7 +694,7 @@ class MyCollectionsAdapter implements SmartTreeAdapter<MyCollectionNode> {
     let target = collections[indexPaths.shift() as number]
 
     while (indexPaths.length > 0)
-      target = target.folders[indexPaths.shift() as number]
+      target = target?.folders[indexPaths.shift() as number]
 
     return target !== undefined ? target : null
   }

packages/hoppscotch-common/src/components/collections/index.vue

@@ -614,8 +614,8 @@ const addNewRootCollection = (name: string) => {
         requests: [],
         headers: [],
         auth: {
-          authType: "inherit",
-          authActive: false,
+          authType: "none",
+          authActive: true,
         },
       })
     )

packages/hoppscotch-common/src/components/environments/ImportExport.vue

@@ -133,7 +133,7 @@ const PostmanEnvironmentsImport: ImporterOrExporter = {
         return
       }
 
-      handleImportToStore([res.right])
+      handleImportToStore(res.right)
 
       platform.analytics?.logEvent({
         type: "HOPP_IMPORT_ENVIRONMENT",
@@ -166,19 +166,14 @@ const insomniaEnvironmentsImport: ImporterOrExporter = {
         return
       }
 
-      const globalEnvIndex = res.right.findIndex(
+      const globalEnvs = res.right.filter(
         (env) => env.name === "Base Environment"
       )
+      const otherEnvs = res.right.filter(
+        (env) => env.name !== "Base Environment"
+      )
 
-      const globalEnv =
-        globalEnvIndex !== -1 ? res.right[globalEnvIndex] : undefined
-
-      // remove the global env from the environments array to prevent it from being imported twice
-      if (globalEnvIndex !== -1) {
-        res.right.splice(globalEnvIndex, 1)
-      }
-
-      handleImportToStore(res.right, globalEnv)
+      handleImportToStore(otherEnvs, globalEnvs)
 
       platform.analytics?.logEvent({
         type: "HOPP_IMPORT_ENVIRONMENT",
@@ -340,14 +335,14 @@ const showImportFailedError = () => {
 
 const handleImportToStore = async (
   environments: Environment[],
-  globalEnv?: NonSecretEnvironment
+  globalEnvs: NonSecretEnvironment[] = []
 ) => {
-  // if there's a global env, add them to the store
-  if (globalEnv) {
-    globalEnv.variables.forEach(({ key, value, secret }) =>
+  // Add global envs to the store
+  globalEnvs.forEach(({ variables }) => {
+    variables.forEach(({ key, value, secret }) => {
       addGlobalEnvVariable({ key, value, secret })
-    )
-  }
+    })
+  })
 
   if (props.environmentType === "MY_ENV") {
     appendEnvironments(environments)

packages/hoppscotch-common/src/components/graphql/Authorization.vue

@@ -31,17 +31,6 @@
               tabindex="0"
               @keyup.escape="hide()"
             >
-              <HoppSmartItem
-                label="None"
-                :icon="authName === 'None' ? IconCircleDot : IconCircle"
-                :active="authName === 'None'"
-                @click="
-                  () => {
-                    auth.authType = 'none'
-                    hide()
-                  }
-                "
-              />
               <HoppSmartItem
                 v-if="!isRootCollection"
                 label="Inherit"
@@ -54,6 +43,17 @@
                   }
                 "
               />
+              <HoppSmartItem
+                label="None"
+                :icon="authName === 'None' ? IconCircleDot : IconCircle"
+                :active="authName === 'None'"
+                @click="
+                  () => {
+                    auth.authType = 'none'
+                    hide()
+                  }
+                "
+              />
               <HoppSmartItem
                 label="Basic Auth"
                 :icon="authName === 'Basic Auth' ? IconCircleDot : IconCircle"
@@ -284,7 +284,7 @@ const authActive = pluckRef(auth, "authActive")
 
 const clearContent = () => {
   auth.value = {
-    authType: "none",
+    authType: "inherit",
     authActive: true,
   }
 }

packages/hoppscotch-common/src/components/graphql/RequestOptions.vue

@@ -1,5 +1,5 @@
 <template>
-  <div class="flex h-full flex-1 flex-col">
+  <div class="h-full">
     <HoppSmartTabs
       v-model="selectedOptionTab"
       styles="sticky top-0 bg-primary z-10 border-b-0"

packages/hoppscotch-common/src/components/graphql/Response.vue

@@ -72,7 +72,9 @@
           </tippy>
         </div>
       </div>
-      <div ref="schemaEditor" class="flex flex-1 flex-col"></div>
+      <div class="h-full">
+        <div ref="schemaEditor"></div>
+      </div>
     </div>
     <component
       :is="response[0].error.component"

packages/hoppscotch-common/src/components/graphql/Sidebar.vue

@@ -145,11 +145,9 @@
           />
         </div>
       </div>
-      <div
-        v-if="schemaString"
-        ref="schemaEditor"
-        class="flex flex-1 flex-col"
-      ></div>
+      <div v-if="schemaString" class="h-full relative w-full">
+        <div ref="schemaEditor" class="absolute inset-0"></div>
+      </div>
       <HoppSmartPlaceholder
         v-else
         :src="`/images/states/${colorMode.value}/blockchain.svg`"

packages/hoppscotch-common/src/components/graphql/Variable.vue

@@ -67,7 +67,9 @@
       />
     </div>
   </div>
-  <div ref="variableEditor" class="flex flex-1 flex-col"></div>
+  <div class="h-full relative">
+    <div ref="variableEditor" class="flex flex-1 flex-col"></div>
+  </div>
 </template>
 
 <script setup lang="ts">

packages/hoppscotch-common/src/components/http/Authorization.vue

@@ -31,17 +31,6 @@
               tabindex="0"
               @keyup.escape="hide()"
             >
-              <HoppSmartItem
-                label="None"
-                :icon="authName === 'None' ? IconCircleDot : IconCircle"
-                :active="authName === 'None'"
-                @click="
-                  () => {
-                    auth.authType = 'none'
-                    hide()
-                  }
-                "
-              />
               <HoppSmartItem
                 v-if="!isRootCollection"
                 label="Inherit"
@@ -54,6 +43,17 @@
                   }
                 "
               />
+              <HoppSmartItem
+                label="None"
+                :icon="authName === 'None' ? IconCircleDot : IconCircle"
+                :active="authName === 'None'"
+                @click="
+                  () => {
+                    auth.authType = 'none'
+                    hide()
+                  }
+                "
+              />
               <HoppSmartItem
                 label="Basic Auth"
                 :icon="authName === 'Basic Auth' ? IconCircleDot : IconCircle"
@@ -265,7 +265,7 @@ const authActive = pluckRef(auth, "authActive")
 
 const clearContent = () => {
   auth.value = {
-    authType: "none",
+    authType: "inherit",
     authActive: true,
   }
 }

packages/hoppscotch-common/src/components/http/Headers.vue

@@ -49,7 +49,9 @@
         />
       </div>
     </div>
-    <div v-if="bulkMode" ref="bulkEditor" class="flex flex-1 flex-col"></div>
+    <div v-if="bulkMode" class="h-full relative w-full">
+      <div ref="bulkEditor" class="absolute inset-0"></div>
+    </div>
     <div v-else>
       <draggable
         v-model="workingHeaders"

packages/hoppscotch-common/src/components/http/OAuth2Authorization.vue

@@ -112,7 +112,7 @@ const handleAccessTokenRequest = async () => {
   }
 
   const envs = getCombinedEnvVariables()
-  const envVars = [...envs.selected.variables, ...envs.global]
+  const envVars = [...envs.selected, ...envs.global]
 
   try {
     const tokenReqParams = {

packages/hoppscotch-common/src/components/http/Parameters.vue

@@ -44,7 +44,9 @@
         />
       </div>
     </div>
-    <div v-if="bulkMode" ref="bulkEditor" class="flex flex-1 flex-col"></div>
+    <div v-if="bulkMode" class="h-full relative">
+      <div ref="bulkEditor" class="absolute inset-0"></div>
+    </div>
     <div v-else>
       <draggable
         v-model="workingParams"

packages/hoppscotch-common/src/components/http/PreRequestScript.vue

@@ -30,8 +30,8 @@
       </div>
     </div>
     <div class="flex flex-1 border-b border-dividerLight">
-      <div class="w-2/3 border-r border-dividerLight">
-        <div ref="preRequestEditor" class="h-full"></div>
+      <div class="w-2/3 border-r border-dividerLight h-full relative">
+        <div ref="preRequestEditor" class="h-full absolute inset-0"></div>
       </div>
       <div
         class="z-[9] sticky top-upperTertiaryStickyFold h-full min-w-[12rem] max-w-1/3 flex-shrink-0 overflow-auto overflow-x-auto bg-primary p-4"

packages/hoppscotch-common/src/components/http/RawBody.vue

@@ -59,7 +59,9 @@
         />
       </div>
     </div>
-    <div ref="rawBodyParameters" class="flex flex-1 flex-col"></div>
+    <div class="h-full relative">
+      <div ref="rawBodyParameters" class="absolute inset-0"></div>
+    </div>
   </div>
 </template>
 

packages/hoppscotch-common/src/components/http/RequestTab.vue

@@ -9,7 +9,7 @@
       />
     </template>
     <template #secondary>
-      <HttpResponse v-model:document="tab.document" />
+      <HttpResponse v-model:document="tab.document" :is-embed="false" />
     </template>
   </AppPaneLayout>
 </template>

packages/hoppscotch-common/src/components/http/Tests.vue

@@ -30,8 +30,8 @@
       </div>
     </div>
     <div class="flex flex-1 border-b border-dividerLight">
-      <div class="w-2/3 border-r border-dividerLight">
-        <div ref="testScriptEditor" class="h-full"></div>
+      <div class="w-2/3 border-r border-dividerLight h-full relative">
+        <div ref="testScriptEditor" class="h-full absolute inset-0"></div>
       </div>
       <div
         class="z-[9] sticky top-upperTertiaryStickyFold h-full min-w-[12rem] max-w-1/3 flex-shrink-0 overflow-auto overflow-x-auto bg-primary p-4"

packages/hoppscotch-common/src/components/http/URLEncodedParams.vue

@@ -44,7 +44,9 @@
         />
       </div>
     </div>
-    <div v-if="bulkMode" ref="bulkEditor" class="flex flex-1 flex-col"></div>
+    <div v-if="bulkMode" class="h-full relative">
+      <div ref="bulkEditor" class="absolute inset-0"></div>
+    </div>
     <div v-else>
       <draggable
         v-model="workingUrlEncodedParams"

packages/hoppscotch-common/src/components/importExport/ImportExportSteps/FileImport.vue

@@ -13,6 +13,7 @@
         {{ t(`${caption}`) }}
       </span>
     </p>
+
     <div
       class="flex flex-col ml-10 border border-dashed rounded border-dividerDark"
     >
@@ -23,15 +24,30 @@
         type="file"
         class="p-4 cursor-pointer transition file:transition file:cursor-pointer text-secondary hover:text-secondaryDark file:mr-2 file:py-2 file:px-4 file:rounded file:border-0 file:text-secondary hover:file:text-secondaryDark file:bg-primaryLight hover:file:bg-primaryDark"
         :accept="acceptedFileTypes"
+        multiple
         @change="onFileChange"
       />
     </div>
 
+    <p v-if="showFileSizeLimitExceededWarning" class="text-red-500 ml-10">
+      <template v-if="importFilesCount">
+        {{
+          t("import.file_size_limit_exceeded_warning_multiple_files", {
+            files:
+              importFilesCount === 1 ? "file" : `${importFilesCount} files`,
+          })
+        }}
+      </template>
+
+      <template v-else>
+        {{ t("import.file_size_limit_exceeded_warning_single_file") }}
+      </template>
+    </p>
     <div>
       <HoppButtonPrimary
         class="w-full"
         :label="t('import.title')"
-        :disabled="!hasFile"
+        :disabled="!hasFile || showFileSizeLimitExceededWarning"
         @click="emit('importFromFile', fileContent)"
       />
     </div>
@@ -51,16 +67,30 @@ defineProps<{
 const t = useI18n()
 const toast = useToast()
 
+const ALLOWED_FILE_SIZE_LIMIT = 10 // 10 MB
+
+const importFilesCount = ref(0)
+
 const hasFile = ref(false)
-const fileContent = ref("")
+const showFileSizeLimitExceededWarning = ref(false)
+const fileContent = ref<string[]>([])
 
 const inputChooseFileToImportFrom = ref<HTMLInputElement | any>()
 
 const emit = defineEmits<{
-  (e: "importFromFile", content: string): void
+  (e: "importFromFile", content: string[]): void
 }>()
 
-const onFileChange = () => {
+const onFileChange = async () => {
+  // Reset the state on entering the handler to avoid any stale state
+  if (showFileSizeLimitExceededWarning.value) {
+    showFileSizeLimitExceededWarning.value = false
+  }
+
+  if (importFilesCount.value) {
+    importFilesCount.value = 0
+  }
+
   const inputFileToImport = inputChooseFileToImportFrom.value
 
   if (!inputFileToImport) {
@@ -69,27 +99,52 @@ const onFileChange = () => {
   }
 
   if (!inputFileToImport.files || inputFileToImport.files.length === 0) {
-    inputChooseFileToImportFrom.value[0].value = ""
+    inputChooseFileToImportFrom.value = ""
     hasFile.value = false
     toast.show(t("action.choose_file").toString())
     return
   }
 
-  const reader = new FileReader()
+  const readerPromises: Promise<string | null>[] = []
 
-  reader.onload = ({ target }) => {
-    const content = target!.result as string | null
-    if (!content) {
-      hasFile.value = false
-      toast.show(t("action.choose_file").toString())
-      return
+  let totalFileSize = 0
+
+  for (let i = 0; i < inputFileToImport.files.length; i++) {
+    const file = inputFileToImport.files[i]
+
+    totalFileSize += file.size / 1024 / 1024
+
+    if (totalFileSize > ALLOWED_FILE_SIZE_LIMIT) {
+      showFileSizeLimitExceededWarning.value = true
+      break
     }
 
-    fileContent.value = content
+    const reader = new FileReader()
 
-    hasFile.value = !!content?.length
+    readerPromises.push(
+      new Promise((resolve, reject) => {
+        reader.onload = () => resolve(reader.result as string | null)
+        reader.onerror = reject
+        reader.readAsText(file)
+      })
+    )
   }
 
-  reader.readAsText(inputFileToImport.files[0])
+  importFilesCount.value = readerPromises.length
+
+  const results = await Promise.allSettled(readerPromises)
+
+  const contentsArr = results
+    .filter((result) => result.status === "fulfilled")
+    .map((result) => (result as { value: string | null }).value)
+    .filter(Boolean) as string[]
+
+  const errors = results.filter((result) => result.status === "rejected")
+  if (errors.length) {
+    toast.error(t("error.reading_files"))
+  }
+
+  fileContent.value = contentsArr
+  hasFile.value = contentsArr.length > 0
 }
 </script>

packages/hoppscotch-common/src/components/lenses/renderers/HTMLLensRenderer.vue

@@ -44,11 +44,9 @@
         />
       </div>
     </div>
-    <div
-      v-show="!previewEnabled"
-      ref="htmlResponse"
-      class="flex flex-1 flex-col"
-    ></div>
+    <div v-show="!previewEnabled" class="h-full">
+      <div ref="htmlResponse" class="flex flex-1 flex-col"></div>
+    </div>
     <iframe
       v-show="previewEnabled"
       ref="previewFrame"

packages/hoppscotch-common/src/components/lenses/renderers/JSONLensRenderer.vue

@@ -119,11 +119,12 @@
         />
       </div>
     </div>
-    <div
-      ref="jsonResponse"
-      class="flex h-auto h-full flex-1 flex-col"
-      :class="toggleFilter ? 'responseToggleOn' : 'responseToggleOff'"
-    ></div>
+    <div class="h-full">
+      <div
+        ref="jsonResponse"
+        :class="toggleFilter ? 'responseToggleOn' : 'responseToggleOff'"
+      ></div>
+    </div>
     <div
       v-if="outlinePath"
       class="sticky bottom-0 z-10 flex flex-shrink-0 flex-nowrap overflow-auto overflow-x-auto border-t border-dividerLight bg-primaryLight px-2"

packages/hoppscotch-common/src/components/lenses/renderers/RawLensRenderer.vue

@@ -35,7 +35,9 @@
         />
       </div>
     </div>
-    <div ref="rawResponse" class="flex flex-1 flex-col"></div>
+    <div class="h-full">
+      <div ref="rawResponse" class="flex flex-1 flex-col"></div>
+    </div>
   </div>
 </template>
 

packages/hoppscotch-common/src/components/lenses/renderers/XMLLensRenderer.vue

@@ -35,7 +35,9 @@
         />
       </div>
     </div>
-    <div ref="xmlResponse" class="flex flex-1 flex-col"></div>
+    <div class="h-full">
+      <div ref="xmlResponse" class="flex flex-1 flex-col"></div>
+    </div>
   </div>
 </template>
 

packages/hoppscotch-common/src/components/realtime/Communication.vue

@@ -130,7 +130,9 @@
         />
       </div>
     </div>
-    <div ref="wsCommunicationBody" class="flex flex-1 flex-col"></div>
+    <div class="h-full">
+      <div ref="wsCommunicationBody" class="flex flex-1 flex-col"></div>
+    </div>
   </div>
 </template>
 <script setup lang="ts">

packages/hoppscotch-common/src/components/share/Request.vue

@@ -62,7 +62,7 @@
                 :shortcut="['T']"
                 @click="
                   () => {
-                    openInNewTab()
+                    emit('open-shared-request', parseRequest)
                     hide()
                   }
                 "
@@ -128,6 +128,7 @@ const emit = defineEmits<{
     embedProperties?: string | null
   ): void
   (e: "delete-shared-request", codeID: string): void
+  (e: "open-shared-request", request: HoppRESTRequest): void
 }>()
 
 const tippyActions = ref<TippyComponent | null>(null)

packages/hoppscotch-common/src/components/share/index.vue

@@ -53,6 +53,7 @@
           :request="request"
           @customize-shared-request="customizeSharedRequest"
           @delete-shared-request="deleteSharedRequest"
+          @open-shared-request="openRequestInNewTab"
         />
         <HoppSmartIntersection
           v-if="hasMoreSharedRequests"
@@ -483,6 +484,13 @@ const getErrorMessage = (err: GQLError<string>) => {
   }
 }
 
+const openRequestInNewTab = (request: HoppRESTRequest) => {
+  restTab.createNewTab({
+    isDirty: false,
+    request,
+  })
+}
+
 defineActionHandler("share.request", ({ request }) => {
   requestToShare.value = request
   displayShareRequestModal(true)

packages/hoppscotch-common/src/helpers/curl/__tests__/curlparser.spec.js

@@ -18,7 +18,7 @@ const samples = [
       method: "GET",
       name: "Untitled",
       endpoint: "https://echo.hoppscotch.io/",
-      auth: { authType: "none", authActive: true },
+      auth: { authType: "inherit", authActive: true },
       body: {
         contentType: "application/x-www-form-urlencoded",
         body: rawKeyValueEntriesToString([
@@ -149,7 +149,7 @@ const samples = [
       method: "GET",
       name: "Untitled",
       endpoint: "https://google.com/",
-      auth: { authType: "none", authActive: true },
+      auth: { authType: "inherit", authActive: true },
       body: {
         contentType: null,
         body: null,
@@ -166,7 +166,7 @@ const samples = [
       method: "POST",
       name: "Untitled",
       endpoint: "http://localhost:1111/hello/world/?buzz",
-      auth: { authType: "none", authActive: true },
+      auth: { authType: "inherit", authActive: true },
       body: {
         contentType: "application/json",
         body: `{\n  "foo": "bar"\n}`,
@@ -189,7 +189,7 @@ const samples = [
       method: "GET",
       name: "Untitled",
       endpoint: "https://example.com/",
-      auth: { authType: "none", authActive: true },
+      auth: { authType: "inherit", authActive: true },
       body: {
         contentType: null,
         body: null,
@@ -217,7 +217,7 @@ const samples = [
       method: "POST",
       name: "Untitled",
       endpoint: "https://bing.com/",
-      auth: { authType: "none", authActive: true },
+      auth: { authType: "inherit", authActive: true },
       body: {
         contentType: "multipart/form-data",
         body: [
@@ -301,7 +301,7 @@ const samples = [
       name: "Untitled",
       endpoint: "http://localhost:9900/",
       auth: {
-        authType: "none",
+        authType: "inherit",
         authActive: true,
       },
       body: {
@@ -345,7 +345,7 @@ const samples = [
       endpoint: "https://hoppscotch.io/?io",
       auth: {
         authActive: true,
-        authType: "none",
+        authType: "inherit",
       },
       body: {
         contentType: null,
@@ -380,7 +380,7 @@ const samples = [
       endpoint: "https://someshadywebsite.com/questionable/path/?so",
       auth: {
         authActive: true,
-        authType: "none",
+        authType: "inherit",
       },
       body: {
         contentType: "multipart/form-data",
@@ -441,7 +441,7 @@ const samples = [
       endpoint: "http://localhost/",
       auth: {
         authActive: true,
-        authType: "none",
+        authType: "inherit",
       },
       body: {
         contentType: "multipart/form-data",
@@ -473,7 +473,7 @@ const samples = [
       method: "GET",
       name: "Untitled",
       endpoint: "https://hoppscotch.io/",
-      auth: { authType: "none", authActive: true },
+      auth: { authType: "inherit", authActive: true },
       body: {
         contentType: null,
         body: null,
@@ -528,7 +528,7 @@ const samples = [
       method: "GET",
       name: "Untitled",
       endpoint: "https://echo.hoppscotch.io/",
-      auth: { authType: "none", authActive: true },
+      auth: { authType: "inherit", authActive: true },
       body: {
         contentType: "application/x-www-form-urlencoded",
         body: rawKeyValueEntriesToString([
@@ -573,7 +573,7 @@ const samples = [
       name: "Untitled",
       endpoint: "https://echo.hoppscotch.io/",
       method: "POST",
-      auth: { authType: "none", authActive: true },
+      auth: { authType: "inherit", authActive: true },
       headers: [
         {
           active: true,
@@ -615,7 +615,7 @@ const samples = [
       name: "Untitled",
       endpoint: "https://muxueqz.top/skybook.html",
       method: "GET",
-      auth: { authType: "none", authActive: true },
+      auth: { authType: "inherit", authActive: true },
       headers: [],
       body: { contentType: null, body: null },
       params: [],
@@ -629,7 +629,7 @@ const samples = [
       name: "Untitled",
       endpoint: "https://echo.hoppscotch.io/",
       method: "POST",
-      auth: { authType: "none", authActive: true },
+      auth: { authType: "inherit", authActive: true },
       headers: [],
       body: {
         contentType: "multipart/form-data",
@@ -653,7 +653,7 @@ const samples = [
       name: "Untitled",
       endpoint: "http://127.0.0.1/",
       method: "CUSTOMMETHOD",
-      auth: { authType: "none", authActive: true },
+      auth: { authType: "inherit", authActive: true },
       headers: [],
       body: {
         contentType: null,
@@ -670,7 +670,7 @@ const samples = [
       name: "Untitled",
       endpoint: "https://echo.hoppscotch.io/",
       method: "GET",
-      auth: { authType: "none", authActive: true },
+      auth: { authType: "inherit", authActive: true },
       headers: [
         {
           active: true,
@@ -693,7 +693,7 @@ const samples = [
       name: "Untitled",
       endpoint: "https://echo.hoppscotch.io/",
       method: "GET",
-      auth: { authType: "none", authActive: true },
+      auth: { authType: "inherit", authActive: true },
       headers: [],
       body: {
         contentType: null,
@@ -710,7 +710,7 @@ const samples = [
       name: "Untitled",
       endpoint: "https://example.org/",
       method: "HEAD",
-      auth: { authType: "none", authActive: true },
+      auth: { authType: "inherit", authActive: true },
       headers: [],
       body: {
         contentType: null,
@@ -756,7 +756,7 @@ const samples = [
       name: "Untitled",
       endpoint: "https://google.com/",
       auth: {
-        authType: "none",
+        authType: "inherit",
         authActive: true,
       },
       body: {
@@ -777,7 +777,7 @@ const samples = [
       name: "Untitled",
       endpoint: "https://google.com/",
       auth: {
-        authType: "none",
+        authType: "inherit",
         authActive: true,
       },
       body: {
@@ -797,7 +797,7 @@ const samples = [
       name: "Untitled",
       endpoint: "http://192.168.0.24:8080/ping",
       auth: {
-        authType: "none",
+        authType: "inherit",
         authActive: true,
       },
       body: {
@@ -817,7 +817,7 @@ const samples = [
       name: "Untitled",
       endpoint: "https://example.com/",
       auth: {
-        authType: "none",
+        authType: "inherit",
         authActive: true,
       },
       body: {

packages/hoppscotch-common/src/helpers/editor/themes/baseTheme.ts

@@ -171,9 +171,6 @@ export const baseTheme = EditorView.theme({
   ".cm-activeLineGutter": {
     backgroundColor: "transparent",
   },
-  ".cm-scroller::-webkit-scrollbar": {
-    display: "none",
-  },
   ".cm-foldPlaceholder": {
     backgroundColor: "var(--divider-light-color)",
     color: "var(--secondary-dark-color)",
@@ -320,9 +317,6 @@ export const inputTheme = EditorView.theme({
   ".cm-activeLineGutter": {
     backgroundColor: "transparent",
   },
-  ".cm-scroller::-webkit-scrollbar": {
-    display: "none",
-  },
   ".cm-foldPlaceholder": {
     backgroundColor: "var(--divider-light-color)",
     color: "var(--secondary-dark-color)",

packages/hoppscotch-common/src/helpers/graphql/default.ts

@@ -27,7 +27,7 @@ export const getDefaultGQLRequest = (): HoppGQLRequest => ({
 }`,
   query: DEFAULT_QUERY,
   auth: {
-    authType: "none",
+    authType: "inherit",
     authActive: true,
   },
 })

packages/hoppscotch-common/src/helpers/import-export/import/hopp.ts

@@ -2,6 +2,7 @@ import { pipe, flow } from "fp-ts/function"
 import * as TE from "fp-ts/TaskEither"
 import * as O from "fp-ts/Option"
 import * as RA from "fp-ts/ReadonlyArray"
+import * as A from "fp-ts/Array"
 import { translateToNewRESTCollection, HoppCollection } from "@hoppscotch/data"
 import { isPlainObject as _isPlainObject } from "lodash-es"
 
@@ -9,11 +10,13 @@ import { IMPORTER_INVALID_FILE_FORMAT } from "."
 import { safeParseJSON } from "~/helpers/functional/json"
 import { translateToNewGQLCollection } from "@hoppscotch/data"
 
-export const hoppRESTImporter = (content: string) =>
+export const hoppRESTImporter = (content: string[]) =>
   pipe(
-    safeParseJSON(content),
+    content,
+    A.traverse(O.Applicative)((str) => safeParseJSON(str, true)),
     O.chain(
       flow(
+        A.flatten,
         makeCollectionsArray,
         RA.map(validateCollection),
         O.sequenceArray,

packages/hoppscotch-common/src/helpers/import-export/import/hoppEnv.ts

@@ -8,17 +8,35 @@ import { IMPORTER_INVALID_FILE_FORMAT } from "."
 import { Environment } from "@hoppscotch/data"
 import { z } from "zod"
 
-export const hoppEnvImporter = (content: string) => {
-  const parsedContent = safeParseJSON(content, true)
+export const hoppEnvImporter = (contents: string[]) => {
+  const parsedContents = contents.map((str) => safeParseJSON(str, true))
 
-  // parse json from the environments string
-  if (O.isNone(parsedContent)) {
+  if (parsedContents.some((parsed) => O.isNone(parsed))) {
     return TE.left(IMPORTER_INVALID_FILE_FORMAT)
   }
 
+  const parsedValues = parsedContents.flatMap((content) => {
+    const unwrappedContent = O.toNullable(content) as Environment[] | null
+
+    if (unwrappedContent) {
+      return unwrappedContent.map((contentEntry) => {
+        return {
+          ...contentEntry,
+          variables: contentEntry.variables?.map((valueEntry) => ({
+            ...valueEntry,
+            ...("value" in valueEntry
+              ? { value: String(valueEntry.value) }
+              : {}),
+          })),
+        }
+      })
+    }
+    return null
+  })
+
   const validationResult = z
     .array(entityReference(Environment))
-    .safeParse(parsedContent.value)
+    .safeParse(parsedValues)
 
   if (!validationResult.success) {
     return TE.left(IMPORTER_INVALID_FILE_FORMAT)

packages/hoppscotch-common/src/helpers/import-export/import/hoppGql.ts

@@ -3,10 +3,10 @@ import * as E from "fp-ts/Either"
 
 // TODO: add zod validation
 export const hoppGqlCollectionsImporter = (
-  content: string
+  contents: string[]
 ): E.Either<"INVALID_JSON", HoppCollection[]> => {
   return E.tryCatch(
-    () => JSON.parse(content) as HoppCollection[],
+    () => contents.flatMap((content) => JSON.parse(content)),
     () => "INVALID_JSON"
   )
 }

packages/hoppscotch-common/src/helpers/import-export/import/import-sources/FileSource.ts

@@ -6,7 +6,7 @@ import { v4 as uuidv4 } from "uuid"
 export function FileSource(metadata: {
   acceptedFileTypes: string
   caption: string
-  onImportFromFile: (content: string) => any | Promise<any>
+  onImportFromFile: (content: string[]) => any | Promise<any>
 }) {
   const stepID = uuidv4()
 

packages/hoppscotch-common/src/helpers/import-export/import/import-sources/GistSource.ts

@@ -10,14 +10,14 @@ import { v4 as uuidv4 } from "uuid"
 export function GistSource(metadata: {
   caption: string
   onImportFromGist: (
-    importResult: E.Either<string, string>
+    importResult: E.Either<string, string[]>
   ) => any | Promise<any>
 }) {
   const stepID = uuidv4()
 
   return defineStep(stepID, UrlImport, () => ({
     caption: metadata.caption,
-    onImportFromURL: (gistResponse) => {
+    onImportFromURL: (gistResponse: Record<string, unknown>) => {
       const fileSchema = z.object({
         files: z.record(z.object({ content: z.string() })),
       })
@@ -29,9 +29,11 @@ export function GistSource(metadata: {
         return
       }
 
-      const content = Object.values(parseResult.data.files)[0].content
+      const contents = Object.values(parseResult.data.files).map(
+        ({ content }) => content
+      )
 
-      metadata.onImportFromGist(E.right(content))
+      metadata.onImportFromGist(E.right(contents))
     },
     fetchLogic: fetchGistFromUrl,
   }))

packages/hoppscotch-common/src/helpers/import-export/import/insomnia.ts

@@ -1,19 +1,21 @@
-import { convert, ImportRequest } from "insomnia-importers"
-import { pipe } from "fp-ts/function"
 import {
+  HoppCollection,
   HoppRESTAuth,
   HoppRESTHeader,
   HoppRESTParam,
   HoppRESTReqBody,
   HoppRESTRequest,
   knownContentTypes,
-  makeRESTRequest,
-  HoppCollection,
   makeCollection,
+  makeRESTRequest,
 } from "@hoppscotch/data"
+
 import * as A from "fp-ts/Array"
-import * as TO from "fp-ts/TaskOption"
 import * as TE from "fp-ts/TaskEither"
+import * as TO from "fp-ts/TaskOption"
+import { pipe } from "fp-ts/function"
+import { ImportRequest, convert } from "insomnia-importers"
+
 import { IMPORTER_INVALID_FILE_FORMAT } from "."
 import { replaceInsomniaTemplating } from "./insomniaEnv"
 
@@ -203,15 +205,18 @@ const getHoppFolder = (
     headers: [],
   })
 
-const getHoppCollections = (doc: InsomniaDoc) =>
-  getFoldersIn(null, doc.data.resources).map((f) =>
-    getHoppFolder(f, doc.data.resources)
-  )
+const getHoppCollections = (docs: InsomniaDoc[]) => {
+  return docs.flatMap((doc) => {
+    return getFoldersIn(null, doc.data.resources).map((f) =>
+      getHoppFolder(f, doc.data.resources)
+    )
+  })
+}
 
-export const hoppInsomniaImporter = (fileContent: string) =>
+export const hoppInsomniaImporter = (fileContents: string[]) =>
   pipe(
-    fileContent,
-    parseInsomniaDoc,
+    fileContents,
+    A.traverse(TO.ApplicativeSeq)(parseInsomniaDoc),
     TO.map(getHoppCollections),
     TE.fromTaskOption(() => IMPORTER_INVALID_FILE_FORMAT)
   )

packages/hoppscotch-common/src/helpers/import-export/import/insomniaEnv.ts

@@ -29,33 +29,36 @@ export const replaceInsomniaTemplating = (expression: string) => {
   return expression.replaceAll(regex, "<<$1>>")
 }
 
-export const insomniaEnvImporter = (content: string) => {
-  const parsedContent = safeParseJSONOrYAML(content)
-
-  if (O.isNone(parsedContent)) {
+export const insomniaEnvImporter = (contents: string[]) => {
+  const parsedContents = contents.map((str) => safeParseJSONOrYAML(str))
+  if (parsedContents.some((parsed) => O.isNone(parsed))) {
     return TE.left(IMPORTER_INVALID_FILE_FORMAT)
   }
 
-  const validationResult = insomniaResourcesSchema.safeParse(
-    parsedContent.value
-  )
+  const parsedValues = parsedContents.map((parsed) => O.toNullable(parsed))
+
+  const validationResult = z
+    .array(insomniaResourcesSchema)
+    .safeParse(parsedValues)
 
   if (!validationResult.success) {
     return TE.left(IMPORTER_INVALID_FILE_FORMAT)
   }
 
-  const insomniaEnvs = validationResult.data.resources
-    .filter((resource) => resource._type === "environment")
-    .map((envResource) => {
-      const envResourceData = envResource.data as Record<string, unknown>
-      const stringifiedData: Record<string, string> = {}
+  const insomniaEnvs = validationResult.data.flatMap(({ resources }) => {
+    return resources
+      .filter((resource) => resource._type === "environment")
+      .map((envResource) => {
+        const envResourceData = envResource.data as Record<string, unknown>
+        const stringifiedData: Record<string, string> = {}
 
-      Object.keys(envResourceData).forEach((key) => {
-        stringifiedData[key] = String(envResourceData[key])
+        Object.keys(envResourceData).forEach((key) => {
+          stringifiedData[key] = String(envResourceData[key])
+        })
+
+        return { ...envResource, data: stringifiedData }
       })
-
-      return { ...envResource, data: stringifiedData }
-    })
+  })
 
   const environments: NonSecretEnvironment[] = []
 

packages/hoppscotch-common/src/helpers/import-export/import/openapi.ts

@@ -584,24 +584,28 @@ const convertPathToHoppReqs = (
     RA.toArray
   )
 
-const convertOpenApiDocToHopp = (
-  doc: OpenAPI.Document
+const convertOpenApiDocsToHopp = (
+  docs: OpenAPI.Document[]
 ): TE.TaskEither<never, HoppCollection[]> => {
-  const name = doc.info.title
+  const collections = docs.map((doc) => {
+    const name = doc.info.title
 
-  const paths = Object.entries(doc.paths ?? {})
-    .map(([pathName, pathObj]) => convertPathToHoppReqs(doc, pathName, pathObj))
-    .flat()
+    const paths = Object.entries(doc.paths ?? {})
+      .map(([pathName, pathObj]) =>
+        convertPathToHoppReqs(doc, pathName, pathObj)
+      )
+      .flat()
 
-  return TE.of([
-    makeCollection({
+    return makeCollection({
       name,
       folders: [],
       requests: paths,
       auth: { authType: "inherit", authActive: true },
       headers: [],
-    }),
-  ])
+    })
+  })
+
+  return TE.of(collections)
 }
 
 const parseOpenAPIDocContent = (str: string) =>
@@ -614,29 +618,49 @@ const parseOpenAPIDocContent = (str: string) =>
     )
   )
 
-export const hoppOpenAPIImporter = (fileContent: string) =>
+export const hoppOpenAPIImporter = (fileContents: string[]) =>
   pipe(
     // See if we can parse JSON properly
-    fileContent,
-    parseOpenAPIDocContent,
-    TE.fromOption(() => IMPORTER_INVALID_FILE_FORMAT),
+    fileContents,
+    A.traverse(O.Applicative)(parseOpenAPIDocContent),
+    TE.fromOption(() => {
+      return IMPORTER_INVALID_FILE_FORMAT
+    }),
     // Try validating, else the importer is invalid file format
-    TE.chainW((obj) =>
-      pipe(
+    TE.chainW((docArr) => {
+      return pipe(
         TE.tryCatch(
-          () => SwaggerParser.validate(obj),
+          async () => {
+            const resultDoc = []
+
+            for (const docObj of docArr) {
+              const validatedDoc = await SwaggerParser.validate(docObj)
+              resultDoc.push(validatedDoc)
+            }
+
+            return resultDoc
+          },
           () => IMPORTER_INVALID_FILE_FORMAT
         )
       )
-    ),
+    }),
     // Deference the references
-    TE.chainW((obj) =>
+    TE.chainW((docArr) =>
       pipe(
         TE.tryCatch(
-          () => SwaggerParser.dereference(obj),
+          async () => {
+            const resultDoc = []
+
+            for (const docObj of docArr) {
+              const validatedDoc = await SwaggerParser.dereference(docObj)
+              resultDoc.push(validatedDoc)
+            }
+
+            return resultDoc
+          },
           () => OPENAPI_DEREF_ERROR
         )
       )
     ),
-    TE.chainW(convertOpenApiDocToHopp)
+    TE.chainW(convertOpenApiDocsToHopp)
   )

packages/hoppscotch-common/src/helpers/import-export/import/postman.ts

@@ -55,7 +55,11 @@ const readPMCollection = (def: string) =>
   pipe(
     def,
     safeParseJSON,
-    O.chain((data) => O.tryCatch(() => new PMCollection(data)))
+    O.chain((data) =>
+      O.tryCatch(() => {
+        return new PMCollection(data)
+      })
+    )
   )
 
 const getHoppReqHeaders = (item: Item): HoppRESTHeader[] =>
@@ -296,15 +300,17 @@ const getHoppFolder = (ig: ItemGroup<Item>): HoppCollection =>
     headers: [],
   })
 
-export const getHoppCollection = (coll: PMCollection) => getHoppFolder(coll)
+export const getHoppCollections = (collections: PMCollection[]) => {
+  return collections.map(getHoppFolder)
+}
 
-export const hoppPostmanImporter = (fileContent: string) =>
+export const hoppPostmanImporter = (fileContents: string[]) =>
   pipe(
     // Try reading
-    fileContent,
-    readPMCollection,
+    fileContents,
+    A.traverse(O.Applicative)(readPMCollection),
 
-    O.map(flow(getHoppCollection, A.of)),
+    O.map(flow(getHoppCollections)),
 
     TE.fromOption(() => IMPORTER_INVALID_FILE_FORMAT)
   )

packages/hoppscotch-common/src/helpers/import-export/import/postmanEnv.ts

@@ -1,12 +1,11 @@
-import * as TE from "fp-ts/TaskEither"
-import * as O from "fp-ts/Option"
-
-import { IMPORTER_INVALID_FILE_FORMAT } from "."
-import { safeParseJSON } from "~/helpers/functional/json"
-
-import { z } from "zod"
 import { Environment } from "@hoppscotch/data"
+import * as O from "fp-ts/Option"
+import * as TE from "fp-ts/TaskEither"
 import { uniqueId } from "lodash-es"
+import { z } from "zod"
+
+import { safeParseJSON } from "~/helpers/functional/json"
+import { IMPORTER_INVALID_FILE_FORMAT } from "."
 
 const postmanEnvSchema = z.object({
   name: z.string(),
@@ -18,32 +17,44 @@ const postmanEnvSchema = z.object({
   ),
 })
 
-export const postmanEnvImporter = (content: string) => {
-  const parsedContent = safeParseJSON(content)
+type PostmanEnv = z.infer<typeof postmanEnvSchema>
 
-  // parse json from the environments string
-  if (O.isNone(parsedContent)) {
+export const postmanEnvImporter = (contents: string[]) => {
+  const parsedContents = contents.map((str) => safeParseJSON(str, true))
+  if (parsedContents.some((parsed) => O.isNone(parsed))) {
     return TE.left(IMPORTER_INVALID_FILE_FORMAT)
   }
 
-  const validationResult = postmanEnvSchema.safeParse(parsedContent.value)
+  const parsedValues = parsedContents.flatMap((parsed) => {
+    const unwrappedEntry = O.toNullable(parsed) as PostmanEnv[] | null
+
+    if (unwrappedEntry) {
+      return unwrappedEntry.map((entry) => ({
+        ...entry,
+        values: entry.values?.map((valueEntry) => ({
+          ...valueEntry,
+          value: String(valueEntry.value),
+        })),
+      }))
+    }
+    return null
+  })
+
+  const validationResult = z.array(postmanEnvSchema).safeParse(parsedValues)
 
   if (!validationResult.success) {
     return TE.left(IMPORTER_INVALID_FILE_FORMAT)
   }
 
-  const postmanEnv = validationResult.data
-
-  const environment: Environment = {
-    id: uniqueId(),
-    v: 1,
-    name: postmanEnv.name,
-    variables: [],
-  }
-
-  postmanEnv.values.forEach(({ key, value }) =>
-    environment.variables.push({ key, value, secret: false })
+  // Convert `values` to `variables` to match the format expected by the system
+  const environments: Environment[] = validationResult.data.map(
+    ({ name, values }) => ({
+      id: uniqueId(),
+      v: 1,
+      name,
+      variables: values.map((entires) => ({ ...entires, secret: false })),
+    })
   )
 
-  return TE.right(environment)
+  return TE.right(environments)
 }

packages/hoppscotch-common/src/helpers/oauth.ts

@@ -250,19 +250,23 @@ const handleOAuthRedirect = async () => {
     return E.left("NO_CODE_VERIFIER" as const)
   }
 
+  const data = new URLSearchParams({
+    grant_type: "authorization_code",
+    code: queryParams.code,
+    client_id: clientID,
+    client_secret: clientSecret,
+    redirect_uri: redirectUri,
+    code_verifier: codeVerifier,
+  })
+
   // Exchange the authorization code for an access token
   const tokenResponse = await runRequestThroughInterceptor({
     url: tokenEndpoint,
-    data: JSON.stringify({
-      grant_type: "authorization_code",
-      code: queryParams.code,
-      client_id: clientID,
-      client_secret: clientSecret,
-      redirect_uri: redirectUri,
-      code_verifier: codeVerifier,
-    }),
+    data: data.toString(),
     method: "POST",
-    headers: {},
+    headers: {
+      "Content-Type": "application/x-www-form-urlencoded",
+    },
   })
 
   // Clean these up since we don't need them anymore

packages/hoppscotch-common/src/helpers/rest/default.ts

@@ -8,7 +8,7 @@ export const getDefaultRESTRequest = (): HoppRESTRequest => ({
   headers: [],
   method: "GET",
   auth: {
-    authType: "none",
+    authType: "inherit",
     authActive: true,
   },
   preRequestScript: "",