Refactor upgrade commands (#10592)

Simplifying a lot the upgrade system.

New way to upgrade:
`yarn command:prod upgrade`

New way to write upgrade commands (all wrapping is done for you)
```
  override async runOnWorkspace({
    index,
    total,
    workspaceId,
    options,
  }: RunOnWorkspaceArgs): Promise<void> {}
```

Also cleaning CommandModule imports to make it lighter

packages/twenty-server/src/database/commands/upgrade-version-command/0-43/0-43-add-tasks-assigned-to-me-view.command.ts

@@ -0,0 +1,212 @@
+import { InjectRepository } from '@nestjs/typeorm';
+
+import chalk from 'chalk';
+import { Command } from 'nest-commander';
+import { Repository } from 'typeorm';
+import { v4 } from 'uuid';
+
+import {
+  ActiveOrSuspendedWorkspacesMigrationCommandRunner,
+  RunOnWorkspaceArgs,
+} from 'src/database/commands/command-runners/active-or-suspended-workspaces-migration.command-runner';
+import { Workspace } from 'src/engine/core-modules/workspace/workspace.entity';
+import { FieldMetadataDefaultOption } from 'src/engine/metadata-modules/field-metadata/dtos/options.input';
+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 { WorkspaceMetadataVersionService } from 'src/engine/metadata-modules/workspace-metadata-version/services/workspace-metadata-version.service';
+import { TwentyORMGlobalManager } from 'src/engine/twenty-orm/twenty-orm-global.manager';
+import { tasksAssignedToMeView } from 'src/engine/workspace-manager/standard-objects-prefill-data/views/tasks-assigned-to-me';
+import { TASK_STANDARD_FIELD_IDS } from 'src/engine/workspace-manager/workspace-sync-metadata/constants/standard-field-ids';
+import { STANDARD_OBJECT_IDS } from 'src/engine/workspace-manager/workspace-sync-metadata/constants/standard-object-ids';
+import { ViewFieldWorkspaceEntity } from 'src/modules/view/standard-objects/view-field.workspace-entity';
+import { ViewFilterWorkspaceEntity } from 'src/modules/view/standard-objects/view-filter.workspace-entity';
+import { ViewGroupWorkspaceEntity } from 'src/modules/view/standard-objects/view-group.workspace-entity';
+import { ViewWorkspaceEntity } from 'src/modules/view/standard-objects/view.workspace-entity';
+
+@Command({
+  name: 'upgrade:0-43:add-tasks-assigned-to-me-view',
+  description: 'Add tasks assigned to me view',
+})
+export class AddTasksAssignedToMeViewCommand extends ActiveOrSuspendedWorkspacesMigrationCommandRunner {
+  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>,
+    protected readonly twentyORMGlobalManager: TwentyORMGlobalManager,
+    private readonly workspaceMetadataVersionService: WorkspaceMetadataVersionService,
+  ) {
+    super(workspaceRepository, twentyORMGlobalManager);
+  }
+
+  override async runOnWorkspace({
+    index,
+    total,
+    workspaceId,
+  }: RunOnWorkspaceArgs): Promise<void> {
+    this.logger.log(
+      `Running command for workspace ${workspaceId} ${index + 1}/${total}`,
+    );
+
+    await this.createTasksAssignedToMeView(workspaceId);
+
+    this.logger.log(
+      chalk.green(`Command completed for workspace ${workspaceId}.`),
+    );
+  }
+
+  private async createTasksAssignedToMeView(
+    workspaceId: string,
+  ): Promise<void> {
+    const objectMetadata = await this.objectMetadataRepository.find({
+      where: { workspaceId },
+      relations: ['fields'],
+    });
+
+    const objectMetadataMap = objectMetadata.reduce((acc, object) => {
+      acc[object.standardId ?? ''] = {
+        id: object.id,
+        fields: object.fields.reduce((acc, field) => {
+          acc[field.standardId ?? ''] = field.id;
+
+          return acc;
+        }, {}),
+      };
+
+      return acc;
+    }, {});
+
+    const taskObjectMetadata = objectMetadata.find(
+      (object) => object.standardId === STANDARD_OBJECT_IDS.task,
+    );
+
+    if (!taskObjectMetadata) {
+      throw new Error(`Task object not found for workspace ${workspaceId}`);
+    }
+
+    const viewRepository =
+      await this.twentyORMGlobalManager.getRepositoryForWorkspace<ViewWorkspaceEntity>(
+        workspaceId,
+        'view',
+        false,
+      );
+
+    const existingView = await viewRepository.findOne({
+      where: {
+        name: 'Assigned to Me',
+        objectMetadataId: taskObjectMetadata.id,
+      },
+    });
+
+    if (existingView) {
+      this.logger.log(
+        chalk.yellow(
+          `"Assigned to Me" view already exists for workspace ${workspaceId}`,
+        ),
+      );
+
+      return;
+    }
+
+    const viewDefinition = tasksAssignedToMeView(objectMetadataMap);
+    const viewId = v4();
+
+    const insertedView = await viewRepository.save({
+      id: viewId,
+      name: viewDefinition.name,
+      objectMetadataId: viewDefinition.objectMetadataId,
+      type: viewDefinition.type,
+      position: viewDefinition.position,
+      icon: viewDefinition.icon,
+      kanbanFieldMetadataId: viewDefinition.kanbanFieldMetadataId,
+    });
+
+    if (viewDefinition.fields && viewDefinition.fields.length > 0) {
+      const viewFieldRepository =
+        await this.twentyORMGlobalManager.getRepositoryForWorkspace<ViewFieldWorkspaceEntity>(
+          workspaceId,
+          'viewField',
+          false,
+        );
+
+      const viewFields = viewDefinition.fields.map((field) => ({
+        fieldMetadataId: field.fieldMetadataId,
+        position: field.position,
+        isVisible: field.isVisible,
+        size: field.size,
+        viewId: insertedView.id,
+      }));
+
+      await viewFieldRepository.save(viewFields);
+    }
+
+    if (viewDefinition.filters && viewDefinition.filters.length > 0) {
+      const viewFilterRepository =
+        await this.twentyORMGlobalManager.getRepositoryForWorkspace<ViewFilterWorkspaceEntity>(
+          workspaceId,
+          'viewFilter',
+          false,
+        );
+
+      const viewFilters = viewDefinition.filters.map((filter) => ({
+        fieldMetadataId: filter.fieldMetadataId,
+        displayValue: filter.displayValue,
+        operand: filter.operand,
+        value: filter.value,
+        viewId: insertedView.id,
+      }));
+
+      await viewFilterRepository.save(viewFilters);
+    }
+
+    await this.createTasksAssignedToMeViewGroups(workspaceId, insertedView.id);
+  }
+
+  private async createTasksAssignedToMeViewGroups(
+    workspaceId: string,
+    viewId: string,
+  ) {
+    const taskStatusFieldMetadata = await this.fieldMetadataRepository.findOne({
+      where: {
+        workspaceId,
+        standardId: TASK_STANDARD_FIELD_IDS.status,
+      },
+    });
+
+    if (!taskStatusFieldMetadata) {
+      throw new Error(
+        `Task status field metadata not found for workspace ${workspaceId}`,
+      );
+    }
+
+    const optionValueViewGroups = taskStatusFieldMetadata.options.map(
+      (taskStatusOption: FieldMetadataDefaultOption, index) =>
+        ({
+          fieldMetadataId: taskStatusFieldMetadata.id,
+          viewId,
+          fieldValue: taskStatusOption.value,
+          position: index,
+        }) satisfies Partial<ViewGroupWorkspaceEntity>,
+    );
+
+    const noValueViewGroup: Partial<ViewGroupWorkspaceEntity> = {
+      fieldMetadataId: taskStatusFieldMetadata.id,
+      viewId,
+      fieldValue: '',
+      position: optionValueViewGroups.length,
+    };
+
+    const viewGroups = [...optionValueViewGroups, noValueViewGroup];
+
+    const viewGroupRepository =
+      await this.twentyORMGlobalManager.getRepositoryForWorkspace<ViewGroupWorkspaceEntity>(
+        workspaceId,
+        'viewGroup',
+        false,
+      );
+
+    await viewGroupRepository.insert(viewGroups);
+  }
+}

