Migrate to a monorepo structure (#2909)

packages/twenty-server/src/database/commands/data-seed-demo-workspace.command.ts

@@ -0,0 +1,54 @@
+import { Command, CommandRunner } from 'nest-commander';
+import { DataSource } from 'typeorm';
+
+import {
+  deleteCoreSchema,
+  seedCoreSchema,
+} from 'src/database/typeorm-seeds/core/demo';
+import { EnvironmentService } from 'src/integrations/environment/environment.service';
+import { WorkspaceManagerService } from 'src/workspace/workspace-manager/workspace-manager.service';
+
+@Command({
+  name: 'workspace:seed:demo',
+  description:
+    'Seed workspace with demo data. This command is intended for development only.',
+})
+export class DataSeedDemoWorkspaceCommand extends CommandRunner {
+  constructor(
+    private readonly environmentService: EnvironmentService,
+    private readonly workspaceManagerService: WorkspaceManagerService,
+  ) {
+    super();
+  }
+
+  async run(): Promise<void> {
+    try {
+      const dataSource = new DataSource({
+        url: this.environmentService.getPGDatabaseUrl(),
+        type: 'postgres',
+        logging: true,
+        schema: 'public',
+      });
+
+      await dataSource.initialize();
+      const demoWorkspaceIds = this.environmentService.getDemoWorkspaceIds();
+
+      if (demoWorkspaceIds.length === 0) {
+        throw new Error(
+          'Could not get DEMO_WORKSPACE_IDS. Please specify in .env',
+        );
+      }
+      for (const workspaceId of demoWorkspaceIds) {
+        await deleteCoreSchema(dataSource, workspaceId);
+        await this.workspaceManagerService.delete(workspaceId);
+
+        await seedCoreSchema(dataSource, workspaceId);
+        await this.workspaceManagerService.initDemo(workspaceId);
+      }
+    } catch (error) {
+      console.error(error);
+
+      return;
+    }
+  }
+}

packages/twenty-server/src/database/commands/data-seed-dev-workspace.command.ts

@@ -0,0 +1,116 @@
+import { Command, CommandRunner } from 'nest-commander';
+import { DataSource } from 'typeorm';
+
+import { DataSourceService } from 'src/metadata/data-source/data-source.service';
+import { seedCompanies } from 'src/database/typeorm-seeds/workspace/companies';
+import { seedViews } from 'src/database/typeorm-seeds/workspace/views';
+import { TypeORMService } from 'src/database/typeorm/typeorm.service';
+import { seedOpportunity } from 'src/database/typeorm-seeds/workspace/opportunity';
+import { seedPipelineStep } from 'src/database/typeorm-seeds/workspace/pipeline-step';
+import { seedWorkspaceMember } from 'src/database/typeorm-seeds/workspace/workspaceMember';
+import { seedPeople } from 'src/database/typeorm-seeds/workspace/people';
+import { seedCoreSchema } from 'src/database/typeorm-seeds/core';
+import { EnvironmentService } from 'src/integrations/environment/environment.service';
+import { WorkspaceSyncMetadataService } from 'src/workspace/workspace-sync-metadata/workspace-sync.metadata.service';
+import { WorkspaceDataSourceService } from 'src/workspace/workspace-datasource/workspace-datasource.service';
+import { ObjectMetadataService } from 'src/metadata/object-metadata/object-metadata.service';
+
+// TODO: implement dry-run
+@Command({
+  name: 'workspace:seed:dev',
+  description:
+    'Seed workspace with initial data. This command is intended for development only.',
+})
+export class DataSeedWorkspaceCommand extends CommandRunner {
+  workspaceId = '20202020-1c25-4d02-bf25-6aeccf7ea419';
+
+  constructor(
+    private readonly environmentService: EnvironmentService,
+    private readonly dataSourceService: DataSourceService,
+    private readonly typeORMService: TypeORMService,
+    private readonly workspaceSyncMetadataService: WorkspaceSyncMetadataService,
+    private readonly workspaceDataSourceService: WorkspaceDataSourceService,
+    private readonly objectMetadataService: ObjectMetadataService,
+  ) {
+    super();
+  }
+
+  async run(): Promise<void> {
+    try {
+      const dataSource = new DataSource({
+        url: this.environmentService.getPGDatabaseUrl(),
+        type: 'postgres',
+        logging: true,
+        schema: 'core',
+      });
+
+      await dataSource.initialize();
+
+      await seedCoreSchema(dataSource, this.workspaceId);
+
+      await dataSource.destroy();
+
+      const schemaName = await this.workspaceDataSourceService.createWorkspaceDBSchema(
+        this.workspaceId,
+      );
+
+    const dataSourceMetadata =
+      await this.dataSourceService.createDataSourceMetadata(
+        this.workspaceId,
+        schemaName,
+      );
+
+      await this.workspaceSyncMetadataService.syncStandardObjectsAndFieldsMetadata(
+        dataSourceMetadata.id,
+        this.workspaceId,
+      );
+
+    } catch (error) {
+      console.error(error);
+
+      return;
+    }
+
+    const dataSourceMetadata =
+      await this.dataSourceService.getLastDataSourceMetadataFromWorkspaceIdOrFail(
+        this.workspaceId,
+      );
+
+    const workspaceDataSource = await this.typeORMService.connectToDataSource(
+      dataSourceMetadata,
+    );
+
+    if (!workspaceDataSource) {
+      throw new Error('Could not connect to workspace data source');
+    }
+
+    try {
+      const objectMetadata = await this.objectMetadataService.findManyWithinWorkspace(this.workspaceId);
+      const objectMetadataMap = objectMetadata.reduce((acc, object) => {
+        acc[object.nameSingular] = {
+          id: object.id,
+          fields: object.fields.reduce((acc, field) => {
+            acc[field.name] = field.id;
+    
+            return acc;
+          }, {}),
+        };
+    
+        return acc;
+      }, {});
+
+
+      await seedCompanies(workspaceDataSource, dataSourceMetadata.schema);
+      await seedPeople(workspaceDataSource, dataSourceMetadata.schema);
+      await seedPipelineStep(workspaceDataSource, dataSourceMetadata.schema);
+      await seedOpportunity(workspaceDataSource, dataSourceMetadata.schema);
+
+      await seedViews(workspaceDataSource, dataSourceMetadata.schema, objectMetadataMap);
+      await seedWorkspaceMember(workspaceDataSource, dataSourceMetadata.schema);
+    } catch (error) {
+      console.error(error);
+    }
+
+    await this.typeORMService.disconnectFromDataSource(dataSourceMetadata.id);
+  }
+}

packages/twenty-server/src/database/commands/database-command.module.ts

@@ -0,0 +1,32 @@
+import { Module } from '@nestjs/common';
+
+import { ConfirmationQuestion } from 'src/database/commands/questions/confirmation.question';
+import { WorkspaceManagerModule } from 'src/workspace/workspace-manager/workspace-manager.module';
+import { DataSourceModule } from 'src/metadata/data-source/data-source.module';
+import { WorkspaceMigrationModule } from 'src/metadata/workspace-migration/workspace-migration.module';
+import { WorkspaceMigrationRunnerModule } from 'src/workspace/workspace-migration-runner/workspace-migration-runner.module';
+import { TypeORMModule } from 'src/database/typeorm/typeorm.module';
+import { WorkspaceModule } from 'src/core/workspace/workspace.module';
+import { DataSeedWorkspaceCommand } from 'src/database/commands/data-seed-dev-workspace.command';
+import { DataSeedDemoWorkspaceCommand } from 'src/database/commands/data-seed-demo-workspace.command';
+import { WorkspaceDataSourceModule } from 'src/workspace/workspace-datasource/workspace-datasource.module';
+import { WorkspaceSyncMetadataModule } from 'src/workspace/workspace-sync-metadata/worksapce-sync-metadata.module';
+import { ObjectMetadataModule } from 'src/metadata/object-metadata/object-metadata.module';
+
+@Module({
+  imports: [
+    WorkspaceManagerModule,
+    DataSourceModule,
+    TypeORMModule,
+    WorkspaceModule,
+    WorkspaceDataSourceModule,
+    WorkspaceSyncMetadataModule,
+    ObjectMetadataModule,
+  ],
+  providers: [
+    DataSeedWorkspaceCommand,
+    DataSeedDemoWorkspaceCommand,
+    ConfirmationQuestion,
+  ],
+})
+export class DatabaseCommandModule {}

packages/twenty-server/src/database/commands/questions/confirmation.question.ts

@@ -0,0 +1,16 @@
+import { Question, QuestionSet } from 'nest-commander';
+
+@QuestionSet({
+  name: 'confirm',
+})
+export class ConfirmationQuestion {
+  @Question({
+    type: 'confirm',
+    name: 'confirmation',
+    message:
+      "You are about to delete data from database. Are you sure to continue? Consider the '--dry-run' option first",
+  })
+  parseConfirm(val: string): boolean {
+    return Boolean(val);
+  }
+}