Migrate to a monorepo structure (#2909)

packages/twenty-server/src/core/workspace/dtos/update-workspace-input.ts

@@ -0,0 +1,31 @@
+import { Field, InputType } from '@nestjs/graphql';
+
+import { IsBoolean, IsOptional, IsString } from 'class-validator';
+
+@InputType()
+export class UpdateWorkspaceInput {
+  @Field({ nullable: true })
+  @IsString()
+  @IsOptional()
+  domainName?: string;
+
+  @Field({ nullable: true })
+  @IsString()
+  @IsOptional()
+  displayName?: string;
+
+  @Field({ nullable: true })
+  @IsString()
+  @IsOptional()
+  logo?: string;
+
+  @Field({ nullable: true })
+  @IsString()
+  @IsOptional()
+  inviteHash?: string;
+
+  @Field({ nullable: true })
+  @IsBoolean()
+  @IsOptional()
+  allowImpersonation?: boolean;
+}

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

@@ -0,0 +1,33 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { getRepositoryToken } from '@nestjs/typeorm';
+
+import { Workspace } from 'src/core/workspace/workspace.entity';
+import { WorkspaceManagerService } from 'src/workspace/workspace-manager/workspace-manager.service';
+
+import { WorkspaceService } from './workspace.service';
+
+describe('WorkspaceService', () => {
+  let service: WorkspaceService;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [
+        WorkspaceService,
+        {
+          provide: getRepositoryToken(Workspace, 'core'),
+          useValue: {},
+        },
+        {
+          provide: WorkspaceManagerService,
+          useValue: {},
+        },
+      ],
+    }).compile();
+
+    service = module.get<WorkspaceService>(WorkspaceService);
+  });
+
+  it('should be defined', () => {
+    expect(service).toBeDefined();
+  });
+});

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

@@ -0,0 +1,30 @@
+import { InjectRepository } from '@nestjs/typeorm';
+
+import assert from 'assert';
+
+import { TypeOrmQueryService } from '@ptc-org/nestjs-query-typeorm';
+import { Repository } from 'typeorm';
+
+import { WorkspaceManagerService } from 'src/workspace/workspace-manager/workspace-manager.service';
+import { Workspace } from 'src/core/workspace/workspace.entity';
+
+export class WorkspaceService extends TypeOrmQueryService<Workspace> {
+  constructor(
+    @InjectRepository(Workspace, 'core')
+    private readonly workspaceRepository: Repository<Workspace>,
+    private readonly workspaceManagerService: WorkspaceManagerService,
+  ) {
+    super(workspaceRepository);
+  }
+
+  async deleteWorkspace(id: string) {
+    const workspace = await this.workspaceRepository.findOneBy({ id });
+
+    assert(workspace, 'Workspace not found');
+
+    await this.workspaceManagerService.delete(id);
+    await this.workspaceRepository.delete(id);
+
+    return workspace;
+  }
+}

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

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

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

@@ -0,0 +1,61 @@
+import { Field, ID, ObjectType } from '@nestjs/graphql';
+
+import { IDField, UnPagedRelation } from '@ptc-org/nestjs-query-graphql';
+import {
+  Column,
+  CreateDateColumn,
+  Entity,
+  OneToMany,
+  PrimaryGeneratedColumn,
+  UpdateDateColumn,
+} from 'typeorm';
+
+import { User } from 'src/core/user/user.entity';
+import { FeatureFlagEntity } from 'src/core/feature-flag/feature-flag.entity';
+
+@Entity({ name: 'workspace', schema: 'core' })
+@ObjectType('Workspace')
+@UnPagedRelation('featureFlags', () => FeatureFlagEntity, { nullable: true })
+export class Workspace {
+  @IDField(() => ID)
+  @PrimaryGeneratedColumn('uuid')
+  id: string;
+
+  @Field({ nullable: true })
+  @Column({ nullable: true })
+  domainName?: string;
+
+  @Field({ nullable: true })
+  @Column({ nullable: true })
+  displayName?: string;
+
+  @Field({ nullable: true })
+  @Column({ nullable: true })
+  logo?: string;
+
+  @Field({ nullable: true })
+  @Column({ nullable: true })
+  inviteHash?: string;
+
+  @Field({ nullable: true })
+  @Column({ nullable: true })
+  deletedAt?: Date;
+
+  @Field()
+  @CreateDateColumn({ type: 'timestamp with time zone' })
+  createdAt: Date;
+
+  @Field()
+  @UpdateDateColumn({ type: 'timestamp with time zone' })
+  updatedAt: Date;
+
+  @OneToMany(() => User, (user) => user.defaultWorkspace)
+  users: User[];
+
+  @Field()
+  @Column({ default: true })
+  allowImpersonation: boolean;
+
+  @OneToMany(() => FeatureFlagEntity, (featureFlag) => featureFlag.workspace)
+  featureFlags: FeatureFlagEntity[];
+}

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

