Migrate to a monorepo structure (#2909)

packages/twenty-server/src/core/user/dtos/workspace-member.dto.ts

@@ -0,0 +1,30 @@
+import { Field, ID, ObjectType } from '@nestjs/graphql';
+
+import { IDField } from '@ptc-org/nestjs-query-graphql';
+
+@ObjectType('UserWorkspaceMemberName')
+export class UserWorkspaceMemberName {
+  @Field({ nullable: false })
+  firstName: string;
+
+  @Field({ nullable: false })
+  lastName: string;
+}
+
+@ObjectType('UserWorkspaceMember')
+export class UserWorkspaceMember {
+  @IDField(() => ID)
+  id: string;
+
+  @Field(() => UserWorkspaceMemberName)
+  name: UserWorkspaceMemberName;
+
+  @Field({ nullable: false })
+  colorScheme: string;
+
+  @Field({ nullable: true })
+  avatarUrl: string;
+
+  @Field({ nullable: false })
+  locale: string;
+}

packages/twenty-server/src/core/user/services/user.service.spec.ts

@@ -0,0 +1,38 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { getRepositoryToken } from '@nestjs/typeorm';
+
+import { User } from 'src/core/user/user.entity';
+import { DataSourceService } from 'src/metadata/data-source/data-source.service';
+import { TypeORMService } from 'src/database/typeorm/typeorm.service';
+
+import { UserService } from './user.service';
+
+describe('UserService', () => {
+  let service: UserService;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [
+        UserService,
+        {
+          provide: getRepositoryToken(User, 'core'),
+          useValue: {},
+        },
+        {
+          provide: DataSourceService,
+          useValue: {},
+        },
+        {
+          provide: TypeORMService,
+          useValue: {},
+        },
+      ],
+    }).compile();
+
+    service = module.get<UserService>(UserService);
+  });
+
+  it('should be defined', () => {
+    expect(service).toBeDefined();
+  });
+});

packages/twenty-server/src/core/user/services/user.service.ts

@@ -0,0 +1,82 @@
+import { InjectRepository } from '@nestjs/typeorm';
+
+import { TypeOrmQueryService } from '@ptc-org/nestjs-query-typeorm';
+import { Repository } from 'typeorm';
+
+import { assert } from 'src/utils/assert';
+import { User } from 'src/core/user/user.entity';
+import { UserWorkspaceMember } from 'src/core/user/dtos/workspace-member.dto';
+import { DataSourceService } from 'src/metadata/data-source/data-source.service';
+import { TypeORMService } from 'src/database/typeorm/typeorm.service';
+
+export class UserService extends TypeOrmQueryService<User> {
+  constructor(
+    @InjectRepository(User, 'core')
+    private readonly userRepository: Repository<User>,
+    private readonly dataSourceService: DataSourceService,
+    private readonly typeORMService: TypeORMService,
+  ) {
+    super(userRepository);
+  }
+
+  async loadWorkspaceMember(user: User) {
+    const dataSourceMetadata =
+      await this.dataSourceService.getLastDataSourceMetadataFromWorkspaceIdOrFail(
+        user.defaultWorkspace.id,
+      );
+
+    const workspaceDataSource = await this.typeORMService.connectToDataSource(
+      dataSourceMetadata,
+    );
+
+    const workspaceMembers = await workspaceDataSource?.query(
+      `SELECT * FROM ${dataSourceMetadata.schema}."workspaceMember" WHERE "userId" = '${user.id}'`,
+    );
+
+    assert(workspaceMembers.length === 1, 'WorkspaceMember not found');
+
+    const userWorkspaceMember = new UserWorkspaceMember();
+
+    userWorkspaceMember.id = workspaceMembers[0].id;
+    userWorkspaceMember.colorScheme = workspaceMembers[0].colorScheme;
+    userWorkspaceMember.locale = workspaceMembers[0].locale;
+    userWorkspaceMember.avatarUrl = workspaceMembers[0].avatarUrl;
+    userWorkspaceMember.name = {
+      firstName: workspaceMembers[0].nameFirstName,
+      lastName: workspaceMembers[0].nameLastName,
+    };
+
+    return userWorkspaceMember;
+  }
+
+  async createWorkspaceMember(user: User, avatarUrl?: string) {
+    const dataSourceMetadata =
+      await this.dataSourceService.getLastDataSourceMetadataFromWorkspaceIdOrFail(
+        user.defaultWorkspace.id,
+      );
+
+    const workspaceDataSource = await this.typeORMService.connectToDataSource(
+      dataSourceMetadata,
+    );
+
+    await workspaceDataSource?.query(
+      `INSERT INTO ${dataSourceMetadata.schema}."workspaceMember"
+      ("nameFirstName", "nameLastName", "colorScheme", "userId", "avatarUrl")
+      VALUES ('${user.firstName}', '${user.lastName}', 'Light', '${
+        user.id
+      }', '${avatarUrl ?? ''}')`,
+    );
+  }
+
+  async deleteUser(userId: string): Promise<User> {
+    const user = await this.userRepository.findOneBy({
+      id: userId,
+    });
+
+    assert(user, 'User not found');
+
+    await this.userRepository.delete(user.id);
+
+    return user;
+  }
+}