packages/twenty-server/src/database/commands/upgrade-version-command/0-43/0-43-migrate-is-searchable-for-custom-object-metadata.command.ts

@@ -0,0 +1,51 @@
+import { InjectRepository } from '@nestjs/typeorm';
+
+import { Command } from 'nest-commander';
+import { Repository } from 'typeorm';
+
+import {
+  ActiveOrSuspendedWorkspacesMigrationCommandRunner,
+  RunOnWorkspaceArgs,
+} from 'src/database/commands/command-runners/active-or-suspended-workspaces-migration.command-runner';
+import { Workspace } from 'src/engine/core-modules/workspace/workspace.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: 'upgrade:0-43:migrate-is-searchable-for-custom-object-metadata',
+  description: 'Set isSearchable true for custom object metadata',
+})
+export class MigrateIsSearchableForCustomObjectMetadataCommand extends ActiveOrSuspendedWorkspacesMigrationCommandRunner {
+  constructor(
+    @InjectRepository(Workspace, 'core')
+    protected readonly workspaceRepository: Repository<Workspace>,
+    protected readonly twentyORMGlobalManager: TwentyORMGlobalManager,
+    @InjectRepository(ObjectMetadataEntity, 'metadata')
+    protected readonly objectMetadataRepository: Repository<ObjectMetadataEntity>,
+  ) {
+    super(workspaceRepository, twentyORMGlobalManager);
+  }
+
+  override async runOnWorkspace({
+    index,
+    total,
+    workspaceId,
+    options,
+  }: RunOnWorkspaceArgs): Promise<void> {
+    this.logger.log(
+      `Running command for workspace ${workspaceId} ${index + 1}/${total}`,
+    );
+
+    if (!options.dryRun) {
+      await this.objectMetadataRepository.update(
+        {
+          workspaceId,
+          isCustom: true,
+        },
+        {
+          isSearchable: true,
+        },
+      );
+    }
+  }
+}

packages/twenty-server/src/database/commands/upgrade-version-command/0-43/0-43-migrate-rich-text-content-patch.command.ts