@@ -0,0 +1,36 @@
+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 { WorkspaceManagerModule } from 'src/workspace/workspace-manager/workspace-manager.module';
+import { WorkspaceResolver } from 'src/core/workspace/workspace.resolver';
+import { TypeORMModule } from 'src/database/typeorm/typeorm.module';
+import { FeatureFlagEntity } from 'src/core/feature-flag/feature-flag.entity';
+
+import { Workspace } from './workspace.entity';
+import { workspaceAutoResolverOpts } from './workspace.auto-resolver-opts';
+
+import { WorkspaceService } from './services/workspace.service';
+
+@Module({
+  imports: [
+    TypeORMModule,
+    NestjsQueryGraphQLModule.forFeature({
+      imports: [
+        NestjsQueryTypeOrmModule.forFeature(
+          [Workspace, FeatureFlagEntity],
+          'core',
+        ),
+        WorkspaceManagerModule,
+        FileModule,
+      ],
+      services: [WorkspaceService],
+      resolvers: workspaceAutoResolverOpts,
+    }),
+  ],
+  exports: [WorkspaceService],
+  providers: [WorkspaceResolver, WorkspaceService],
+})
+export class WorkspaceModule {}

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

@@ -0,0 +1,72 @@
+import { Resolver, Query, Args, Mutation } from '@nestjs/graphql';
+import { UseGuards } from '@nestjs/common';
+
+import { FileUpload, GraphQLUpload } from 'graphql-upload';
+
+import { FileFolder } from 'src/core/file/interfaces/file-folder.interface';
+
+import { streamToBuffer } from 'src/utils/stream-to-buffer';
+import { FileUploadService } from 'src/core/file/services/file-upload.service';
+import { AuthWorkspace } from 'src/decorators/auth-workspace.decorator';
+import { assert } from 'src/utils/assert';
+import { JwtAuthGuard } from 'src/guards/jwt.auth.guard';
+import { UpdateWorkspaceInput } from 'src/core/workspace/dtos/update-workspace-input';
+
+import { Workspace } from './workspace.entity';
+
+import { WorkspaceService } from './services/workspace.service';
+
+@UseGuards(JwtAuthGuard)
+@Resolver(() => Workspace)
+export class WorkspaceResolver {
+  constructor(
+    private readonly workspaceService: WorkspaceService,
+    private readonly fileUploadService: FileUploadService,
+  ) {}
+
+  @Query(() => Workspace)
+  async currentWorkspace(@AuthWorkspace() { id }: Workspace) {
+    const workspace = await this.workspaceService.findById(id);
+
+    assert(workspace, 'User not found');
+
+    return workspace;
+  }
+
+  @Mutation(() => Workspace)
+  async updateWorkspace(
+    @Args('data') data: UpdateWorkspaceInput,
+    @AuthWorkspace() workspace: Workspace,
+  ) {
+    return this.workspaceService.updateOne(workspace.id, data);
+  }
+
+  @Mutation(() => String)
+  async uploadWorkspaceLogo(
+    @AuthWorkspace() { id }: Workspace,
+    @Args({ name: 'file', type: () => GraphQLUpload })
+    { createReadStream, filename, mimetype }: FileUpload,
+  ): Promise<string> {
+    const stream = createReadStream();
+    const buffer = await streamToBuffer(stream);
+    const fileFolder = FileFolder.WorkspaceLogo;
+
+    const { paths } = await this.fileUploadService.uploadImage({
+      file: buffer,
+      filename,
+      mimeType: mimetype,
+      fileFolder,
+    });
+
+    await this.workspaceService.updateOne(id, {
+      logo: paths[0],
+    });
+
+    return paths[0];
+  }
+
+  @Mutation(() => Workspace)
+  async deleteCurrentWorkspace(@AuthWorkspace() { id }: Workspace) {
+    return this.workspaceService.deleteWorkspace(id);
+  }
+}