packages/twenty-server/src/core/user/user.auto-resolver-opts.ts

@@ -0,0 +1,38 @@
+import {
+  AutoResolverOpts,
+  ReadResolverOpts,
+  PagingStrategies,
+} from '@ptc-org/nestjs-query-graphql';
+
+import { User } from 'src/core/user/user.entity';
+import { JwtAuthGuard } from 'src/guards/jwt.auth.guard';
+
+export const userAutoResolverOpts: AutoResolverOpts<
+  any,
+  any,
+  unknown,
+  unknown,
+  ReadResolverOpts<any>,
+  PagingStrategies
+>[] = [
+  {
+    EntityClass: User,
+    DTOClass: User,
+    enableTotalCount: true,
+    pagingStrategy: PagingStrategies.CURSOR,
+    read: {
+      many: { disabled: true },
+      one: { disabled: true },
+    },
+    create: {
+      many: { disabled: true },
+      one: { disabled: true },
+    },
+    update: {
+      many: { disabled: true },
+      one: { disabled: true },
+    },
+    delete: { many: { disabled: true }, one: { disabled: true } },
+    guards: [JwtAuthGuard],
+  },
+];

packages/twenty-server/src/core/user/user.entity.ts

@@ -0,0 +1,78 @@
+import { ID, Field, ObjectType } from '@nestjs/graphql';
+
+import {
+  Entity,
+  Column,
+  PrimaryGeneratedColumn,
+  CreateDateColumn,
+  UpdateDateColumn,
+  OneToMany,
+  ManyToOne,
+} from 'typeorm';
+import { IDField } from '@ptc-org/nestjs-query-graphql';
+
+import { RefreshToken } from 'src/core/refresh-token/refresh-token.entity';
+import { Workspace } from 'src/core/workspace/workspace.entity';
+import { UserWorkspaceMember } from 'src/core/user/dtos/workspace-member.dto';
+
+@Entity({ name: 'user', schema: 'core' })
+@ObjectType('User')
+export class User {
+  @IDField(() => ID)
+  @PrimaryGeneratedColumn('uuid')
+  id: string;
+
+  @Field()
+  @Column({ default: '' })
+  firstName: string;
+
+  @Field()
+  @Column({ default: '' })
+  lastName: string;
+
+  @Field()
+  @Column()
+  email: string;
+
+  @Field()
+  @Column({ default: false })
+  emailVerified: boolean;
+
+  @Field({ nullable: true })
+  @Column({ default: false })
+  disabled: boolean;
+
+  @Field({ nullable: true })
+  @Column({ nullable: true })
+  passwordHash: string;
+
+  @Field()
+  @Column({ default: false })
+  canImpersonate: boolean;
+
+  @Field()
+  @CreateDateColumn({ type: 'timestamp with time zone' })
+  createdAt: Date;
+
+  @Field()
+  @UpdateDateColumn({ type: 'timestamp with time zone' })
+  updatedAt: Date;
+
+  @Field({ nullable: true })
+  @Column({ nullable: true })
+  deletedAt: Date;
+
+  @Field(() => Workspace, { nullable: false })
+  @ManyToOne(() => Workspace, (workspace) => workspace.users, {
+    onDelete: 'SET NULL',
+  })
+  defaultWorkspace: Workspace;
+
+  @OneToMany(() => RefreshToken, (refreshToken) => refreshToken.user, {
+    cascade: true,
+  })
+  refreshTokens: RefreshToken[];
+
+  @Field(() => UserWorkspaceMember, { nullable: false })
+  workspaceMember: UserWorkspaceMember;
+}

packages/twenty-server/src/core/user/user.module.ts