@@ -0,0 +1,265 @@
+import { InjectRepository } from '@nestjs/typeorm';
+
+import { ServerBlockNoteEditor } from '@blocknote/server-util';
+import chalk from 'chalk';
+import { Command } from 'nest-commander';
+import { FieldMetadataType } from 'twenty-shared';
+import { Repository } from 'typeorm';
+
+import {
+  ActiveOrSuspendedWorkspacesMigrationCommandOptions,
+  ActiveOrSuspendedWorkspacesMigrationCommandRunner,
+  RunOnWorkspaceArgs,
+} from 'src/database/commands/command-runners/active-or-suspended-workspaces-migration.command-runner';
+import { FeatureFlagKey } from 'src/engine/core-modules/feature-flag/enums/feature-flag-key.enum';
+import { FeatureFlag } from 'src/engine/core-modules/feature-flag/feature-flag.entity';
+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';
+import { computeTableName } from 'src/engine/utils/compute-table-name.util';
+import { WorkspaceDataSourceService } from 'src/engine/workspace-datasource/workspace-datasource.service';
+
+type MigrateRichTextContentArgs = {
+  richTextFieldsWithObjectMetadata: RichTextFieldsWithObjectMetadata[];
+  workspaceId: string;
+  options: ActiveOrSuspendedWorkspacesMigrationCommandOptions;
+};
+
+type RichTextFieldsWithObjectMetadata = {
+  richTextField: FieldMetadataEntity;
+  objectMetadata: ObjectMetadataEntity | null;
+};
+
+type ProcessRichTextFieldsArgs = {
+  richTextFields: FieldMetadataEntity[];
+  workspaceId: string;
+};
+
+@Command({
+  name: 'upgrade:0-43:migrate-rich-text-content-patch',
+  description: 'Migrate RICH_TEXT content from v1 to v2',
+})
+export class MigrateRichTextContentPatchCommand extends ActiveOrSuspendedWorkspacesMigrationCommandRunner {
+  constructor(
+    @InjectRepository(Workspace, 'core')
+    protected readonly workspaceRepository: Repository<Workspace>,
+    protected readonly twentyORMGlobalManager: TwentyORMGlobalManager,
+    @InjectRepository(FieldMetadataEntity, 'metadata')
+    private readonly fieldMetadataRepository: Repository<FieldMetadataEntity>,
+    @InjectRepository(ObjectMetadataEntity, 'metadata')
+    private readonly objectMetadataRepository: Repository<ObjectMetadataEntity>,
+    @InjectRepository(FeatureFlag, 'core')
+    protected readonly featureFlagRepository: Repository<FeatureFlag>,
+    private readonly workspaceDataSourceService: WorkspaceDataSourceService,
+  ) {
+    super(workspaceRepository, twentyORMGlobalManager);
+  }
+
+  override async runOnWorkspace({
+    index,
+    total,
+    options,
+    workspaceId,
+  }: RunOnWorkspaceArgs): Promise<void> {
+    this.logger.log(
+      `Running MigrateRichTextContentPatchCommand for workspace ${workspaceId} ${index + 1}/${total}`,
+    );
+
+    if (await this.hasRichTextV2FeatureFlag(workspaceId)) {
+      this.logger.log(
+        chalk.yellow(
+          'Rich text v2 feature flag is enabled, skipping migration',
+        ),
+      );
+
+      return;
+    }
+
+    const richTextFields = await this.fieldMetadataRepository.find({
+      where: {
+        workspaceId,
+        type: FieldMetadataType.RICH_TEXT,
+      },
+    });
+
+    if (!richTextFields.length) {
+      this.logger.log(
+        chalk.yellow('No RICH_TEXT fields found in this workspace'),
+      );
+
+      return;
+    }
+
+    this.logger.log(`Found ${richTextFields.length} RICH_TEXT fields`);
+
+    const richTextFieldsWithObjectMetadata =
+      await this.getRichTextFieldsWithObjectMetadata({
+        richTextFields,
+        workspaceId,
+      });
+
+    await this.migrateToNewRichTextFieldsColumn({
+      richTextFieldsWithObjectMetadata,
+      workspaceId,
+      options,
+    });
+
+    this.logger.log(
+      chalk.green(`Command completed for workspace ${workspaceId}`),
+    );
+  }
+
+  private async hasRichTextV2FeatureFlag(
+    workspaceId: string,
+  ): Promise<boolean> {
+    return await this.featureFlagRepository.exists({
+      where: {
+        workspaceId,
+        key: 'IS_RICH_TEXT_V2_ENABLED' as FeatureFlagKey,
+        value: true,
+      },
+    });
+  }
+
+  private async getRichTextFieldsWithObjectMetadata({
+    richTextFields,
+    workspaceId,
+  }: ProcessRichTextFieldsArgs): Promise<RichTextFieldsWithObjectMetadata[]> {
+    const richTextFieldsWithObjectMetadata: RichTextFieldsWithObjectMetadata[] =
+      [];
+
+    for (const richTextField of richTextFields) {
+      const objectMetadata = await this.objectMetadataRepository.findOne({
+        where: { id: richTextField.objectMetadataId },
+        relations: {
+          fields: true,
+        },
+      });
+
+      if (objectMetadata === null) {
+        this.logger.log(
+          `Object metadata not found for rich text field ${richTextField.name} in workspace ${workspaceId}`,
+        );
+      }
+
+      richTextFieldsWithObjectMetadata.push({
+        richTextField,
+        objectMetadata,
+      });
+    }
+
+    return richTextFieldsWithObjectMetadata;
+  }
+
+  private jsonParseOrSilentlyFail(input: string): null | unknown {
+    try {
+      return JSON.parse(input);
+    } catch (e) {
+      return null;
+    }
+  }
+
+  private async getMarkdownFieldValue({
+    blocknoteFieldValue,
+    serverBlockNoteEditor,
+  }: {
+    blocknoteFieldValue: string | null;
+    serverBlockNoteEditor: ServerBlockNoteEditor;
+  }): Promise<string | null> {
+    const blocknoteFieldValueIsDefined =
+      blocknoteFieldValue !== null &&
+      blocknoteFieldValue !== undefined &&
+      blocknoteFieldValue !== '{}';
+
+    if (!blocknoteFieldValueIsDefined) {
+      return null;
+    }
+
+    const jsonParsedblocknoteFieldValue =
+      this.jsonParseOrSilentlyFail(blocknoteFieldValue);
+
+    if (jsonParsedblocknoteFieldValue === null) {
+      return null;
+    }
+
+    if (!Array.isArray(jsonParsedblocknoteFieldValue)) {
+      this.logger.log(
+        `blocknoteFieldValue is defined and is not an array got ${blocknoteFieldValue}`,
+      );
+
+      return null;
+    }
+
+    let markdown: string | null = null;
+
+    try {
+      markdown = await serverBlockNoteEditor.blocksToMarkdownLossy(
+        jsonParsedblocknoteFieldValue,
+      );
+    } catch (error) {
+      this.logger.log(
+        `Error converting blocknote to markdown for ${blocknoteFieldValue}`,
+      );
+    }
+
+    return markdown;
+  }
+
+  private async migrateToNewRichTextFieldsColumn({
+    richTextFieldsWithObjectMetadata,
+    workspaceId,
+    options,
+  }: MigrateRichTextContentArgs) {
+    const serverBlockNoteEditor = ServerBlockNoteEditor.create();
+
+    for (const {
+      richTextField,
+      objectMetadata,
+    } of richTextFieldsWithObjectMetadata) {
+      if (objectMetadata === null) {
+        this.logger.log(
+          `Object metadata not found for rich text field ${richTextField.name} in workspace ${workspaceId}`,
+        );
+        continue;
+      }
+
+      const schemaName =
+        this.workspaceDataSourceService.getSchemaName(workspaceId);
+
+      const workspaceDataSource =
+        await this.twentyORMGlobalManager.getDataSourceForWorkspace(
+          workspaceId,
+        );
+
+      const rows = await workspaceDataSource.query(
+        `SELECT id, "${richTextField.name}" FROM "${schemaName}"."${computeTableName(objectMetadata.nameSingular, objectMetadata.isCustom)}" WHERE "${richTextField.name}" IS NOT NULL`,
+      );
+
+      this.logger.log(`Generating markdown for ${rows.length} records`);
+
+      for (const row of rows) {
+        const blocknoteFieldValue = row[richTextField.name];
+        const markdownFieldValue = await this.getMarkdownFieldValue({
+          blocknoteFieldValue,
+          serverBlockNoteEditor,
+        });
+
+        if (!options.dryRun) {
+          try {
+            await workspaceDataSource.query(
+              `UPDATE "${schemaName}"."${computeTableName(objectMetadata.nameSingular, objectMetadata.isCustom)}" SET "${richTextField.name}V2Blocknote" = $1, "${richTextField.name}V2Markdown" = $2 WHERE id = $3`,
+              [blocknoteFieldValue, markdownFieldValue, row.id],
+            );
+          } catch (error) {
+            this.logger.log(
+              chalk.red(
+                `Error updating rich text field ${richTextField.name} for record ${row.id} in workspace ${workspaceId}`,
+              ),
+            );
+          }
+        }
+      }
+    }
+  }
+}

