Seed workflow views and favorites in upgrade to 0.41 (#9785)

- Sync metadata to create workflow entities, since those are not behind
a flag anymore
- Seed workflow views
- Seed workspace favorite for workflow
- Put all steps in upgrade command

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

@@ -8,6 +8,7 @@ import { DataSeedDemoWorkspaceModule } from 'src/database/commands/data-seed-dem
 import { DataSeedWorkspaceCommand } from 'src/database/commands/data-seed-dev-workspace.command';
 import { ConfirmationQuestion } from 'src/database/commands/questions/confirmation.question';
 import { UpgradeTo0_40CommandModule } from 'src/database/commands/upgrade-version/0-40/0-40-upgrade-version.module';
+import { UpgradeTo0_41CommandModule } from 'src/database/commands/upgrade-version/0-41/0-41-upgrade-version.module';
 import { TypeORMModule } from 'src/database/typeorm/typeorm.module';
 import { BillingSubscription } from 'src/engine/core-modules/billing/entities/billing-subscription.entity';
 import { FeatureFlagEntity } from 'src/engine/core-modules/feature-flag/feature-flag.entity';
@@ -49,6 +50,7 @@ import { WorkspaceSyncMetadataModule } from 'src/engine/workspace-manager/worksp
     WorkspaceCacheStorageModule,
     WorkspaceMetadataVersionModule,
     UpgradeTo0_40CommandModule,
+    UpgradeTo0_41CommandModule,
     FeatureFlagModule,
   ],
   providers: [

packages/twenty-server/src/database/commands/upgrade-version/0-41/0-41-seed-workflow-views.command.ts

@@ -0,0 +1,203 @@
+import { Logger } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+
+import { Command } from 'nest-commander';
+import { EntityManager, IsNull, Not, Repository } from 'typeorm';
+
+import {
+  ActiveWorkspacesCommandOptions,
+  ActiveWorkspacesCommandRunner,
+} from 'src/database/commands/active-workspaces.command';
+import { TypeORMService } from 'src/database/typeorm/typeorm.service';
+import { Workspace } from 'src/engine/core-modules/workspace/workspace.entity';
+import { DataSourceService } from 'src/engine/metadata-modules/data-source/data-source.service';
+import { ObjectMetadataService } from 'src/engine/metadata-modules/object-metadata/object-metadata.service';
+import { TwentyORMGlobalManager } from 'src/engine/twenty-orm/twenty-orm-global.manager';
+import { createWorkspaceViews } from 'src/engine/workspace-manager/standard-objects-prefill-data/create-workspace-views';
+import { workflowRunsAllView } from 'src/engine/workspace-manager/standard-objects-prefill-data/views/workflow-runs-all.view';
+import { workflowVersionsAllView } from 'src/engine/workspace-manager/standard-objects-prefill-data/views/workflow-versions-all.view';
+import { workflowsAllView } from 'src/engine/workspace-manager/standard-objects-prefill-data/views/workflows-all.view';
+import { STANDARD_OBJECT_IDS } from 'src/engine/workspace-manager/workspace-sync-metadata/constants/standard-object-ids';
+
+@Command({
+  name: 'upgrade-0.41:workflow-seed-views',
+  description: 'Seed workflow views for workspace.',
+})
+export class SeedWorkflowViewsCommand extends ActiveWorkspacesCommandRunner {
+  protected readonly logger: Logger;
+
+  constructor(
+    @InjectRepository(Workspace, 'core')
+    protected readonly workspaceRepository: Repository<Workspace>,
+    private readonly twentyORMGlobalManager: TwentyORMGlobalManager,
+    private readonly dataSourceService: DataSourceService,
+    private readonly typeORMService: TypeORMService,
+    private readonly objectMetadataService: ObjectMetadataService,
+  ) {
+    super(workspaceRepository);
+    this.logger = new Logger(this.constructor.name);
+  }
+
+  async executeActiveWorkspacesCommand(
+    _passedParam: string[],
+    _options: ActiveWorkspacesCommandOptions,
+    _workspaceIds: string[],
+  ): Promise<void> {
+    const { dryRun } = _options;
+
+    for (const workspaceId of _workspaceIds) {
+      await this.execute(workspaceId, dryRun);
+    }
+  }
+
+  private async execute(workspaceId: string, dryRun = false): Promise<void> {
+    this.logger.log(`Seeding workflow views for workspace: ${workspaceId}`);
+
+    const workflowObjectMetadata =
+      await this.objectMetadataService.findOneWithinWorkspace(workspaceId, {
+        where: {
+          standardId: STANDARD_OBJECT_IDS.workflow,
+        },
+      });
+
+    if (!workflowObjectMetadata) {
+      this.logger.error('Workflow object metadata not found');
+
+      return;
+    }
+
+    await this.seedWorkflowViews(
+      workspaceId,
+      workflowObjectMetadata.id,
+      dryRun,
+    );
+
+    await this.seedWorkspaceFavorite(
+      workspaceId,
+      workflowObjectMetadata.id,
+      dryRun,
+    );
+  }
+
+  private async seedWorkflowViews(
+    workspaceId: string,
+    workflowObjectMetadataId: string,
+    dryRun = false,
+  ) {
+    const viewRepository =
+      await this.twentyORMGlobalManager.getRepositoryForWorkspace(
+        workspaceId,
+        'view',
+      );
+
+    const existingWorkflowView = await viewRepository.findOne({
+      where: {
+        objectMetadataId: workflowObjectMetadataId,
+      },
+    });
+
+    if (existingWorkflowView) {
+      this.logger.log(`View already exists: ${existingWorkflowView.id}`);
+
+      return;
+    }
+
+    if (dryRun) {
+      this.logger.log(`Dry run: not creating view`);
+
+      return;
+    }
+
+    const { objectMetadataStandardIdToIdMap } =
+      await this.objectMetadataService.getObjectMetadataStandardIdToIdMap(
+        workspaceId,
+      );
+
+    const dataSourceMetadata =
+      await this.dataSourceService.getLastDataSourceMetadataFromWorkspaceIdOrFail(
+        workspaceId,
+      );
+
+    const workspaceDataSource =
+      await this.typeORMService.connectToDataSource(dataSourceMetadata);
+
+    if (!workspaceDataSource) {
+      this.logger.error('Could not connect to workspace data source');
+
+      return;
+    }
+
+    const viewDefinitions = [
+      workflowsAllView(objectMetadataStandardIdToIdMap),
+      workflowVersionsAllView(objectMetadataStandardIdToIdMap),
+      workflowRunsAllView(objectMetadataStandardIdToIdMap),
+    ];
+
+    await workspaceDataSource.transaction(
+      async (entityManager: EntityManager) => {
+        return createWorkspaceViews(
+          entityManager,
+          dataSourceMetadata.schema,
+          viewDefinitions,
+        );
+      },
+    );
+  }
+
+  private async seedWorkspaceFavorite(
+    workspaceId: string,
+    workflowObjectMetadataId: string,
+    dryRun = false,
+  ) {
+    const viewRepository =
+      await this.twentyORMGlobalManager.getRepositoryForWorkspace(
+        workspaceId,
+        'view',
+      );
+
+    const workflowView = await viewRepository.findOne({
+      where: {
+        objectMetadataId: workflowObjectMetadataId,
+      },
+    });
+
+    if (!workflowView) {
+      this.logger.error('Workflow view not found');
+
+      return;
+    }
+
+    if (dryRun) {
+      this.logger.log(`Dry run: not creating favorite`);
+
+      return;
+    }
+
+    const favoriteRepository =
+      await this.twentyORMGlobalManager.getRepositoryForWorkspace(
+        workspaceId,
+        'favorite',
+      );
+
+    const existingFavorites = await favoriteRepository.find({
+      where: {
+        viewId: Not(IsNull()),
+      },
+    });
+
+    const workflowFavorite = existingFavorites.find(
+      (favorite) => favorite.viewId === workflowView.id,
+    );
+
+    if (workflowFavorite) {
+      this.logger.log(`Favorite already exists: ${workflowFavorite.id}`);
+
+      return;
+    }
+
+    await favoriteRepository.insert({
+      viewId: workflowView.id,
+      position: existingFavorites.length,
+    });
+  }
+}

packages/twenty-server/src/database/commands/upgrade-version/0-41/0-41-upgrade-version.command.ts

@@ -0,0 +1,48 @@
+import { InjectRepository } from '@nestjs/typeorm';
+
+import { Command } from 'nest-commander';
+import { Repository } from 'typeorm';
+
+import { ActiveWorkspacesCommandRunner } from 'src/database/commands/active-workspaces.command';
+import { BaseCommandOptions } from 'src/database/commands/base.command';
+import { SeedWorkflowViewsCommand } from 'src/database/commands/upgrade-version/0-41/0-41-seed-workflow-views.command';
+import { Workspace } from 'src/engine/core-modules/workspace/workspace.entity';
+import { SyncWorkspaceMetadataCommand } from 'src/engine/workspace-manager/workspace-sync-metadata/commands/sync-workspace-metadata.command';
+
+@Command({
+  name: 'upgrade-0.41',
+  description: 'Upgrade to 0.41',
+})
+export class UpgradeTo0_41Command extends ActiveWorkspacesCommandRunner {
+  constructor(
+    @InjectRepository(Workspace, 'core')
+    protected readonly workspaceRepository: Repository<Workspace>,
+    private readonly seedWorkflowViewsCommand: SeedWorkflowViewsCommand,
+    private readonly syncWorkspaceMetadataCommand: SyncWorkspaceMetadataCommand,
+  ) {
+    super(workspaceRepository);
+  }
+
+  async executeActiveWorkspacesCommand(
+    passedParam: string[],
+    options: BaseCommandOptions,
+    workspaceIds: string[],
+  ): Promise<void> {
+    this.logger.log('Running command to upgrade to 0.41');
+
+    await this.syncWorkspaceMetadataCommand.executeActiveWorkspacesCommand(
+      passedParam,
+      {
+        ...options,
+        force: true,
+      },
+      workspaceIds,
+    );
+
+    await this.seedWorkflowViewsCommand.executeActiveWorkspacesCommand(
+      passedParam,
+      options,
+      workspaceIds,
+    );
+  }
+}

packages/twenty-server/src/database/commands/upgrade-version/0-41/0-41-upgrade-version.module.ts

@@ -0,0 +1,33 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+
+import { SeedWorkflowViewsCommand } from 'src/database/commands/upgrade-version/0-41/0-41-seed-workflow-views.command';
+import { UpgradeTo0_41Command } from 'src/database/commands/upgrade-version/0-41/0-41-upgrade-version.command';
+import { TypeORMModule } from 'src/database/typeorm/typeorm.module';
+import { Workspace } from 'src/engine/core-modules/workspace/workspace.entity';
+import { DataSourceModule } from 'src/engine/metadata-modules/data-source/data-source.module';
+import { ObjectMetadataModule } from 'src/engine/metadata-modules/object-metadata/object-metadata.module';
+import { WorkspaceHealthModule } from 'src/engine/workspace-manager/workspace-health/workspace-health.module';
+import { SyncWorkspaceLoggerService } from 'src/engine/workspace-manager/workspace-sync-metadata/commands/services/sync-workspace-logger.service';
+import { SyncWorkspaceMetadataCommand } from 'src/engine/workspace-manager/workspace-sync-metadata/commands/sync-workspace-metadata.command';
+import { WorkspaceSyncMetadataCommandsModule } from 'src/engine/workspace-manager/workspace-sync-metadata/commands/workspace-sync-metadata-commands.module';
+import { WorkspaceSyncMetadataModule } from 'src/engine/workspace-manager/workspace-sync-metadata/workspace-sync-metadata.module';
+
+@Module({
+  imports: [
+    TypeOrmModule.forFeature([Workspace], 'core'),
+    TypeORMModule,
+    DataSourceModule,
+    ObjectMetadataModule,
+    WorkspaceSyncMetadataCommandsModule,
+    WorkspaceSyncMetadataModule,
+    WorkspaceHealthModule,
+  ],
+  providers: [
+    SyncWorkspaceLoggerService,
+    SyncWorkspaceMetadataCommand,
+    SeedWorkflowViewsCommand,
+    UpgradeTo0_41Command,
+  ],
+})
+export class UpgradeTo0_41CommandModule {}

packages/twenty-server/src/modules/workflow/common/commands/seed-workflow-views.command.ts

@@ -1,185 +0,0 @@
-import { Logger } from '@nestjs/common';
-import { InjectRepository } from '@nestjs/typeorm';
-
-import { Command } from 'nest-commander';
-import { Repository } from 'typeorm';
-import { v4 } from 'uuid';
-
-import {
-  ActiveWorkspacesCommandOptions,
-  ActiveWorkspacesCommandRunner,
-} from 'src/database/commands/active-workspaces.command';
-import { Workspace } from 'src/engine/core-modules/workspace/workspace.entity';
-import { FieldMetadataEntity } from 'src/engine/metadata-modules/field-metadata/field-metadata.entity';
-import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
-import { TwentyORMGlobalManager } from 'src/engine/twenty-orm/twenty-orm-global.manager';
-
-@Command({
-  name: 'workflow:seed:views',
-  description: 'Seed workflow views for workspace.',
-})
-export class SeedWorkflowViewsCommand extends ActiveWorkspacesCommandRunner {
-  protected readonly logger: Logger;
-
-  constructor(
-    @InjectRepository(Workspace, 'core')
-    protected readonly workspaceRepository: Repository<Workspace>,
-    @InjectRepository(ObjectMetadataEntity, 'metadata')
-    private readonly objectMetadataRepository: Repository<ObjectMetadataEntity>,
-
-    @InjectRepository(FieldMetadataEntity, 'metadata')
-    private readonly fieldMetadataRepository: Repository<FieldMetadataEntity>,
-    private readonly twentyORMGlobalManager: TwentyORMGlobalManager,
-  ) {
-    super(workspaceRepository);
-    this.logger = new Logger(this.constructor.name);
-  }
-
-  async executeActiveWorkspacesCommand(
-    _passedParam: string[],
-    _options: ActiveWorkspacesCommandOptions,
-    _workspaceIds: string[],
-  ): Promise<void> {
-    const { dryRun } = _options;
-
-    for (const workspaceId of _workspaceIds) {
-      await this.execute(workspaceId, dryRun);
-    }
-  }
-
-  private async execute(workspaceId: string, dryRun = false): Promise<void> {
-    this.logger.log(`Seeding workflow views for workspace: ${workspaceId}`);
-
-    const workflowViewId = await this.seedView(
-      workspaceId,
-      'workflow',
-      'All Workflows',
-    );
-
-    await this.seedView(
-      workspaceId,
-      'workflowVersion',
-      'All Workflow Versions',
-    );
-
-    await this.seedView(workspaceId, 'workflowRun', 'All Workflow Runs');
-
-    const favoriteRepository =
-      await this.twentyORMGlobalManager.getRepositoryForWorkspace(
-        workspaceId,
-        'favorite',
-      );
-
-    const existingFavorites = await favoriteRepository.find({
-      where: {
-        viewId: workflowViewId,
-      },
-    });
-
-    if (existingFavorites.length > 0) {
-      this.logger.log(
-        `Favorite already exists for view: ${existingFavorites[0].id}`,
-      );
-
-      return;
-    }
-
-    if (dryRun) {
-      this.logger.log(`Dry run: Creating favorite for view: ${workflowViewId}`);
-
-      return;
-    }
-
-    await favoriteRepository.insert({
-      viewId: workflowViewId,
-      position: 5,
-    });
-  }
-
-  private async seedView(
-    workspaceId: string,
-    nameSingular: string,
-    viewName: string,
-    dryRun = false,
-  ): Promise<string> {
-    const objectMetadata = (
-      await this.objectMetadataRepository.find({
-        where: { workspaceId, nameSingular },
-      })
-    )?.[0];
-
-    if (!objectMetadata) {
-      throw new Error(`Object metadata not found: ${nameSingular}`);
-    }
-
-    const fieldMetadataName = (
-      await this.fieldMetadataRepository.find({
-        where: {
-          workspaceId,
-          objectMetadataId: objectMetadata.id,
-          name: 'name',
-        },
-      })
-    )?.[0];
-
-    if (!fieldMetadataName) {
-      throw new Error(
-        `Field metadata not found for ${objectMetadata.id}: name`,
-      );
-    }
-
-    const viewRepository =
-      await this.twentyORMGlobalManager.getRepositoryForWorkspace(
-        workspaceId,
-        'view',
-      );
-
-    const viewFieldRepository =
-      await this.twentyORMGlobalManager.getRepositoryForWorkspace(
-        workspaceId,
-        'viewField',
-      );
-
-    const viewId = v4();
-
-    const existingViews = await viewRepository.find({
-      where: {
-        objectMetadataId: objectMetadata.id,
-        name: viewName,
-      },
-    });
-
-    if (existingViews.length > 0) {
-      this.logger.log(`View already exists: ${existingViews[0].id}`);
-
-      return existingViews[0].id;
-    }
-
-    if (dryRun) {
-      this.logger.log(`Dry run: Creating view: ${viewName}`);
-
-      return viewId;
-    }
-
-    await viewRepository.insert({
-      id: viewId,
-      name: viewName,
-      objectMetadataId: objectMetadata.id,
-      type: 'table',
-      key: 'INDEX',
-      position: 0,
-      icon: 'IconSettingsAutomation',
-      kanbanFieldMetadataId: '',
-    });
-
-    await viewFieldRepository.insert({
-      fieldMetadataId: fieldMetadataName.id,
-      position: 0,
-      isVisible: true,
-      size: 210,
-      viewId: viewId,
-    });
-
-    return viewId;
-  }
-}

packages/twenty-server/src/modules/workflow/common/commands/workflow-command.module.ts

@@ -1,20 +0,0 @@
-import { Module } from '@nestjs/common';
-import { TypeOrmModule } from '@nestjs/typeorm';
-
-import { Workspace } from 'src/engine/core-modules/workspace/workspace.entity';
-import { FieldMetadataEntity } from 'src/engine/metadata-modules/field-metadata/field-metadata.entity';
-import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
-import { SeedWorkflowViewsCommand } from 'src/modules/workflow/common/commands/seed-workflow-views.command';
-
-@Module({
-  imports: [
-    TypeOrmModule.forFeature([Workspace], 'core'),
-    TypeOrmModule.forFeature(
-      [ObjectMetadataEntity, FieldMetadataEntity],
-      'metadata',
-    ),
-  ],
-  providers: [SeedWorkflowViewsCommand],
-  exports: [SeedWorkflowViewsCommand],
-})
-export class WorkflowCommandModule {}

packages/twenty-server/src/modules/workflow/common/workflow-common.module.ts

@@ -2,18 +2,16 @@ import { Module } from '@nestjs/common';
 
 import { NestjsQueryTypeOrmModule } from '@ptc-org/nestjs-query-typeorm';
 
-import { WorkflowCommandModule } from 'src/modules/workflow/common/commands/workflow-command.module';
+import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
+import { ServerlessFunctionModule } from 'src/engine/metadata-modules/serverless-function/serverless-function.module';
 import { WorkflowQueryHookModule } from 'src/modules/workflow/common/query-hooks/workflow-query-hook.module';
 import { WorkflowCommonWorkspaceService } from 'src/modules/workflow/common/workspace-services/workflow-common.workspace-service';
 import { WorkflowVersionStepWorkspaceService } from 'src/modules/workflow/common/workspace-services/workflow-version-step.workspace-service';
 import { WorkflowBuilderModule } from 'src/modules/workflow/workflow-builder/workflow-builder.module';
-import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
-import { ServerlessFunctionModule } from 'src/engine/metadata-modules/serverless-function/serverless-function.module';
 
 @Module({
   imports: [
     WorkflowQueryHookModule,
-    WorkflowCommandModule,
     WorkflowBuilderModule,
     ServerlessFunctionModule,
     NestjsQueryTypeOrmModule.forFeature([ObjectMetadataEntity], 'metadata'),