@@ -0,0 +1,33 @@
+/* eslint-disable no-restricted-imports */
+import { Module } from '@nestjs/common';
+
+import { NestjsQueryGraphQLModule } from '@ptc-org/nestjs-query-graphql';
+import { NestjsQueryTypeOrmModule } from '@ptc-org/nestjs-query-typeorm';
+
+import { FileModule } from 'src/core/file/file.module';
+import { User } from 'src/core/user/user.entity';
+import { UserResolver } from 'src/core/user/user.resolver';
+import { TypeORMService } from 'src/database/typeorm/typeorm.service';
+import { DataSourceModule } from 'src/metadata/data-source/data-source.module';
+import { TypeORMModule } from 'src/database/typeorm/typeorm.module';
+
+import { userAutoResolverOpts } from './user.auto-resolver-opts';
+
+import { UserService } from './services/user.service';
+
+@Module({
+  imports: [
+    NestjsQueryGraphQLModule.forFeature({
+      imports: [
+        NestjsQueryTypeOrmModule.forFeature([User], 'core'),
+        TypeORMModule,
+      ],
+      resolvers: userAutoResolverOpts,
+    }),
+    DataSourceModule,
+    FileModule,
+  ],
+  exports: [UserService],
+  providers: [UserService, UserResolver, TypeORMService],
+})
+export class UserModule {}

packages/twenty-server/src/core/user/user.resolver.ts

@@ -0,0 +1,104 @@
+import {
+  Resolver,
+  Query,
+  Args,
+  Parent,
+  ResolveField,
+  Mutation,
+} from '@nestjs/graphql';
+import { UseGuards } from '@nestjs/common';
+
+import crypto from 'crypto';
+
+import { FileUpload, GraphQLUpload } from 'graphql-upload';
+
+import { SupportDriver } from 'src/integrations/environment/interfaces/support.interface';
+import { FileFolder } from 'src/core/file/interfaces/file-folder.interface';
+
+import { AuthUser } from 'src/decorators/auth-user.decorator';
+import { EnvironmentService } from 'src/integrations/environment/environment.service';
+import { streamToBuffer } from 'src/utils/stream-to-buffer';
+import { FileUploadService } from 'src/core/file/services/file-upload.service';
+import { assert } from 'src/utils/assert';
+import { JwtAuthGuard } from 'src/guards/jwt.auth.guard';
+import { User } from 'src/core/user/user.entity';
+import { UserWorkspaceMember } from 'src/core/user/dtos/workspace-member.dto';
+
+import { UserService } from './services/user.service';
+
+const getHMACKey = (email?: string, key?: string | null) => {
+  if (!email || !key) return null;
+
+  const hmac = crypto.createHmac('sha256', key);
+
+  return hmac.update(email).digest('hex');
+};
+
+@UseGuards(JwtAuthGuard)
+@Resolver(() => User)
+export class UserResolver {
+  constructor(
+    private readonly userService: UserService,
+    private readonly environmentService: EnvironmentService,
+    private readonly fileUploadService: FileUploadService,
+  ) {}
+
+  @Query(() => User)
+  async currentUser(@AuthUser() { id }: User) {
+    const user = await this.userService.findById(id, {
+      relations: [{ name: 'defaultWorkspace', query: {} }],
+    });
+
+    assert(user, 'User not found');
+
+    return user;
+  }
+
+  @ResolveField(() => UserWorkspaceMember, {
+    nullable: false,
+  })
+  async workspaceMember(@Parent() user: User): Promise<UserWorkspaceMember> {
+    return this.userService.loadWorkspaceMember(user);
+  }
+
+  @ResolveField(() => String, {
+    nullable: true,
+  })
+  supportUserHash(@Parent() parent: User): string | null {
+    if (this.environmentService.getSupportDriver() !== SupportDriver.Front) {
+      return null;
+    }
+    const key = this.environmentService.getSupportFrontHMACKey();
+
+    return getHMACKey(parent.email, key);
+  }
+
+  @Mutation(() => String)
+  async uploadProfilePicture(
+    @AuthUser() { id }: User,
+    @Args({ name: 'file', type: () => GraphQLUpload })
+    { createReadStream, filename, mimetype }: FileUpload,
+  ): Promise<string> {
+    if (!id) {
+      throw new Error('User not found');
+    }
+
+    const stream = createReadStream();
+    const buffer = await streamToBuffer(stream);
+    const fileFolder = FileFolder.ProfilePicture;
+
+    const { paths } = await this.fileUploadService.uploadImage({
+      file: buffer,
+      filename,
+      mimeType: mimetype,
+      fileFolder,
+    });
+
+    return paths[0];
+  }
+
+  @Mutation(() => User)
+  async deleteUser(@AuthUser() { id: userId }: User) {
+    return this.userService.deleteUser(userId);
+  }
+}