packages/twenty-server/src/database/commands/upgrade-version-command/0-43/0-43-migrate-search-vector-on-note-and-task-entities.command.ts

@@ -0,0 +1,96 @@
+import { InjectRepository } from '@nestjs/typeorm';
+
+import { Command } from 'nest-commander';
+import { Repository } from 'typeorm';
+
+import {
+  ActiveOrSuspendedWorkspacesMigrationCommandRunner,
+  RunOnWorkspaceArgs,
+} from 'src/database/commands/command-runners/active-or-suspended-workspaces-migration.command-runner';
+import { FeatureFlag } from 'src/engine/core-modules/feature-flag/feature-flag.entity';
+import { Workspace } from 'src/engine/core-modules/workspace/workspace.entity';
+import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
+import { SearchService } from 'src/engine/metadata-modules/search/search.service';
+import { WorkspaceMetadataVersionService } from 'src/engine/metadata-modules/workspace-metadata-version/services/workspace-metadata-version.service';
+import { TwentyORMGlobalManager } from 'src/engine/twenty-orm/twenty-orm-global.manager';
+import { WorkspaceMigrationRunnerService } from 'src/engine/workspace-manager/workspace-migration-runner/workspace-migration-runner.service';
+import { SEARCH_FIELDS_FOR_NOTES } from 'src/modules/note/standard-objects/note.workspace-entity';
+import { SEARCH_FIELDS_FOR_TASKS } from 'src/modules/task/standard-objects/task.workspace-entity';
+
+@Command({
+  name: 'upgrade:0-43:migrate-search-vector-on-note-and-task-entities',
+  description: 'Migrate search vector on note and task entities',
+})
+export class MigrateSearchVectorOnNoteAndTaskEntitiesCommand extends ActiveOrSuspendedWorkspacesMigrationCommandRunner {
+  constructor(
+    @InjectRepository(Workspace, 'core')
+    protected readonly workspaceRepository: Repository<Workspace>,
+    protected readonly twentyORMGlobalManager: TwentyORMGlobalManager,
+    @InjectRepository(FeatureFlag, 'core')
+    protected readonly featureFlagRepository: Repository<FeatureFlag>,
+    @InjectRepository(ObjectMetadataEntity, 'metadata')
+    protected readonly objectMetadataRepository: Repository<ObjectMetadataEntity>,
+    private readonly searchService: SearchService,
+    private readonly workspaceMigrationRunnerService: WorkspaceMigrationRunnerService,
+    private readonly workspaceMetadataVersionService: WorkspaceMetadataVersionService,
+  ) {
+    super(workspaceRepository, twentyORMGlobalManager);
+  }
+
+  override async runOnWorkspace({
+    index,
+    total,
+    workspaceId,
+    options,
+  }: RunOnWorkspaceArgs): Promise<void> {
+    this.logger.log(
+      `Running command for workspace ${workspaceId} ${index + 1}/${total}`,
+    );
+
+    const noteObjectMetadata =
+      await this.objectMetadataRepository.findOneOrFail({
+        select: ['id'],
+        where: {
+          workspaceId,
+          nameSingular: 'note',
+        },
+      });
+
+    if (!options.dryRun) {
+      await this.searchService.updateSearchVector(
+        noteObjectMetadata.id,
+        SEARCH_FIELDS_FOR_NOTES,
+        workspaceId,
+      );
+    }
+
+    const taskObjectMetadata =
+      await this.objectMetadataRepository.findOneOrFail({
+        select: ['id'],
+        where: {
+          workspaceId,
+          nameSingular: 'task',
+        },
+      });
+
+    if (!options.dryRun) {
+      await this.searchService.updateSearchVector(
+        taskObjectMetadata.id,
+        SEARCH_FIELDS_FOR_TASKS,
+        workspaceId,
+      );
+    }
+
+    await this.workspaceMigrationRunnerService.executeMigrationFromPendingMigrations(
+      workspaceId,
+    );
+
+    await this.workspaceMetadataVersionService.incrementMetadataVersion(
+      workspaceId,
+    );
+
+    this.logger.log(
+      `Migrated search vector on note and task entities for workspace ${workspaceId}`,
+    );
+  }
+}

packages/twenty-server/src/database/commands/upgrade-version-command/0-43/0-43-update-default-view-record-opening-on-workflow-objects.command.ts

@@ -0,0 +1,95 @@
+import { InjectRepository } from '@nestjs/typeorm';
+
+import chalk from 'chalk';
+import { Command } from 'nest-commander';
+import { In, Repository } from 'typeorm';
+
+import {
+  ActiveOrSuspendedWorkspacesMigrationCommandRunner,
+  RunOnWorkspaceArgs,
+} from 'src/database/commands/command-runners/active-or-suspended-workspaces-migration.command-runner';
+import { Workspace } from 'src/engine/core-modules/workspace/workspace.entity';
+import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
+import { TwentyORMGlobalManager } from 'src/engine/twenty-orm/twenty-orm-global.manager';
+import { STANDARD_OBJECT_IDS } from 'src/engine/workspace-manager/workspace-sync-metadata/constants/standard-object-ids';
+import { ViewOpenRecordInType } from 'src/modules/view/standard-objects/view.workspace-entity';
+
+@Command({
+  name: 'upgrade:0-43:update-default-view-record-opening-on-workflow-objects',
+  description:
+    'Update default view record opening on workflow objects to record page',
+})
+export class UpdateDefaultViewRecordOpeningOnWorkflowObjectsCommand extends ActiveOrSuspendedWorkspacesMigrationCommandRunner {
+  constructor(
+    @InjectRepository(Workspace, 'core')
+    protected readonly workspaceRepository: Repository<Workspace>,
+    @InjectRepository(ObjectMetadataEntity, 'metadata')
+    protected readonly objectMetadataRepository: Repository<ObjectMetadataEntity>,
+    protected readonly twentyORMGlobalManager: TwentyORMGlobalManager,
+  ) {
+    super(workspaceRepository, twentyORMGlobalManager);
+  }
+
+  override async runOnWorkspace({
+    index,
+    total,
+    workspaceId,
+    options,
+  }: RunOnWorkspaceArgs): Promise<void> {
+    this.logger.log(
+      `Running command for workspace ${workspaceId} ${index + 1}/${total}`,
+    );
+
+    const workflowObjectsMetadata = await this.objectMetadataRepository.find({
+      select: ['id'],
+      where: {
+        workspaceId,
+        standardId: In([
+          STANDARD_OBJECT_IDS.workflow,
+          STANDARD_OBJECT_IDS.workflowVersion,
+          STANDARD_OBJECT_IDS.workflowRun,
+        ]),
+      },
+    });
+
+    if (workflowObjectsMetadata.length === 0) {
+      this.logger.log(
+        chalk.yellow(`No workflow objects found for workspace ${workspaceId}`),
+      );
+
+      return;
+    }
+
+    if (!options.dryRun) {
+      await this.updateDefaultViewsRecordOpening(
+        workflowObjectsMetadata.map((metadata) => metadata.id),
+        workspaceId,
+      );
+    }
+
+    this.logger.log(
+      chalk.green(`Command completed for workspace ${workspaceId}.`),
+    );
+  }
+
+  private async updateDefaultViewsRecordOpening(
+    workflowObjectMetadataIds: string[],
+    workspaceId: string,
+  ): Promise<void> {
+    const viewRepository =
+      await this.twentyORMGlobalManager.getRepositoryForWorkspace(
+        workspaceId,
+        'view',
+      );
+
+    await viewRepository.update(
+      {
+        objectMetadataId: In(workflowObjectMetadataIds),
+        key: 'INDEX',
+      },
+      {
+        openRecordIn: ViewOpenRecordInType.RECORD_PAGE,
+      },
+    );
+  }
+}

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

