Skip to content

Open-Source API Development Ecosystem • https://hoppscotch.io • Offline, On-Prem & Cloud • Web, Desktop & CLI • Open-Source Alternative to Postman, Insomnia

chore: resolved all merge conflicts

Balu Babuca4c576f7838
diff --cc packages/hoppscotch-backend/prisma/schema.prisma
index 01d5fa972,28e11e010..b42205a69
--- a/packages/hoppscotch-backend/prisma/schema.prisma
+++ b/packages/hoppscotch-backend/prisma/schema.prisma
@@@ -79,42 -79,50 +79,80 @@@ model TeamEnvironment
}
model User {
- uid String @id @default(cuid())
- displayName String?
- email String?
- photoURL String?
- currentRESTSession Json?
- currentGQLSession Json?
- settings UserSettings?
- UserHistory UserHistory[]
- UserEnvironments UserEnvironment[]
+ uid String @id @default(cuid())
+ displayName String?
+ email String? @unique
+ photoURL String?
+ isAdmin Boolean @default(false)
+ refreshToken String?
+ accounts Account[]
- createdOn DateTime @default(now()) @db.Timestamp(3)
+ PasswordlessVerification PasswordlessVerification[]
++ settings UserSettings?
++ UserHistory UserHistory[]
++ UserEnvironments UserEnvironment[]
++ currentRESTSession Json?
++ currentGQLSession Json?
++ createdOn DateTime @default(now()) @db.Timestamp(3)
+}
+
+model Account {
+ id String @id @default(cuid())
+ userId String
+ provider String
+ providerAccountId String
+ providerRefreshToken String?
+ providerAccessToken String?
+ providerScope String?
+ loggedIn DateTime @default(now()) @db.Timestamp(3)
+
+ user User @relation(fields: [userId], references: [uid], onDelete: Cascade)
+
+ @@unique(fields: [provider, providerAccountId], name: "verifyProviderAccount")
+}
+
+model PasswordlessVerification {
+ deviceIdentifier String
+ token String @unique @default(cuid())
+ userUid String
+ user User @relation(fields: [userUid], references: [uid], onDelete: Cascade)
+ expiresOn DateTime @db.Timestamp(3)
+
+ @@unique(fields: [deviceIdentifier, token], name: "passwordless_deviceIdentifier_tokens")
}
+ model UserSettings {
+ id String @id @default(cuid())
+ userUid String @unique
+ user User @relation(fields: [userUid], references: [uid], onDelete: Cascade)
+ properties Json
+ updatedOn DateTime @updatedAt @db.Timestamp(3)
+ }
+
+ model UserHistory {
+ id String @id @default(cuid())
+ userUid String
+ user User @relation(fields: [userUid], references: [uid], onDelete: Cascade)
+ reqType ReqType
+ request Json
+ responseMetadata Json
+ isStarred Boolean
+ executedOn DateTime @default(now()) @db.Timestamp(3)
+ }
+
+ enum ReqType {
+ REST
+ GQL
+ }
+
+ model UserEnvironment {
+ id String @id @default(cuid())
+ userUid String
+ user User @relation(fields: [userUid], references: [uid], onDelete: Cascade)
+ name String?
+ variables Json
+ isGlobal Boolean
+ }
+
enum TeamMemberRole {
OWNER
VIEWER
diff --cc packages/hoppscotch-backend/src/app.module.ts
index 5ffd49e90,80d1d83b4..e44a2ed05
--- a/packages/hoppscotch-backend/src/app.module.ts
+++ b/packages/hoppscotch-backend/src/app.module.ts
@@@ -3,7 -3,9 +3,10 @@@ import { GraphQLModule } from '@nestjs/
import { ApolloDriver, ApolloDriverConfig } from '@nestjs/apollo';
import { UserModule } from './user/user.module';
import { GQLComplexityPlugin } from './plugins/GQLComplexityPlugin';
+import { AuthModule } from './auth/auth.module';
+ import { UserSettingsModule } from './user-settings/user-settings.module';
+ import { UserEnvironmentsModule } from './user-environment/user-environments.module';
+ import { UserHistoryModule } from './user-history/user-history.module';
@Module({
imports: [
@@@ -49,7 -47,9 +52,10 @@@
driver: ApolloDriver,
}),
UserModule,
+ AuthModule,
+ UserSettingsModule,
+ UserEnvironmentsModule,
+ UserHistoryModule,
],
providers: [GQLComplexityPlugin],
})
diff --cc packages/hoppscotch-backend/src/user/user.model.ts
index 2bacac70a,d06319358..f4997fb17
--- a/packages/hoppscotch-backend/src/user/user.model.ts
+++ b/packages/hoppscotch-backend/src/user/user.model.ts
@@@ -25,13 -31,24 +31,34 @@@ export class User
})
photoURL?: string;
+ @Field({
+ description: 'Flag to determine if user is an Admin or not',
+ })
+ isAdmin: boolean;
+
+ @Field({
+ description: 'Date when the user account was created',
+ })
+ createdOn: Date;
++
+ @Field({
+ nullable: true,
+ description: 'Stringified current REST session for logged-in User',
+ })
+ currentRESTSession?: string;
+
+ @Field({
+ nullable: true,
+ description: 'Stringified current GraphQL session for logged-in User',
+ })
+ currentGQLSession?: string;
}
+
+ export enum SessionType {
+ REST = 'REST',
+ GQL = 'GQL',
+ }
+
+ registerEnumType(SessionType, {
+ name: 'SessionType',
+ });
diff --cc packages/hoppscotch-backend/src/user/user.resolver.ts
index a6a3d9dbf,a3c88fe2a..3c5ab1080
--- a/packages/hoppscotch-backend/src/user/user.resolver.ts
+++ b/packages/hoppscotch-backend/src/user/user.resolver.ts
@@@ -13,7 -20,55 +20,46 @@@ export class UserResolver
"Gives details of the user executing this query (pass Authorization 'Bearer' header)",
})
@UseGuards(GqlAuthGuard)
- me(@GqlUser() user: User): User {
- return user;
- }
-
- @Query(() => User, {
- description:
- "Gives details of the user executing this query (pass Authorization 'Bearer' header)",
- })
- @UseGuards(GqlAuthGuard)
- me2(@GqlUser() user: User): User {
+ me(@GqlUser() user) {
return user;
}
+
+ /* Mutations */
+
+ @Mutation(() => User, {
+ description: 'Update user sessions',
+ })
+ @UseGuards(GqlAuthGuard)
+ async updateUserSessions(
+ @GqlUser() user: User,
+ @Args({
+ name: 'currentSession',
+ description: 'JSON string of the saved REST/GQL session',
+ })
+ currentSession: string,
+ @Args({
+ name: 'sessionType',
+ description: 'Type of the session',
+ })
+ sessionType: SessionType,
+ ): Promise<User> {
+ const updatedUser = await this.userService.updateUserSessions(
+ user,
+ currentSession,
+ sessionType,
+ );
+ if (E.isLeft(updatedUser)) throwErr(updatedUser.left);
+ return updatedUser.right;
+ }
+
+ /* Subscriptions */
+
+ @Subscription(() => User, {
+ description: 'Listen for user updates',
+ resolve: (value) => value,
+ })
+ @UseGuards(GqlAuthGuard)
+ userUpdated(@GqlUser() user: User) {
+ return this.pubsub.asyncIterator(`user/${user.uid}/updated`);
+ }
}
diff --cc packages/hoppscotch-backend/src/user/user.service.spec.ts
index 6a29590b5,4561a6f61..5b9b63edf
--- a/packages/hoppscotch-backend/src/user/user.service.spec.ts
+++ b/packages/hoppscotch-backend/src/user/user.service.spec.ts
@@@ -1,215 -1,108 +1,306 @@@
-import { mockDeep, mockReset } from 'jest-mock-extended';
+ import { JSON_INVALID } from 'src/errors';
+import { mockDeep, mockReset } from 'jest-mock-extended';
import { PrismaService } from 'src/prisma/prisma.service';
-import { PubSubService } from 'src/pubsub/pubsub.service';
+import { AuthUser } from 'src/types/AuthUser';
+import { User } from './user.model';
import { UserService } from './user.service';
++import { PubSubService } from 'src/pubsub/pubsub.service';
const mockPrisma = mockDeep<PrismaService>();
+ const mockPubSub = mockDeep<PubSubService>();
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
// @ts-ignore
- const userService = new UserService(mockPrisma);
+ const userService = new UserService(mockPrisma, mockPubSub as any);
-const user = {
- uid: '123',
- displayName: 'John Doe',
- email: '[email protected]',
- photoURL: 'https://example.com/avatar.png',
+const currentTime = new Date();
+
+const user: AuthUser = {
+ uid: '123344',
+ email: '[email protected]',
+ displayName: 'Dwight Schrute',
+ photoURL: 'https://en.wikipedia.org/wiki/Dwight_Schrute',
+ isAdmin: false,
+ currentRESTSession: JSON.stringify({}),
+ currentGQLSession: JSON.stringify({}),
+ refreshToken: 'hbfvdkhjbvkdvdfjvbnkhjb',
+ createdOn: currentTime,
+};
+
+const exampleSSOProfileData = {
+ id: '123rfedvd',
+ emails: [{ value: '[email protected]' }],
+ displayName: 'Dwight Schrute',
+ provider: 'google',
+ photos: 'https://en.wikipedia.org/wiki/Dwight_Schrute',
};
+ beforeEach(() => {
+ mockReset(mockPrisma);
+ mockPubSub.publish.mockClear();
+ });
+
-describe('UserService', () => {
- describe('updateUserSessions', () => {
- test('Should resolve right and update users GQL session', async () => {
- const sessionData = user.currentGQLSession;
- mockPrisma.user.update.mockResolvedValue({
- ...user,
- currentGQLSession: JSON.parse(sessionData),
- currentRESTSession: null,
- });
-
- const result = await userService.updateUserSessions(
- user,
- sessionData,
- 'GQL',
- );
-
- expect(result).toEqualRight({
- ...user,
- currentGQLSession: sessionData,
- currentRESTSession: null,
- });
- });
- test('Should resolve right and update users REST session', async () => {
- const sessionData = user.currentGQLSession;
- mockPrisma.user.update.mockResolvedValue({
- ...user,
- currentGQLSession: null,
- currentRESTSession: JSON.parse(sessionData),
- });
-
- const result = await userService.updateUserSessions(
- user,
- sessionData,
- 'REST',
- );
-
- expect(result).toEqualRight({
- ...user,
- currentGQLSession: null,
- currentRESTSession: sessionData,
- });
- });
- test('Should reject left and update user for invalid GQL session', async () => {
- const sessionData = 'invalid json';
-
- const result = await userService.updateUserSessions(
- user,
- sessionData,
- 'GQL',
- );
-
- expect(result).toEqualLeft(JSON_INVALID);
- });
- test('Should reject left and update user for invalid REST session', async () => {
- const sessionData = 'invalid json';
-
- const result = await userService.updateUserSessions(
- user,
- sessionData,
- 'REST',
- );
-
- expect(result).toEqualLeft(JSON_INVALID);
- });
-
- test('Should publish pubsub message on user update sessions', async () => {
- mockPrisma.user.update.mockResolvedValue({
- ...user,
- currentGQLSession: JSON.parse(user.currentGQLSession),
- currentRESTSession: JSON.parse(user.currentRESTSession),
- });
-
- await userService.updateUserSessions(user, user.currentGQLSession, 'GQL');
-
- expect(mockPubSub.publish).toHaveBeenCalledTimes(1);
- expect(mockPubSub.publish).toHaveBeenCalledWith(
- `user/${user.uid}/updated`,
- user,
- );
+describe('findUserByEmail', () => {
+ test('should successfully return a valid user given a valid email', async () => {
+ mockPrisma.user.findUniqueOrThrow.mockResolvedValueOnce(user);
+
+ const result = await userService.findUserByEmail(
+ );
+ expect(result).toEqualSome(user);
+ });
+
+ test('should return a null user given a invalid email', async () => {
+ mockPrisma.user.findUniqueOrThrow.mockRejectedValueOnce('NotFoundError');
+
+ const result = await userService.findUserByEmail('[email protected]');
+ expect(result).resolves.toBeNone;
+ });
+});
+
+describe('findUserById', () => {
+ test('should successfully return a valid user given a valid user uid', async () => {
+ mockPrisma.user.findUniqueOrThrow.mockResolvedValueOnce(user);
+
+ const result = await userService.findUserById('123344');
+ expect(result).toEqualSome(user);
+ });
+
+ test('should return a null user given a invalid user uid', async () => {
+ mockPrisma.user.findUniqueOrThrow.mockRejectedValueOnce('NotFoundError');
+
+ const result = await userService.findUserById('sdcvbdbr');
+ expect(result).resolves.toBeNone;
+ });
+});
+
+describe('createUserMagic', () => {
+ test('should successfully create user and account for magic-link given valid inputs', async () => {
+ mockPrisma.user.create.mockResolvedValueOnce(user);
+
+ const result = await userService.createUserMagic(
+ );
+ expect(result).toEqual(user);
+ });
+});
+
+describe('createUserSSO', () => {
+ test('should successfully create user and account for SSO provider given valid inputs ', async () => {
+ mockPrisma.user.create.mockResolvedValueOnce(user);
+
+ const result = await userService.createUserSSO(
+ 'sdcsdcsdc',
+ 'dscsdc',
+ exampleSSOProfileData,
+ );
+ expect(result).toEqual(user);
+ });
+
+ test('should successfully create user and account for SSO provider given no displayName ', async () => {
+ mockPrisma.user.create.mockResolvedValueOnce({
+ ...user,
+ displayName: null,
+ });
+
+ const result = await userService.createUserSSO('sdcsdcsdc', 'dscsdc', {
+ ...exampleSSOProfileData,
+ displayName: null,
+ });
+
+ expect(result).toEqual({
+ ...user,
+ displayName: null,
+ });
+ });
+
+ test('should successfully create user and account for SSO provider given no photoURL ', async () => {
+ mockPrisma.user.create.mockResolvedValueOnce({
+ ...user,
+ photoURL: null,
+ });
+
+ const result = await userService.createUserSSO('sdcsdcsdc', 'dscsdc', {
+ ...exampleSSOProfileData,
+ photoURL: null,
+ });
+
+ expect(result).toEqual({
+ ...user,
+ photoURL: null,
+ });
+ });
+});
+
+describe('createProviderAccount', () => {
+ test('should successfully create ProviderAccount for user given valid inputs ', async () => {
+ mockPrisma.account.create.mockResolvedValueOnce({
+ id: '123dcdc',
+ userId: user.uid,
+ provider: exampleSSOProfileData.provider,
+ providerAccountId: exampleSSOProfileData.id,
+ providerRefreshToken: 'dscsdc',
+ providerAccessToken: 'sdcsdcsdc',
+ providerScope: 'user.email',
+ loggedIn: currentTime,
+ });
+
+ const result = await userService.createProviderAccount(
+ user,
+ 'sdcsdcsdc',
+ 'dscsdc',
+ exampleSSOProfileData,
+ );
+ expect(result).toEqual({
+ id: '123dcdc',
+ userId: user.uid,
+ provider: exampleSSOProfileData.provider,
+ providerAccountId: exampleSSOProfileData.id,
+ providerRefreshToken: 'dscsdc',
+ providerAccessToken: 'sdcsdcsdc',
+ providerScope: 'user.email',
+ loggedIn: currentTime,
+ });
+ });
+
+ test('should successfully create ProviderAccount for user given no accessToken ', async () => {
+ mockPrisma.account.create.mockResolvedValueOnce({
+ id: '123dcdc',
+ userId: user.uid,
+ provider: exampleSSOProfileData.provider,
+ providerAccountId: exampleSSOProfileData.id,
+ providerRefreshToken: 'dscsdc',
+ providerAccessToken: null,
+ providerScope: 'user.email',
+ loggedIn: currentTime,
+ });
+
+ const result = await userService.createProviderAccount(
+ user,
+ 'sdcsdcsdc',
+ 'dscsdc',
+ exampleSSOProfileData,
+ );
+ expect(result).toEqual({
+ id: '123dcdc',
+ userId: user.uid,
+ provider: exampleSSOProfileData.provider,
+ providerAccountId: exampleSSOProfileData.id,
+ providerRefreshToken: 'dscsdc',
+ providerAccessToken: null,
+ providerScope: 'user.email',
+ loggedIn: currentTime,
+ });
+ });
+
+ test('should successfully create ProviderAccount for user given no refreshToken', async () => {
+ mockPrisma.account.create.mockResolvedValueOnce({
+ id: '123dcdc',
+ userId: user.uid,
+ provider: exampleSSOProfileData.provider,
+ providerAccountId: exampleSSOProfileData.id,
+ providerRefreshToken: null,
+ providerAccessToken: 'sdcsdcsdc',
+ providerScope: 'user.email',
+ loggedIn: currentTime,
+ });
+
+ const result = await userService.createProviderAccount(
+ user,
+ 'sdcsdcsdc',
+ 'dscsdc',
+ exampleSSOProfileData,
+ );
+ expect(result).toEqual({
+ id: '123dcdc',
+ userId: user.uid,
+ provider: exampleSSOProfileData.provider,
+ providerAccountId: exampleSSOProfileData.id,
+ providerRefreshToken: null,
+ providerAccessToken: 'sdcsdcsdc',
+ providerScope: 'user.email',
+ loggedIn: currentTime,
+ });
+ });
+});
++
++describe('updateUserSessions', () => {
++ test('Should resolve right and update users GQL session', async () => {
++ const sessionData = user.currentGQLSession;
++ mockPrisma.user.update.mockResolvedValue({
++ ...user,
++ currentGQLSession: JSON.parse(sessionData),
++ currentRESTSession: null,
+ });
++
++ const result = await userService.updateUserSessions(
++ user,
++ sessionData,
++ 'GQL',
++ );
++
++ expect(result).toEqualRight({
++ ...user,
++ currentGQLSession: sessionData,
++ currentRESTSession: null,
++ });
++ });
++ test('Should resolve right and update users REST session', async () => {
++ const sessionData = user.currentGQLSession;
++ mockPrisma.user.update.mockResolvedValue({
++ ...user,
++ currentGQLSession: null,
++ currentRESTSession: JSON.parse(sessionData),
++ });
++
++ const result = await userService.updateUserSessions(
++ user,
++ sessionData,
++ 'REST',
++ );
++
++ expect(result).toEqualRight({
++ ...user,
++ currentGQLSession: null,
++ currentRESTSession: sessionData,
++ });
++ });
++ test('Should reject left and update user for invalid GQL session', async () => {
++ const sessionData = 'invalid json';
++
++ const result = await userService.updateUserSessions(
++ user,
++ sessionData,
++ 'GQL',
++ );
++
++ expect(result).toEqualLeft(JSON_INVALID);
++ });
++ test('Should reject left and update user for invalid REST session', async () => {
++ const sessionData = 'invalid json';
++
++ const result = await userService.updateUserSessions(
++ user,
++ sessionData,
++ 'REST',
++ );
++
++ expect(result).toEqualLeft(JSON_INVALID);
++ });
++
++ test('Should publish pubsub message on user update sessions', async () => {
++ mockPrisma.user.update.mockResolvedValue({
++ ...user,
++ currentGQLSession: JSON.parse(user.currentGQLSession),
++ currentRESTSession: JSON.parse(user.currentRESTSession),
++ });
++
++ await userService.updateUserSessions(user, user.currentGQLSession, 'GQL');
++
++ expect(mockPubSub.publish).toHaveBeenCalledTimes(1);
++ expect(mockPubSub.publish).toHaveBeenCalledWith(
++ `user/${user.uid}/updated`,
++ user,
++ );
+ });
+ });
diff --cc packages/hoppscotch-backend/src/user/user.service.ts
index ec011423e,9b0d6be1c..81535cd1a
--- a/packages/hoppscotch-backend/src/user/user.service.ts
+++ b/packages/hoppscotch-backend/src/user/user.service.ts
@@@ -1,155 -1,79 +1,226 @@@
import { Injectable } from '@nestjs/common';
-import { PrismaService } from '../prisma/prisma.service';
+import { PrismaService } from 'src/prisma/prisma.service';
+import * as O from 'fp-ts/Option';
+import * as E from 'fp-ts/Either';
+import { AuthUser } from 'src/types/AuthUser';
+import { USER_NOT_FOUND } from 'src/errors';
+ import { SessionType, User } from './user.model';
-import * as E from 'fp-ts/lib/Either';
+ import { USER_UPDATE_FAILED } from 'src/errors';
+ import { PubSubService } from 'src/pubsub/pubsub.service';
+ import { stringToJson } from 'src/utils';
@Injectable()
export class UserService {
- constructor(private prisma: PrismaService) {}
+ constructor(
- private readonly prisma: PrismaService,
++ private prisma: PrismaService,
+ private readonly pubsub: PubSubService,
+ ) {}
+ /**
+ * Find User with given email id
+ *
+ * @param {string} email User's email
+ * @returns {Promise<O.None | O.Some<User>>} Option of found User
+ */
+ async findUserByEmail(email: string) {
+ try {
+ const user = await this.prisma.user.findUniqueOrThrow({
+ where: {
+ email: email,
+ },
+ });
+ return O.some(user);
+ } catch (error) {
+ return O.none;
+ }
+ }
+
+ /**
+ * Find User with given ID
+ *
+ * @param {string} userUid User ID
+ * @returns {Promise<O.None | O.Some<User>>} Option of found User
+ */
+ async findUserById(userUid: string) {
+ try {
+ const user = await this.prisma.user.findUniqueOrThrow({
+ where: {
+ uid: userUid,
+ },
+ });
+ return O.some(user);
+ } catch (error) {
+ return O.none;
+ }
+ }
+
+ /**
+ * Create a new User when logged in via a Magic Link
+ *
+ * @param {string} email User's Email
+ * @returns {Promise<User>} Created User
+ */
+ async createUserMagic(email: string) {
+ const createdUser = await this.prisma.user.create({
+ data: {
+ email: email,
+ accounts: {
+ create: {
+ provider: 'magic',
+ providerAccountId: email,
+ },
+ },
+ },
+ });
+
+ return createdUser;
+ }
+
+ /**
+ * Create a new User when logged in via a SSO provider
+ *
+ * @param {string} accessToken User's access token generated by providers
+ * @param {string} refreshToken User's refresh token generated by providers
+ * @param {any} profile Data received from SSO provider on the users account
+ * @returns {Promise<User>} Created User
+ */
+ async createUserSSO(accessToken: string, refreshToken: string, profile) {
+ const createdUser = await this.prisma.user.create({
+ data: {
+ displayName: !profile.displayName ? null : profile.displayName,
+ email: profile.emails[0].value,
+ photoURL: !profile.photos ? null : profile.photos[0].value,
+ accounts: {
+ create: {
+ provider: profile.provider,
+ providerAccountId: profile.id,
+ providerRefreshToken: refreshToken,
+ providerAccessToken: accessToken,
+ },
+ },
+ },
+ });
+
+ return createdUser;
+ }
+
+ /**
+ * Create a new Account for a given User
+ *
+ * @param {AuthUser} user User object
+ * @param {string} accessToken User's access token generated by providers
+ * @param {string} refreshToken User's refresh token generated by providers
+ * @param {any} profile Data received from SSO provider on the users account
+ * @returns {Promise<Account>} Created Account
+ */
+ async createProviderAccount(
+ user: AuthUser,
+ accessToken: string,
+ refreshToken: string,
+ profile,
+ ) {
+ const createdProvider = await this.prisma.account.create({
+ data: {
+ provider: profile.provider,
+ providerAccountId: profile.id,
+ providerRefreshToken: refreshToken ? refreshToken : null,
+ providerAccessToken: accessToken ? accessToken : null,
+ user: {
+ connect: {
+ uid: user.uid,
+ },
+ },
+ },
+ });
+
+ return createdProvider;
+ }
+
+ /**
+ * Update User displayName and photoURL
+ *
+ * @param {AuthUser} user User object
+ * @param {any} profile Data received from SSO provider on the users account
+ * @returns {Promise<E.Right<User> | E.Left<"user/not_found">>} Updated user object
+ */
+ async updateUserDetails(user: AuthUser, profile) {
+ try {
+ const updatedUser = await this.prisma.user.update({
+ where: {
+ uid: user.uid,
+ },
+ data: {
+ displayName: !profile.displayName ? null : profile.displayName,
+ photoURL: !profile.photos ? null : profile.photos[0].value,
+ },
+ });
+ return E.right(updatedUser);
+ } catch (error) {
+ return E.left(USER_NOT_FOUND);
+ }
+ }
++
+ /**
+ * Update a user's sessions
+ * @param user User object
+ * @param currentRESTSession user's current REST session
+ * @param currentGQLSession user's current GQL session
+ * @returns a Either of User or error
+ */
+ async updateUserSessions(
+ user: User,
+ currentSession: string,
+ sessionType: string,
+ ): Promise<E.Right<User> | E.Left<string>> {
+ const validatedSession = await this.validateSession(currentSession);
+ if (E.isLeft(validatedSession)) return E.left(validatedSession.left);
+
+ try {
+ const sessionObj = {};
+ switch (sessionType) {
+ case SessionType.GQL:
+ sessionObj['currentGQLSession'] = validatedSession.right;
+ break;
+ case SessionType.REST:
+ sessionObj['currentRESTSession'] = validatedSession.right;
+ break;
+ default:
+ return E.left(USER_UPDATE_FAILED);
+ }
+
+ const dbUpdatedUser = await this.prisma.user.update({
+ where: { uid: user.uid },
+ data: sessionObj,
+ });
+
+ const updatedUser: User = {
+ ...dbUpdatedUser,
+ currentGQLSession: dbUpdatedUser.currentGQLSession
+ ? JSON.stringify(dbUpdatedUser.currentGQLSession)
+ : null,
+ currentRESTSession: dbUpdatedUser.currentRESTSession
+ ? JSON.stringify(dbUpdatedUser.currentRESTSession)
+ : null,
+ };
+
+ // Publish subscription for user updates
+ await this.pubsub.publish(`user/${updatedUser.uid}/updated`, updatedUser);
+
+ return E.right(updatedUser);
+ } catch (e) {
+ return E.left(USER_UPDATE_FAILED);
+ }
+ }
+
+ /**
+ * Validate and parse currentRESTSession and currentGQLSession
+ * @param sessionData string of the session
+ * @returns a Either of JSON object or error
+ */
+ async validateSession(sessionData: string) {
+ const jsonSession = stringToJson(sessionData);
+ if (E.isLeft(jsonSession)) return E.left(jsonSession.left);
+
+ return E.right(jsonSession.right);
+ }
}
diff --cc packages/hoppscotch-backend/src/utils.ts
index ba079ed88,570313640..99a1d047b
--- a/packages/hoppscotch-backend/src/utils.ts
+++ b/packages/hoppscotch-backend/src/utils.ts
@@@ -4,13 -4,10 +4,14 @@@ import { pipe } from 'fp-ts/lib/functio
import * as O from 'fp-ts/Option';
import * as TE from 'fp-ts/TaskEither';
import * as T from 'fp-ts/Task';
+ import * as E from 'fp-ts/Either';
import { User } from './user/user.model';
import * as A from 'fp-ts/Array';
- import * as E from 'fp-ts/Either';
+import { AuthErrorHandler } from './types/AuthErrorHandler';
+import { AuthTokens } from './types/AuthTokens';
+import { Response } from 'express';
+import { DateTime } from 'luxon';
+ import { JSON_INVALID } from './errors';
/**
* A workaround to throw an exception in an expression.
@@@ -124,53 -112,16 +125,68 @@@ export const taskEitherValidateArraySe
);
/**
+ * Checks to see if the email is valid or not
+ * @param email The email
+ * @see https://emailregex.com/ for information on email regex
+ * @returns A Boolean depending on the format of the email
+ */
+export const validateEmail = (email: string) => {
+ return new RegExp(
+ /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/,
+ ).test(email);
+};
+
+/**
+ * Sets and returns the cookies in the response object on successful authentication
+ * @param res Express Response Object
+ * @param authTokens Object containing the access and refresh tokens
+ * @param redirect if true will redirect to provided URL else just send a 200 status code
+ */
+export const authCookieHandler = (
+ res: Response,
+ authTokens: AuthTokens,
+ redirect: boolean,
+) => {
+ const currentTime = DateTime.now();
+ const accessTokenValidity = currentTime
+ .plus({
+ milliseconds: parseInt(process.env.ACCESS_TOKEN_VALIDITY),
+ })
+ .toMillis();
+ const refreshTokenValidity = currentTime
+ .plus({
+ milliseconds: parseInt(process.env.REFRESH_TOKEN_VALIDITY),
+ })
+ .toMillis();
+
+ res.cookie('access_token', authTokens.access_token, {
+ httpOnly: true,
+ secure: true,
+ sameSite: 'lax',
+ maxAge: accessTokenValidity,
+ });
+ res.cookie('refresh_token', authTokens.refresh_token, {
+ httpOnly: true,
+ secure: true,
+ sameSite: 'lax',
+ maxAge: refreshTokenValidity,
+ });
+ if (redirect) {
+ res.status(HttpStatus.OK).redirect(process.env.REDIRECT_URL);
+ } else res.status(HttpStatus.OK).send();
+};
++
++/*
+ * String to JSON parser
+ * @param {str} str The string to parse
+ * @returns {E.Right<T> | E.Left<"json_invalid">} An Either of the parsed JSON
+ */
+ export function stringToJson<T>(
+ str: string,
+ ): E.Right<T | any> | E.Left<string> {
+ try {
+ return E.right(JSON.parse(str));
+ } catch (err) {
+ return E.left(JSON_INVALID);
+ }
+ }