Extract user creation code into create-user module (#1602)

Part of OPS-3003.

Author: MarceloRGonc

packages/server/api/src/app/authentication/authentication-service/hooks/authentication-service-hooks.ts

@@ -1,4 +1,4 @@
-import { Project, ProjectMemberRole, User } from '@openops/shared';
+import { User } from '@openops/shared';
 
 export enum Provider {
   EMAIL = 'EMAIL',
@@ -8,16 +8,14 @@ export enum Provider {
 export type AuthenticationServiceHooks = {
   preSignIn(p: PreParams): Promise<void>;
   preSignUp(p: PreSignUpParams): Promise<void>;
-  postSignUp(p: PostParams): Promise<PostResult>;
-  postSignIn(p: PostParams): Promise<PostResult>;
+  postSignUp(p: PostParams): Promise<void>;
+  postSignIn(p: PostParams): Promise<void>;
 };
 
 type PreSignUpParams = {
   name: string;
   email: string;
   password: string;
-  organizationId: string | null;
-  provider: Provider;
 };
 
 type PreParams = {
@@ -28,15 +26,4 @@ type PreParams = {
 
 type PostParams = {
   user: User;
-  tablesAccessToken: string;
-  tablesRefreshToken: string;
-  referringUserId?: string;
-};
-
-type PostResult = {
-  user: User;
-  project: Project;
-  token: string;
-  tablesRefreshToken: string;
-  projectRole: ProjectMemberRole | null;
 };

packages/server/api/src/app/authentication/authentication-service/hooks/community-authentication-hooks.ts

@@ -37,7 +37,7 @@ export const communityAuthenticationServiceHooks: AuthenticationServiceHooks = {
       });
     }
   },
-  async postSignUp({ user, tablesRefreshToken }) {
+  async postSignUp({ user }) {
     let organization = await organizationService.getOldestOrganization();
 
     const adminUser = await userService.getUserByEmailOrFail({
@@ -66,16 +66,14 @@ export const communityAuthenticationServiceHooks: AuthenticationServiceHooks = {
       email: user.email,
       workspaceId: organization.tablesWorkspaceId,
     });
-
-    return getProjectAndToken(user, tablesRefreshToken);
   },
 
-  async postSignIn({ user, tablesRefreshToken }) {
-    return getProjectAndToken(user, tablesRefreshToken);
+  async postSignIn() {
+    // Empty
   },
 };
 
-async function getProjectAndToken(
+export async function getProjectAndToken(
   user: User,
   tablesRefreshToken: string,
 ): Promise<{

packages/server/api/src/app/authentication/authentication-service/index.ts

@@ -1,52 +1,32 @@
 import { authenticateUserInOpenOpsTables } from '@openops/common';
-import { logger, SharedSystemProp, system } from '@openops/server-shared';
 import {
   ApplicationError,
   AuthenticationResponse,
-  EnvironmentType,
   ErrorCode,
   isNil,
-  OrganizationRole,
   User,
   UserId,
   UserStatus,
 } from '@openops/shared';
-import { QueryFailedError } from 'typeorm';
-import { flagService } from '../../flags/flag.service';
-import { openopsTables } from '../../openops-tables';
 import { userService } from '../../user/user-service';
 import { passwordHasher } from '../basic/password-hasher';
+import { createUser } from '../new-user/create-user';
 import { authenticationServiceHooks as hooks } from './hooks';
 import { Provider } from './hooks/authentication-service-hooks';
+import { getProjectAndToken } from './hooks/community-authentication-hooks';
 
 export const authenticationService = {
   async signUp(params: SignUpParams): Promise<AuthenticationResponse> {
-    const name = `${params.firstName} ${params.lastName}`.trim();
-    await hooks.get().preSignUp({
-      ...params,
-      name,
-    });
-
-    const { token, refresh_token } = await openopsTables.createUser({
-      name,
-      email: params.email,
-      password: params.password,
-      authenticate: true,
-    });
+    const { user, tablesRefreshToken } = await createUser(params);
 
-    const user = await createUser(params);
-
-    return this.signUpResponse({
+    await hooks.get().postSignUp({
       user,
-      tablesAccessToken: token,
-      tablesRefreshToken: refresh_token,
-      referringUserId: params.referringUserId,
     });
+
+    return this.authResponse(user, tablesRefreshToken);
   },
 
   async signIn(request: SignInParams): Promise<AuthenticationResponse> {
-    await hooks.get().preSignIn(request);
-
     const user = await userService.getByOrganizationAndEmail({
       organizationId: request.organizationId,
       email: request.email,
@@ -59,98 +39,30 @@ export const authenticationService = {
       userPassword: user.password,
     });
 
-    const { token, refresh_token } = await authenticateUserInOpenOpsTables(
+    const { refresh_token } = await authenticateUserInOpenOpsTables(
       request.email,
       request.password,
     );
 
-    return this.signInResponse({
-      user,
-      tablesAccessToken: token,
-      tablesRefreshToken: refresh_token,
-    });
+    return this.authResponse(user, refresh_token);
   },
 
-  async signUpResponse({
-    user,
-    tablesAccessToken,
-    tablesRefreshToken,
-    referringUserId,
-  }: SignUpResponseParams): Promise<AuthenticationResponse> {
-    const authnResponse = await hooks.get().postSignUp({
-      user,
-      tablesAccessToken,
-      tablesRefreshToken,
-      referringUserId,
-    });
-
-    const userWithoutPassword = removePasswordPropFromUser(authnResponse.user);
+  async authResponse(
+    user: User,
+    tablesRefreshToken: string,
+  ): Promise<AuthenticationResponse> {
+    const projectContext = await getProjectAndToken(user, tablesRefreshToken);
 
-    await saveNewsLetterSubscriber(user);
+    const userWithoutPassword = removePasswordPropFromUser(projectContext.user);
 
     return {
       ...userWithoutPassword,
-      token: authnResponse.token,
-      projectId: authnResponse.project.id,
-      projectRole: authnResponse.projectRole,
-      tablesRefreshToken: authnResponse.tablesRefreshToken,
+      token: projectContext.token,
+      projectId: projectContext.project.id,
+      projectRole: projectContext.projectRole,
+      tablesRefreshToken: projectContext.tablesRefreshToken,
     };
   },
-
-  async signInResponse({
-    user,
-    tablesAccessToken,
-    tablesRefreshToken,
-  }: SignInResponseParams): Promise<AuthenticationResponse> {
-    const authnResponse = await hooks.get().postSignIn({
-      user,
-      tablesAccessToken,
-      tablesRefreshToken,
-    });
-
-    const userWithoutPassword = removePasswordPropFromUser(authnResponse.user);
-
-    return {
-      ...userWithoutPassword,
-      token: authnResponse.token,
-      projectId: authnResponse.project.id,
-      projectRole: authnResponse.projectRole,
-      tablesRefreshToken: authnResponse.tablesRefreshToken,
-    };
-  },
-};
-
-const createUser = async (params: SignUpParams): Promise<User> => {
-  try {
-    const newUser: NewUser = {
-      email: params.email,
-      organizationRole: OrganizationRole.MEMBER,
-      verified: params.verified,
-      status: UserStatus.ACTIVE,
-      firstName: params.firstName,
-      lastName: params.lastName,
-      trackEvents: params.trackEvents,
-      newsLetter: params.newsLetter,
-      password: params.password,
-      organizationId: params.organizationId,
-    };
-
-    const user = await userService.create(newUser);
-
-    return user;
-  } catch (e: unknown) {
-    if (e instanceof QueryFailedError) {
-      throw new ApplicationError({
-        code: ErrorCode.EXISTING_USER,
-        params: {
-          email: params.email,
-          organizationId: params.organizationId,
-        },
-      });
-    }
-
-    throw e;
-  }
 };
 
 const assertUserIsAllowedToSignIn: (
@@ -202,34 +114,6 @@ const removePasswordPropFromUser = (user: User): Omit<User, 'password'> => {
   return filteredUser;
 };
 
-async function saveNewsLetterSubscriber(user: User): Promise<void> {
-  const isOrganizationUserOrNotSubscribed =
-    (!isNil(user.organizationId) &&
-      !flagService.isCloudOrganization(user.organizationId)) ||
-    !user.newsLetter;
-  const environment = system.get(SharedSystemProp.ENVIRONMENT);
-  if (
-    isOrganizationUserOrNotSubscribed ||
-    environment !== EnvironmentType.PRODUCTION
-  ) {
-    return;
-  }
-  try {
-    const response = await fetch('/addContact', {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-      },
-      body: JSON.stringify({ email: user.email }),
-    });
-    return await response.json();
-  } catch (error) {
-    logger.warn(error);
-  }
-}
-
-type NewUser = Omit<User, 'id' | 'created' | 'updated'>;
-
 type SignUpParams = {
   email: string;
   password: string;
@@ -239,7 +123,6 @@ type SignUpParams = {
   newsLetter: boolean;
   verified: boolean;
   organizationId: string | null;
-  referringUserId?: string;
   provider: Provider;
 };