@@ -0,0 +1,45 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+
+import { AddTasksAssignedToMeViewCommand } from 'src/database/commands/upgrade-version-command/0-43/0-43-add-tasks-assigned-to-me-view.command';
+import { MigrateIsSearchableForCustomObjectMetadataCommand } from 'src/database/commands/upgrade-version-command/0-43/0-43-migrate-is-searchable-for-custom-object-metadata.command';
+import { MigrateRichTextContentPatchCommand } from 'src/database/commands/upgrade-version-command/0-43/0-43-migrate-rich-text-content-patch.command';
+import { MigrateSearchVectorOnNoteAndTaskEntitiesCommand } from 'src/database/commands/upgrade-version-command/0-43/0-43-migrate-search-vector-on-note-and-task-entities.command';
+import { UpdateDefaultViewRecordOpeningOnWorkflowObjectsCommand } from 'src/database/commands/upgrade-version-command/0-43/0-43-update-default-view-record-opening-on-workflow-objects.command';
+import { FeatureFlag } from 'src/engine/core-modules/feature-flag/feature-flag.entity';
+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 { SearchModule } from 'src/engine/metadata-modules/search/search.module';
+import { WorkspaceMetadataVersionModule } from 'src/engine/metadata-modules/workspace-metadata-version/workspace-metadata-version.module';
+import { WorkspaceDataSourceModule } from 'src/engine/workspace-datasource/workspace-datasource.module';
+import { WorkspaceMigrationRunnerModule } from 'src/engine/workspace-manager/workspace-migration-runner/workspace-migration-runner.module';
+
+@Module({
+  imports: [
+    TypeOrmModule.forFeature([Workspace, FeatureFlag], 'core'),
+    TypeOrmModule.forFeature(
+      [FieldMetadataEntity, ObjectMetadataEntity],
+      'metadata',
+    ),
+    WorkspaceDataSourceModule,
+    SearchModule,
+    WorkspaceMigrationRunnerModule,
+    WorkspaceMetadataVersionModule,
+  ],
+  providers: [
+    MigrateRichTextContentPatchCommand,
+    MigrateSearchVectorOnNoteAndTaskEntitiesCommand,
+    UpdateDefaultViewRecordOpeningOnWorkflowObjectsCommand,
+    MigrateIsSearchableForCustomObjectMetadataCommand,
+    AddTasksAssignedToMeViewCommand,
+  ],
+  exports: [
+    MigrateRichTextContentPatchCommand,
+    MigrateSearchVectorOnNoteAndTaskEntitiesCommand,
+    UpdateDefaultViewRecordOpeningOnWorkflowObjectsCommand,
+    MigrateIsSearchableForCustomObjectMetadataCommand,
+    AddTasksAssignedToMeViewCommand,
+  ],
+})
+export class V0_43_UpgradeVersionCommandModule {}

packages/twenty-server/src/database/commands/upgrade-version-command/0-44/0-44-initialize-permissions.command.ts

@@ -0,0 +1,282 @@
+import { InjectRepository } from '@nestjs/typeorm';
+
+import chalk from 'chalk';
+import { Command } from 'nest-commander';
+import { isDefined } from 'twenty-shared';
+import { IsNull, Repository } from 'typeorm';
+
+import {
+  ActiveOrSuspendedWorkspacesMigrationCommandOptions,
+  ActiveOrSuspendedWorkspacesMigrationCommandRunner,
+  RunOnWorkspaceArgs,
+} from 'src/database/commands/command-runners/active-or-suspended-workspaces-migration.command-runner';
+import { UserWorkspace } from 'src/engine/core-modules/user-workspace/user-workspace.entity';
+import { Workspace } from 'src/engine/core-modules/workspace/workspace.entity';
+import { ADMIN_ROLE_LABEL } from 'src/engine/metadata-modules/permissions/constants/admin-role-label.constants';
+import { MEMBER_ROLE_LABEL } from 'src/engine/metadata-modules/permissions/constants/member-role-label.constants';
+import { RoleService } from 'src/engine/metadata-modules/role/role.service';
+import { UserRoleService } from 'src/engine/metadata-modules/user-role/user-role.service';
+import { TwentyORMGlobalManager } from 'src/engine/twenty-orm/twenty-orm-global.manager';
+
+@Command({
+  name: 'upgrade:0-44:initialize-permissions',
+  description: 'Initialize permissions',
+})
+export class InitializePermissionsCommand extends ActiveOrSuspendedWorkspacesMigrationCommandRunner {
+  constructor(
+    @InjectRepository(Workspace, 'core')
+    protected readonly workspaceRepository: Repository<Workspace>,
+    @InjectRepository(UserWorkspace, 'core')
+    protected readonly userWorkspaceRepository: Repository<UserWorkspace>,
+    protected readonly twentyORMGlobalManager: TwentyORMGlobalManager,
+    private readonly roleService: RoleService,
+    private readonly userRoleService: UserRoleService,
+  ) {
+    super(workspaceRepository, twentyORMGlobalManager);
+  }
+
+  override async runOnWorkspace({
+    index,
+    total,
+    workspaceId,
+    options,
+  }: RunOnWorkspaceArgs): Promise<void> {
+    try {
+      this.logger.log(
+        `Running command for workspace ${workspaceId} ${index + 1}/${total}`,
+      );
+
+      let adminRoleId: string | undefined;
+
+      const workspaceRoles =
+        await this.roleService.getWorkspaceRoles(workspaceId);
+
+      adminRoleId = workspaceRoles.find(
+        (role) => role.label === ADMIN_ROLE_LABEL,
+      )?.id;
+
+      if (!isDefined(adminRoleId)) {
+        adminRoleId = await this.createAdminRole({
+          workspaceId,
+          options,
+        });
+      }
+
+      await this.assignAdminRole({
+        workspaceId,
+        adminRoleId,
+        options,
+      });
+
+      let memberRoleId: string | undefined;
+
+      memberRoleId = workspaceRoles.find(
+        (role) => role.label === MEMBER_ROLE_LABEL,
+      )?.id;
+
+      if (!isDefined(memberRoleId)) {
+        memberRoleId = await this.createMemberRole({
+          workspaceId,
+          options,
+        });
+      }
+
+      await this.setMemberRoleAsDefaultRole({
+        workspaceId,
+        memberRoleId,
+        options,
+      });
+
+      await this.assignMemberRoleToUserWorkspacesWithoutRole({
+        workspaceId,
+        memberRoleId,
+        options,
+      });
+    } catch (error) {
+      this.logger.log(
+        chalk.red(`Error in workspace ${workspaceId} - ${error.message}`),
+      );
+    }
+  }
+
+  private async createAdminRole({
+    workspaceId,
+    options,
+  }: {
+    workspaceId: string;
+    options: ActiveOrSuspendedWorkspacesMigrationCommandOptions;
+  }) {
+    this.logger.log(
+      chalk.green(`Creating admin role ${options.dryRun ? '(dry run)' : ''}`),
+    );
+
+    if (options.dryRun) {
+      return '';
+    }
+
+    const adminRole = await this.roleService.createAdminRole({
+      workspaceId,
+    });
+
+    return adminRole.id;
+  }
+
+  private async createMemberRole({
+    workspaceId,
+    options,
+  }: {
+    workspaceId: string;
+    options: ActiveOrSuspendedWorkspacesMigrationCommandOptions;
+  }) {
+    this.logger.log(
+      chalk.green(`Creating member role ${options.dryRun ? '(dry run)' : ''}`),
+    );
+
+    if (options.dryRun) {
+      return '';
+    }
+
+    const memberRole = await this.roleService.createMemberRole({
+      workspaceId,
+    });
+
+    return memberRole.id;
+  }
+
+  private async setMemberRoleAsDefaultRole({
+    workspaceId,
+    memberRoleId,
+    options,
+  }: {
+    workspaceId: string;
+    memberRoleId: string;
+    options: ActiveOrSuspendedWorkspacesMigrationCommandOptions;
+  }) {
+    const workspaceDefaultRole = await this.workspaceRepository.findOne({
+      where: {
+        id: workspaceId,
+      },
+    });
+
+    if (!isDefined(workspaceDefaultRole?.defaultRoleId)) {
+      this.logger.log(
+        chalk.green(
+          `Setting member role as default role ${options.dryRun ? '(dry run)' : ''}`,
+        ),
+      );
+
+      if (options.dryRun) {
+        return;
+      }
+
+      await this.workspaceRepository.update(workspaceId, {
+        defaultRoleId: memberRoleId,
+      });
+    }
+  }
+
+  private async assignAdminRole({
+    workspaceId,
+    adminRoleId,
+    options,
+  }: {
+    workspaceId: string;
+    adminRoleId: string;
+    options: ActiveOrSuspendedWorkspacesMigrationCommandOptions;
+  }) {
+    const oldestUserWorkspace = await this.userWorkspaceRepository.findOne({
+      where: {
+        workspaceId,
+        deletedAt: IsNull(),
+      },
+      relations: {
+        user: true,
+      },
+      order: {
+        user: {
+          createdAt: 'ASC',
+        },
+      },
+    });
+
+    if (!oldestUserWorkspace) {
+      throw new Error('No user workspace found');
+    }
+
+    this.logger.log(
+      chalk.green(
+        `Assigning admin role to user ${oldestUserWorkspace.id} ${options.dryRun ? '(dry run)' : ''}`,
+      ),
+    );
+
+    if (options.dryRun) {
+      return;
+    }
+
+    await this.userRoleService.assignRoleToUserWorkspace({
+      roleId: adminRoleId,
+      userWorkspaceId: oldestUserWorkspace.id,
+      workspaceId,
+    });
+  }
+
+  private async assignMemberRoleToUserWorkspacesWithoutRole({
+    workspaceId,
+    memberRoleId,
+    options,
+  }: {
+    workspaceId: string;
+    memberRoleId: string;
+    options: ActiveOrSuspendedWorkspacesMigrationCommandOptions;
+  }) {
+    const userWorkspaces = await this.userWorkspaceRepository.find({
+      where: {
+        workspaceId,
+      },
+      relations: {
+        user: true,
+      },
+    });
+
+    const rolesByUserWorkspace =
+      await this.userRoleService.getRolesByUserWorkspaces({
+        userWorkspaceIds: userWorkspaces.map(
+          (userWorkspace) => userWorkspace.id,
+        ),
+        workspaceId,
+      });
+
+    for (const userWorkspace of userWorkspaces) {
+      // If userWorkspace has a role, do nothing
+      if (
+        rolesByUserWorkspace
+          .get(userWorkspace.id)
+          ?.some((role) => isDefined(role))
+      ) {
+        this.logger.log(
+          chalk.green(
+            `User workspace ${userWorkspace.id} already has a role. Skipping member role assignation`,
+          ),
+        );
+        continue;
+      }
+
+      this.logger.log(
+        chalk.green(
+          `Assigning member role to user workspace ${userWorkspace.id} ${options.dryRun ? '(dry run)' : ''}`,
+        ),
+      );
+
+      if (options.dryRun) {
+        continue;
+      }
+
+      // Otherwise, assign member role to userWorkspace
+      await this.userRoleService.assignRoleToUserWorkspace({
+        roleId: memberRoleId,
+        userWorkspaceId: userWorkspace.id,
+        workspaceId,
+      });
+    }
+  }
+}

packages/twenty-server/src/database/commands/upgrade-version-command/0-44/0-44-migrate-relations-to-field-metadata.command.ts

@@ -0,0 +1,139 @@
+import { InjectRepository } from '@nestjs/typeorm';
+
+import chalk from 'chalk';
+import { Command } from 'nest-commander';
+import { FieldMetadataType } from 'twenty-shared';
+import { In, Repository } from 'typeorm';
+
+import { RelationType } from 'src/engine/metadata-modules/field-metadata/interfaces/relation-type.interface';
+
+import {
+  ActiveOrSuspendedWorkspacesMigrationCommandRunner,
+  RunOnWorkspaceArgs,
+} from 'src/database/commands/command-runners/active-or-suspended-workspaces-migration.command-runner';
+import { Workspace } from 'src/engine/core-modules/workspace/workspace.entity';
+import { FieldMetadataEntity } from 'src/engine/metadata-modules/field-metadata/field-metadata.entity';
+import { TwentyORMGlobalManager } from 'src/engine/twenty-orm/twenty-orm-global.manager';
+import {
+  RelationDirection,
+  deduceRelationDirection,
+} from 'src/engine/utils/deduce-relation-direction.util';
+import { isFieldMetadataOfType } from 'src/engine/utils/is-field-metadata-of-type.util';
+
+@Command({
+  name: 'upgrade:0-44:migrate-relations-to-field-metadata',
+  description: 'Migrate relations to field metadata',
+})
+export class MigrateRelationsToFieldMetadataCommand extends ActiveOrSuspendedWorkspacesMigrationCommandRunner {
+  constructor(
+    @InjectRepository(Workspace, 'core')
+    protected readonly workspaceRepository: Repository<Workspace>,
+    @InjectRepository(FieldMetadataEntity, 'metadata')
+    private readonly fieldMetadataRepository: Repository<FieldMetadataEntity>,
+    protected readonly twentyORMGlobalManager: TwentyORMGlobalManager,
+  ) {
+    super(workspaceRepository, twentyORMGlobalManager);
+  }
+
+  override async runOnWorkspace({
+    index,
+    total,
+    workspaceId,
+  }: RunOnWorkspaceArgs): Promise<void> {
+    this.logger.log(
+      `Running command for workspace ${workspaceId} ${index + 1}/${total}`,
+    );
+
+    const fieldMetadataCollection = await this.fieldMetadataRepository.find({
+      where: {
+        workspaceId,
+        type: In([FieldMetadataType.RELATION, FieldMetadataType.UUID]),
+      },
+      relations: ['fromRelationMetadata', 'toRelationMetadata'],
+    });
+
+    if (!fieldMetadataCollection.length) {
+      this.logger.log(
+        chalk.yellow(
+          `No relation field metadata found for workspace ${workspaceId}.`,
+        ),
+      );
+
+      return;
+    }
+
+    const joinColumnFieldMetadataCollection = fieldMetadataCollection.filter(
+      (fieldMetadata) =>
+        isFieldMetadataOfType(fieldMetadata, FieldMetadataType.UUID),
+      // TODO: Fix this, it's working in other places but not here
+    ) as FieldMetadataEntity<FieldMetadataType.UUID>[];
+
+    const fieldMetadataToUpdateCollection = fieldMetadataCollection
+      .filter((fieldMetadata) =>
+        isFieldMetadataOfType(fieldMetadata, FieldMetadataType.RELATION),
+      )
+      .map((fieldMetadata) =>
+        this.updateRelationFieldMetadata(
+          joinColumnFieldMetadataCollection,
+          // TODO: Fix this, it's working in other places but not here
+          fieldMetadata as FieldMetadataEntity<FieldMetadataType.RELATION>,
+        ),
+      );
+
+    if (fieldMetadataToUpdateCollection.length > 0) {
+      await this.fieldMetadataRepository.save(fieldMetadataToUpdateCollection);
+    }
+
+    this.logger.log(
+      chalk.green(`Command completed for workspace ${workspaceId}.`),
+    );
+  }
+
+  private updateRelationFieldMetadata(
+    joinColumnFieldMetadataCollection: FieldMetadataEntity<FieldMetadataType.UUID>[],
+    fieldMetadata: FieldMetadataEntity<FieldMetadataType.RELATION>,
+  ): FieldMetadataEntity<FieldMetadataType.RELATION> {
+    const relationMetadata =
+      fieldMetadata.fromRelationMetadata ?? fieldMetadata.toRelationMetadata;
+    const joinColumnFieldMetadata = joinColumnFieldMetadataCollection.find(
+      (joinColumnFieldMetadata) =>
+        // We're deducing the field based on the name of the relation field
+        // This is not the best way to do this but we don't have a better way
+        joinColumnFieldMetadata.name === `${fieldMetadata.name}Id`,
+    );
+
+    const relationDirection = deduceRelationDirection(
+      fieldMetadata,
+      relationMetadata,
+    );
+    let relationType = relationMetadata.relationType as unknown as RelationType;
+
+    if (
+      relationDirection === RelationDirection.TO &&
+      relationType === RelationType.ONE_TO_MANY
+    ) {
+      relationType = RelationType.MANY_TO_ONE;
+    }
+
+    const relationTargetFieldMetadataId =
+      relationDirection === RelationDirection.FROM
+        ? relationMetadata.toFieldMetadataId
+        : relationMetadata.fromFieldMetadataId;
+
+    const relationTargetObjectMetadataId =
+      relationDirection === RelationDirection.FROM
+        ? relationMetadata.toObjectMetadataId
+        : relationMetadata.fromObjectMetadataId;
+
+    return {
+      ...fieldMetadata,
+      settings: {
+        relationType,
+        onDelete: relationMetadata.onDeleteAction,
+        joinColumnName: joinColumnFieldMetadata?.name,
+      },
+      relationTargetFieldMetadataId,
+      relationTargetObjectMetadataId,
+    };
+  }
+}

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

@@ -0,0 +1,34 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+
+import { InitializePermissionsCommand } from 'src/database/commands/upgrade-version-command/0-44/0-44-initialize-permissions.command';
+import { MigrateRelationsToFieldMetadataCommand } from 'src/database/commands/upgrade-version-command/0-44/0-44-migrate-relations-to-field-metadata.command';
+import { UserWorkspace } from 'src/engine/core-modules/user-workspace/user-workspace.entity';
+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 { RoleModule } from 'src/engine/metadata-modules/role/role.module';
+import { UserRoleModule } from 'src/engine/metadata-modules/user-role/user-role.module';
+import { WorkspaceDataSourceModule } from 'src/engine/workspace-datasource/workspace-datasource.module';
+
+@Module({
+  imports: [
+    TypeOrmModule.forFeature([Workspace, UserWorkspace], 'core'),
+    TypeOrmModule.forFeature(
+      [FieldMetadataEntity, ObjectMetadataEntity],
+      'metadata',
+    ),
+    WorkspaceDataSourceModule,
+    RoleModule,
+    UserRoleModule,
+  ],
+  providers: [
+    InitializePermissionsCommand,
+    MigrateRelationsToFieldMetadataCommand,
+  ],
+  exports: [
+    InitializePermissionsCommand,
+    MigrateRelationsToFieldMetadataCommand,
+  ],
+})
+export class V0_44_UpgradeVersionCommandModule {}

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

@@ -0,0 +1,19 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+
+import { V0_43_UpgradeVersionCommandModule } from 'src/database/commands/upgrade-version-command/0-43/0-43-upgrade-version-command.module';
+import { V0_44_UpgradeVersionCommandModule } from 'src/database/commands/upgrade-version-command/0-44/0-44-upgrade-version-command.module';
+import { UpgradeCommand } from 'src/database/commands/upgrade-version-command/upgrade.command';
+import { Workspace } from 'src/engine/core-modules/workspace/workspace.entity';
+import { WorkspaceSyncMetadataModule } from 'src/engine/workspace-manager/workspace-sync-metadata/workspace-sync-metadata.module';
+
+@Module({
+  imports: [
+    TypeOrmModule.forFeature([Workspace], 'core'),
+    V0_43_UpgradeVersionCommandModule,
+    V0_44_UpgradeVersionCommandModule,
+    WorkspaceSyncMetadataModule,
+  ],
+  providers: [UpgradeCommand],
+})
+export class UpgradeVersionCommandModule {}

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

@@ -0,0 +1,72 @@
+import { InjectRepository } from '@nestjs/typeorm';
+
+import chalk from 'chalk';
+import { Command } from 'nest-commander';
+import { Repository } from 'typeorm';
+
+import {
+  ActiveOrSuspendedWorkspacesMigrationCommandRunner,
+  RunOnWorkspaceArgs,
+} from 'src/database/commands/command-runners/active-or-suspended-workspaces-migration.command-runner';
+import { AddTasksAssignedToMeViewCommand } from 'src/database/commands/upgrade-version-command/0-43/0-43-add-tasks-assigned-to-me-view.command';
+import { MigrateIsSearchableForCustomObjectMetadataCommand } from 'src/database/commands/upgrade-version-command/0-43/0-43-migrate-is-searchable-for-custom-object-metadata.command';
+import { MigrateRichTextContentPatchCommand } from 'src/database/commands/upgrade-version-command/0-43/0-43-migrate-rich-text-content-patch.command';
+import { MigrateSearchVectorOnNoteAndTaskEntitiesCommand } from 'src/database/commands/upgrade-version-command/0-43/0-43-migrate-search-vector-on-note-and-task-entities.command';
+import { UpdateDefaultViewRecordOpeningOnWorkflowObjectsCommand } from 'src/database/commands/upgrade-version-command/0-43/0-43-update-default-view-record-opening-on-workflow-objects.command';
+import { Workspace } from 'src/engine/core-modules/workspace/workspace.entity';
+import { TwentyORMGlobalManager } from 'src/engine/twenty-orm/twenty-orm-global.manager';
+import { SyncWorkspaceMetadataCommand } from 'src/engine/workspace-manager/workspace-sync-metadata/commands/sync-workspace-metadata.command';
+
+@Command({
+  name: 'upgrade',
+  description: 'Upgrade workspaces to the latest version',
+})
+export class UpgradeCommand extends ActiveOrSuspendedWorkspacesMigrationCommandRunner {
+  constructor(
+    @InjectRepository(Workspace, 'core')
+    protected readonly workspaceRepository: Repository<Workspace>,
+    protected readonly twentyORMGlobalManager: TwentyORMGlobalManager,
+    protected readonly migrateRichTextContentPatchCommand: MigrateRichTextContentPatchCommand,
+    protected readonly addTasksAssignedToMeViewCommand: AddTasksAssignedToMeViewCommand,
+    protected readonly migrateIsSearchableForCustomObjectMetadataCommand: MigrateIsSearchableForCustomObjectMetadataCommand,
+    protected readonly updateDefaultViewRecordOpeningOnWorkflowObjectsCommand: UpdateDefaultViewRecordOpeningOnWorkflowObjectsCommand,
+    protected readonly migrateSearchVectorOnNoteAndTaskEntitiesCommand: MigrateSearchVectorOnNoteAndTaskEntitiesCommand,
+    protected readonly syncWorkspaceMetadataCommand: SyncWorkspaceMetadataCommand,
+  ) {
+    super(workspaceRepository, twentyORMGlobalManager);
+  }
+
+  override async runOnWorkspace(args: RunOnWorkspaceArgs): Promise<void> {
+    this.logger.log(
+      chalk.blue(
+        `${args.options.dryRun ? '(dry run)' : ''} Upgrading workspace ${args.workspaceId} ${args.index + 1}/${args.total}`,
+      ),
+    );
+
+    await this.migrateRichTextContentPatchCommand.runOnWorkspace(args);
+
+    await this.migrateIsSearchableForCustomObjectMetadataCommand.runOnWorkspace(
+      args,
+    );
+
+    await this.migrateSearchVectorOnNoteAndTaskEntitiesCommand.runOnWorkspace(
+      args,
+    );
+
+    await this.migrateIsSearchableForCustomObjectMetadataCommand.runOnWorkspace(
+      args,
+    );
+
+    await this.syncWorkspaceMetadataCommand.runOnWorkspace(args);
+
+    await this.updateDefaultViewRecordOpeningOnWorkflowObjectsCommand.runOnWorkspace(
+      args,
+    );
+
+    await this.addTasksAssignedToMeViewCommand.runOnWorkspace(args);
+
+    this.logger.log(
+      chalk.blue(`Upgrade for workspace ${args.workspaceId} completed.`),
+    );
+  }
+}