The open alternative to Salesforce, designed for AI.
TypeScript crmcrm-systemcustomergood-first-issuegraphqlhacktoberfestjavascriptmarketingmonoreponestjsopen-sourcepostgresqlreactreactjssalestypescriptweb
Slow instance commands (#19431)
Paul Rastoin85be46348775
diff --git a/packages/twenty-server/src/database/commands/__tests__/__snapshots__/instance-command-generation.service.spec.ts.snap b/packages/twenty-server/src/database/commands/__tests__/__snapshots__/instance-command-generation.service.spec.ts.snapindex 3203ff7d6c5..b24073cffcb 100644--- a/packages/twenty-server/src/database/commands/__tests__/__snapshots__/instance-command-generation.service.spec.ts.snap+++ b/packages/twenty-server/src/database/commands/__tests__/__snapshots__/instance-command-generation.service.spec.ts.snap@@ -2,14 +2,15 @@exports[`InstanceCommandGenerationService should encode version correctly in file and class names 1`] = `{- "className": "TestCommand",+ "className": "TestFastInstanceCommand","fileName": "1-20-instance-command-fast-1775000000000-test.ts",- "fileTemplate": "import { MigrationInterface, QueryRunner } from 'typeorm';+ "fileTemplate": "import { QueryRunner } from 'typeorm';import { RegisteredInstanceCommand } from 'src/engine/core-modules/upgrade/decorators/registered-instance-command.decorator';+import { FastInstanceCommand } from 'src/engine/core-modules/upgrade/interfaces/fast-instance-command.interface';@RegisteredInstanceCommand('1.20.0', 1775000000000)-export class TestCommand implements MigrationInterface {+export class TestFastInstanceCommand implements FastInstanceCommand {public async up(queryRunner: QueryRunner): Promise<void> {await queryRunner.query('SELECT 1');}@@ -24,14 +25,15 @@ export class TestCommand implements MigrationInterface {exports[`InstanceCommandGenerationService should escape backslashes in SQL queries 1`] = `{- "className": "UpdatePathCommand",+ "className": "UpdatePathFastInstanceCommand","fileName": "1-21-instance-command-fast-1775000000000-update-path.ts",- "fileTemplate": "import { MigrationInterface, QueryRunner } from 'typeorm';+ "fileTemplate": "import { QueryRunner } from 'typeorm';import { RegisteredInstanceCommand } from 'src/engine/core-modules/upgrade/decorators/registered-instance-command.decorator';+import { FastInstanceCommand } from 'src/engine/core-modules/upgrade/interfaces/fast-instance-command.interface';@RegisteredInstanceCommand('1.21.0', 1775000000000)-export class UpdatePathCommand implements MigrationInterface {+export class UpdatePathFastInstanceCommand implements FastInstanceCommand {public async up(queryRunner: QueryRunner): Promise<void> {await queryRunner.query('UPDATE "core"."config" SET "value" = E\\'path\\\\\\\\to\\\\\\\\file\\'');}@@ -46,14 +48,15 @@ export class UpdatePathCommand implements MigrationInterface {exports[`InstanceCommandGenerationService should escape single quotes in SQL queries 1`] = `{- "className": "UpdateConfigCommand",+ "className": "UpdateConfigFastInstanceCommand","fileName": "1-21-instance-command-fast-1775000000000-update-config.ts",- "fileTemplate": "import { MigrationInterface, QueryRunner } from 'typeorm';+ "fileTemplate": "import { QueryRunner } from 'typeorm';import { RegisteredInstanceCommand } from 'src/engine/core-modules/upgrade/decorators/registered-instance-command.decorator';+import { FastInstanceCommand } from 'src/engine/core-modules/upgrade/interfaces/fast-instance-command.interface';@RegisteredInstanceCommand('1.21.0', 1775000000000)-export class UpdateConfigCommand implements MigrationInterface {+export class UpdateConfigFastInstanceCommand implements FastInstanceCommand {public async up(queryRunner: QueryRunner): Promise<void> {await queryRunner.query('UPDATE "core"."config" SET "value" = \\'it\\'\\'s done\\'');}@@ -68,14 +71,15 @@ export class UpdateConfigCommand implements MigrationInterface {exports[`InstanceCommandGenerationService should generate a migration with a single up/down query 1`] = `{- "className": "AddFooColumnCommand",+ "className": "AddFooColumnFastInstanceCommand","fileName": "1-21-instance-command-fast-1775000000000-add-foo-column.ts",- "fileTemplate": "import { MigrationInterface, QueryRunner } from 'typeorm';+ "fileTemplate": "import { QueryRunner } from 'typeorm';import { RegisteredInstanceCommand } from 'src/engine/core-modules/upgrade/decorators/registered-instance-command.decorator';+import { FastInstanceCommand } from 'src/engine/core-modules/upgrade/interfaces/fast-instance-command.interface';@RegisteredInstanceCommand('1.21.0', 1775000000000)-export class AddFooColumnCommand implements MigrationInterface {+export class AddFooColumnFastInstanceCommand implements FastInstanceCommand {public async up(queryRunner: QueryRunner): Promise<void> {await queryRunner.query('ALTER TABLE "core"."user" ADD "foo" varchar');}@@ -90,14 +94,15 @@ export class AddFooColumnCommand implements MigrationInterface {exports[`InstanceCommandGenerationService should generate a migration with multiple queries 1`] = `{- "className": "CreateTaskTableCommand",+ "className": "CreateTaskTableFastInstanceCommand","fileName": "1-21-instance-command-fast-1775000000000-create-task-table.ts",- "fileTemplate": "import { MigrationInterface, QueryRunner } from 'typeorm';+ "fileTemplate": "import { QueryRunner } from 'typeorm';import { RegisteredInstanceCommand } from 'src/engine/core-modules/upgrade/decorators/registered-instance-command.decorator';+import { FastInstanceCommand } from 'src/engine/core-modules/upgrade/interfaces/fast-instance-command.interface';@RegisteredInstanceCommand('1.21.0', 1775000000000)-export class CreateTaskTableCommand implements MigrationInterface {+export class CreateTaskTableFastInstanceCommand implements FastInstanceCommand {public async up(queryRunner: QueryRunner): Promise<void> {await queryRunner.query('CREATE TABLE "core"."task" ("id" uuid NOT NULL DEFAULT uuid_generate_v4(), "name" varchar NOT NULL)');await queryRunner.query('ALTER TABLE "core"."task" ADD CONSTRAINT "PK_task" PRIMARY KEY ("id")');@@ -114,14 +119,15 @@ export class CreateTaskTableCommand implements MigrationInterface {exports[`InstanceCommandGenerationService should generate a migration with query parameters 1`] = `{- "className": "SeedSettingCommand",+ "className": "SeedSettingFastInstanceCommand","fileName": "1-21-instance-command-fast-1775000000000-seed-setting.ts",- "fileTemplate": "import { MigrationInterface, QueryRunner } from 'typeorm';+ "fileTemplate": "import { QueryRunner } from 'typeorm';import { RegisteredInstanceCommand } from 'src/engine/core-modules/upgrade/decorators/registered-instance-command.decorator';+import { FastInstanceCommand } from 'src/engine/core-modules/upgrade/interfaces/fast-instance-command.interface';@RegisteredInstanceCommand('1.21.0', 1775000000000)-export class SeedSettingCommand implements MigrationInterface {+export class SeedSettingFastInstanceCommand implements FastInstanceCommand {public async up(queryRunner: QueryRunner): Promise<void> {await queryRunner.query('INSERT INTO "core"."setting" ("key", "value") VALUES ($1, $2)', ["theme","dark"]);}@@ -134,16 +140,44 @@ export class SeedSettingCommand implements MigrationInterface {}`;+exports[`InstanceCommandGenerationService should generate a slow instance command with populated up/down 1`] = `+{+ "className": "MakeColumnNotNullableSlowInstanceCommand",+ "fileName": "1-21-instance-command-slow-1775000000000-make-column-not-nullable.ts",+ "fileTemplate": "import { DataSource, QueryRunner } from 'typeorm';++import { RegisteredInstanceCommand } from 'src/engine/core-modules/upgrade/decorators/registered-instance-command.decorator';+import { SlowInstanceCommand } from 'src/engine/core-modules/upgrade/interfaces/slow-instance-command.interface';++@RegisteredInstanceCommand('1.21.0', 1775000000000, { type: 'slow' })+export class MakeColumnNotNullableSlowInstanceCommand implements SlowInstanceCommand {+ async runDataMigration(dataSource: DataSource): Promise<void> {+ // TODO: implement data backfill before the DDL migration+ }++ public async up(queryRunner: QueryRunner): Promise<void> {+ await queryRunner.query('ALTER TABLE "core"."user" ALTER COLUMN "email" SET NOT NULL');+ }++ public async down(queryRunner: QueryRunner): Promise<void> {+ await queryRunner.query('ALTER TABLE "core"."user" ALTER COLUMN "email" DROP NOT NULL');+ }+}+",+}+`;+exports[`InstanceCommandGenerationService should use default migration name in class and file names 1`] = `{- "className": "AutoGeneratedCommand",+ "className": "AutoGeneratedFastInstanceCommand","fileName": "1-21-instance-command-fast-1775000000000-auto-generated.ts",- "fileTemplate": "import { MigrationInterface, QueryRunner } from 'typeorm';+ "fileTemplate": "import { QueryRunner } from 'typeorm';import { RegisteredInstanceCommand } from 'src/engine/core-modules/upgrade/decorators/registered-instance-command.decorator';+import { FastInstanceCommand } from 'src/engine/core-modules/upgrade/interfaces/fast-instance-command.interface';@RegisteredInstanceCommand('1.21.0', 1775000000000)-export class AutoGeneratedCommand implements MigrationInterface {+export class AutoGeneratedFastInstanceCommand implements FastInstanceCommand {public async up(queryRunner: QueryRunner): Promise<void> {await queryRunner.query('ALTER TABLE "core"."user" ADD "bar" integer');}diff --git a/packages/twenty-server/src/database/commands/__tests__/instance-command-generation.service.spec.ts b/packages/twenty-server/src/database/commands/__tests__/instance-command-generation.service.spec.tsindex 1f09ce246f3..c9e0fe54f07 100644--- a/packages/twenty-server/src/database/commands/__tests__/instance-command-generation.service.spec.ts+++ b/packages/twenty-server/src/database/commands/__tests__/instance-command-generation.service.spec.ts@@ -37,7 +37,7 @@ describe('InstanceCommandGenerationService', () => {it('should return null when no schema changes are detected', async () => {const service = await buildService();- const result = await service.generate({+ const result = await service.generateInstanceCommand({migrationName: 'no-changes',version: '1.21.0',timestamp: FIXED_TIMESTAMP,@@ -52,7 +52,7 @@ describe('InstanceCommandGenerationService', () => {[{ query: 'ALTER TABLE "core"."user" DROP COLUMN "foo"' }],);- const result = await service.generate({+ const result = await service.generateInstanceCommand({migrationName: 'add-foo-column',version: '1.21.0',timestamp: FIXED_TIMESTAMP,@@ -79,7 +79,7 @@ describe('InstanceCommandGenerationService', () => {],);- const result = await service.generate({+ const result = await service.generateInstanceCommand({migrationName: 'create-task-table',version: '1.21.0',timestamp: FIXED_TIMESTAMP,@@ -105,7 +105,7 @@ describe('InstanceCommandGenerationService', () => {],);- const result = await service.generate({+ const result = await service.generateInstanceCommand({migrationName: 'seed-setting',version: '1.21.0',timestamp: FIXED_TIMESTAMP,@@ -120,7 +120,7 @@ describe('InstanceCommandGenerationService', () => {[{ query: 'UPDATE "core"."config" SET "value" = \'original\'' }],);- const result = await service.generate({+ const result = await service.generateInstanceCommand({migrationName: 'update-config',version: '1.21.0',timestamp: FIXED_TIMESTAMP,@@ -139,7 +139,7 @@ describe('InstanceCommandGenerationService', () => {[{ query: 'UPDATE "core"."config" SET "value" = NULL' }],);- const result = await service.generate({+ const result = await service.generateInstanceCommand({migrationName: 'update-path',version: '1.21.0',timestamp: FIXED_TIMESTAMP,@@ -154,7 +154,7 @@ describe('InstanceCommandGenerationService', () => {[{ query: 'ALTER TABLE "core"."user" DROP COLUMN "bar"' }],);- const result = await service.generate({+ const result = await service.generateInstanceCommand({migrationName: 'auto-generated',version: '1.21.0',timestamp: FIXED_TIMESTAMP,@@ -169,7 +169,7 @@ describe('InstanceCommandGenerationService', () => {[{ query: 'SELECT 1' }],);- const result = await service.generate({+ const result = await service.generateInstanceCommand({migrationName: 'test',version: '1.20.0',timestamp: FIXED_TIMESTAMP,@@ -177,4 +177,60 @@ describe('InstanceCommandGenerationService', () => {expect(result).toMatchSnapshot();});++ it('should return null for slow type when no schema changes are detected', async () => {+ const service = await buildService();++ const result = await service.generateInstanceCommand({+ migrationName: 'no-changes',+ version: '1.21.0',+ timestamp: FIXED_TIMESTAMP,+ type: 'slow',+ });++ expect(result).toBeNull();+ });++ it('should generate a slow instance command with populated up/down', async () => {+ const service = await buildService(+ [+ {+ query: 'ALTER TABLE "core"."user" ALTER COLUMN "email" SET NOT NULL',+ },+ ],+ [+ {+ query: 'ALTER TABLE "core"."user" ALTER COLUMN "email" DROP NOT NULL',+ },+ ],+ );++ const result = await service.generateInstanceCommand({+ migrationName: 'make-column-not-nullable',+ version: '1.21.0',+ timestamp: FIXED_TIMESTAMP,+ type: 'slow',+ });++ expect(result).toMatchSnapshot();+ });++ it('should use correct file naming for slow instance commands', async () => {+ const service = await buildService(+ [{ query: 'SELECT 1' }],+ [{ query: 'SELECT 1' }],+ );++ const result = await service.generateInstanceCommand({+ migrationName: 'backfill-data',+ version: '1.20.0',+ timestamp: FIXED_TIMESTAMP,+ type: 'slow',+ });++ expect(result?.fileName).toBe(+ '1-20-instance-command-slow-1775000000000-backfill-data.ts',+ );+ expect(result?.className).toBe('BackfillDataSlowInstanceCommand');+ });});diff --git a/packages/twenty-server/src/database/commands/generate-instance-command.command.ts b/packages/twenty-server/src/database/commands/generate-instance-command.command.tsindex 9a254ff88b8..adac4c1e22d 100644--- a/packages/twenty-server/src/database/commands/generate-instance-command.command.ts+++ b/packages/twenty-server/src/database/commands/generate-instance-command.command.ts@@ -7,6 +7,7 @@ import { Command, CommandRunner, Option } from 'nest-commander';import { InstanceCommandGenerationService } from 'src/database/commands/instance-command-generation.service';import { UPGRADE_COMMAND_SUPPORTED_VERSIONS } from 'src/engine/constants/upgrade-command-supported-versions.constant';+import { type InstanceCommandType } from 'src/engine/core-modules/upgrade/decorators/registered-instance-command.decorator';const UPGRADE_VERSION_COMMAND_DIR = path.resolve(process.cwd(),@@ -15,6 +16,7 @@ const UPGRADE_VERSION_COMMAND_DIR = path.resolve(type GenerateInstanceCommandOptions = {name: string;+ type: InstanceCommandType;};@Command({@@ -40,6 +42,20 @@ export class GenerateInstanceCommandCommand extends CommandRunner {return value;}+ @Option({+ flags: '-t, --type <type>',+ description:+ 'Command type: fast (schema diff) or slow (data migration + DDL)',+ defaultValue: 'fast',+ })+ parseType(value: string): InstanceCommandType {+ if (value !== 'fast' && value !== 'slow') {+ throw new Error(`Invalid type "${value}". Must be "fast" or "slow".`);+ }++ return value;+ }+async run(_passedParams: string[],options: GenerateInstanceCommandOptions,@@ -52,16 +68,22 @@ export class GenerateInstanceCommandCommand extends CommandRunner {throw new Error('No supported versions found');}- this.logger.log(`Generating versioned migration for version ${version}...`);+ const commandType = options.type;++ this.logger.log(+ `Generating ${commandType} instance command for version ${version}...`,+ );const versionDir = this.getVersionDir(version);const timestamp = Date.now();- const result = await this.instanceMigrationGenerationService.generate({- migrationName,- version,- timestamp,- });+ const result =+ await this.instanceMigrationGenerationService.generateInstanceCommand({+ migrationName,+ version,+ timestamp,+ type: commandType,+ });if (!result) {this.logger.warn(@@ -71,11 +93,13 @@ export class GenerateInstanceCommandCommand extends CommandRunner {return;}- const migrationFilePath = path.join(versionDir, result.fileName);+ const filePath = path.join(versionDir, result.fileName);- fs.writeFileSync(migrationFilePath, result.fileTemplate);+ fs.writeFileSync(filePath, result.fileTemplate);- this.logger.log(`Migration generated successfully: ${migrationFilePath}`);+ this.logger.log(+ `${commandType} instance command generated successfully: ${filePath}`,+ );this.logger.log(` Class: ${result.className}`);this.logger.log(` Version: ${version}`);diff --git a/packages/twenty-server/src/database/commands/instance-command-generation.service.ts b/packages/twenty-server/src/database/commands/instance-command-generation.service.tsindex c4b3d32d26f..a7cc58f21e0 100644--- a/packages/twenty-server/src/database/commands/instance-command-generation.service.ts+++ b/packages/twenty-server/src/database/commands/instance-command-generation.service.ts@@ -5,11 +5,13 @@ import { pascalCase } from 'twenty-shared/utils';import { DataSource } from 'typeorm';import { type UpgradeCommandVersion } from 'src/engine/constants/upgrade-command-supported-versions.constant';+import { type InstanceCommandType } from 'src/engine/core-modules/upgrade/decorators/registered-instance-command.decorator';-type GenerateMigrationArgs = {+type GenerateInstanceCommandArgs = {migrationName: string;version: UpgradeCommandVersion;timestamp: number;+ type?: InstanceCommandType;};export type GeneratedMigrationResult = {@@ -25,11 +27,12 @@ export class InstanceCommandGenerationService {private readonly dataSource: DataSource,) {}- async generate({+ async generateInstanceCommand({migrationName,version,timestamp,- }: GenerateMigrationArgs): Promise<GeneratedMigrationResult | null> {+ type = 'fast',+ }: GenerateInstanceCommandArgs): Promise<GeneratedMigrationResult | null> {const sqlInMemory = await this.dataSource.driver.createSchemaBuilder().log();@@ -38,7 +41,7 @@ export class InstanceCommandGenerationService {return null;}- const className = this.buildClassName(migrationName);+ const className = this.buildClassName({ name: migrationName, type });const upStatements = sqlInMemory.upQueries.map(({ query, parameters }) =>@@ -52,22 +55,37 @@ export class InstanceCommandGenerationService {` await queryRunner.query('${this.escapeForSingleQuotedString(query)}'${this.formatQueryParams(parameters)});`,);- const fileTemplate = this.buildMigrationFileContent({- className,- version,- timestamp,- upStatements,- downStatements,- });+ const fileTemplate =+ type === 'slow'+ ? this.buildSlowMigrationFileContent({+ className,+ version,+ timestamp,+ upStatements,+ downStatements,+ })+ : this.buildFastMigrationFileContent({+ className,+ version,+ timestamp,+ upStatements,+ downStatements,+ });const versionSlug = version.split('.').slice(0, 2).join('-');- const fileName = `${versionSlug}-instance-command-fast-${timestamp}-${migrationName}.ts`;+ const fileName = `${versionSlug}-instance-command-${type}-${timestamp}-${migrationName}.ts`;return { fileName, fileTemplate, className };}- private buildClassName(name: string): string {- return `${pascalCase(name)}Command`;+ private buildClassName({+ name,+ type,+ }: {+ name: string;+ type: InstanceCommandType;+ }): string {+ return `${pascalCase(name)}${pascalCase(type)}InstanceCommand`;}private formatQueryParams(parameters: unknown[] | undefined): string {@@ -82,7 +100,7 @@ export class InstanceCommandGenerationService {return query.replace(/\\/g, '\\\\').replace(/'/g, "\\'");}- private buildMigrationFileContent({+ private buildFastMigrationFileContent({className,version,timestamp,@@ -95,12 +113,48 @@ export class InstanceCommandGenerationService {upStatements: string[];downStatements: string[];}): string {- return `import { MigrationInterface, QueryRunner } from 'typeorm';+ return `import { QueryRunner } from 'typeorm';import { RegisteredInstanceCommand } from 'src/engine/core-modules/upgrade/decorators/registered-instance-command.decorator';+import { FastInstanceCommand } from 'src/engine/core-modules/upgrade/interfaces/fast-instance-command.interface';@RegisteredInstanceCommand('${version}', ${timestamp})-export class ${className} implements MigrationInterface {+export class ${className} implements FastInstanceCommand {+ public async up(queryRunner: QueryRunner): Promise<void> {+${upStatements.join('\n')}+ }++ public async down(queryRunner: QueryRunner): Promise<void> {+${downStatements.join('\n')}+ }+}+`;+ }++ private buildSlowMigrationFileContent({+ className,+ version,+ timestamp,+ upStatements,+ downStatements,+ }: {+ className: string;+ version: string;+ timestamp: number;+ upStatements: string[];+ downStatements: string[];+ }): string {+ return `import { DataSource, QueryRunner } from 'typeorm';++import { RegisteredInstanceCommand } from 'src/engine/core-modules/upgrade/decorators/registered-instance-command.decorator';+import { SlowInstanceCommand } from 'src/engine/core-modules/upgrade/interfaces/slow-instance-command.interface';++@RegisteredInstanceCommand('${version}', ${timestamp}, { type: 'slow' })+export class ${className} implements SlowInstanceCommand {+ async runDataMigration(dataSource: DataSource): Promise<void> {+ // TODO: implement data backfill before the DDL migration+ }+public async up(queryRunner: QueryRunner): Promise<void> {${upStatements.join('\n')}}diff --git a/packages/twenty-server/src/database/commands/run-instance-commands.command.ts b/packages/twenty-server/src/database/commands/run-instance-commands.command.tsindex 3334cefc004..a6ff960656b 100644--- a/packages/twenty-server/src/database/commands/run-instance-commands.command.ts+++ b/packages/twenty-server/src/database/commands/run-instance-commands.command.ts@@ -3,7 +3,6 @@ import { InjectDataSource } from '@nestjs/typeorm';import chalk from 'chalk';import { Command, CommandRunner, Option } from 'nest-commander';-import { isDefined } from 'twenty-shared/utils';import { DataSource } from 'typeorm';import { CoreEngineVersionService } from 'src/engine/core-engine-version/services/core-engine-version.service';@@ -13,6 +12,7 @@ import { WorkspaceVersionService } from 'src/engine/workspace-manager/workspace-type RunInstanceCommandsOptions = {force?: boolean;+ includeSlow?: boolean;};@Command({@@ -43,6 +43,15 @@ export class RunInstanceCommandsCommand extends CommandRunner {return true;}+ @Option({+ flags: '--include-slow',+ description: 'Also run slow instance commands (data migration + DDL)',+ required: false,+ })+ parseIncludeSlow(): boolean {+ return true;+ }+async run(_passedParams: string[],options: RunInstanceCommandsOptions,@@ -50,7 +59,43 @@ export class RunInstanceCommandsCommand extends CommandRunner {try {await this.checkWorkspaceVersionSafety(options);await this.runLegacyPendingTypeOrmMigrations();- await this.runAllInstanceCommands();++ for (const {+ command,+ name,+ } of this.upgradeCommandRegistryService.getAllFastInstanceCommands()) {+ const result = await this.instanceUpgradeService.runFastInstanceCommand(+ {+ command,+ name,+ },+ );++ if (result.status === 'failed') {+ throw result.error;+ }+ }++ if (options.includeSlow) {+ const hasWorkspaces =+ await this.workspaceVersionService.hasActiveOrSuspendedWorkspaces();++ for (const {+ command,+ name,+ } of this.upgradeCommandRegistryService.getAllSlowInstanceCommands()) {+ const result =+ await this.instanceUpgradeService.runSlowInstanceCommand({+ command,+ name,+ skipDataMigration: !hasWorkspaces,+ });++ if (result.status === 'failed') {+ throw result.error;+ }+ }+ }this.logger.log(chalk.green('Instance commands completed'));} catch (error) {@@ -77,61 +122,6 @@ export class RunInstanceCommandsCommand extends CommandRunner {}}- private async runAllInstanceCommands(): Promise<void> {- const allInstanceCommands =- this.upgradeCommandRegistryService.getAllInstanceCommands();-- if (allInstanceCommands.length === 0) {- this.logger.log('No registered instance commands');-- return;- }-- this.logger.log(- `Running ${allInstanceCommands.length} instance command(s) across all versions...`,- );-- for (const { version, migration } of allInstanceCommands) {- const migrationName = migration.constructor.name;- const result =- await this.instanceUpgradeService.runSingleMigration(migration);-- switch (result.status) {- case 'already-executed': {- this.logger.log(- `Instance command ${migrationName} (${version}) already executed, skipping`,- );-- break;- }- case 'failed': {- this.logger.error(- `Instance command ${migrationName} (${version}) failed`,- );-- if (isDefined(result.error)) {- this.logger.error(- result.error instanceof Error- ? (result.error.stack ?? result.error.message)- : String(result.error),- );- }-- throw new Error(- `Instance command ${migrationName} (${version}) failed`,- );- }- case 'success': {- this.logger.log(- `Instance command ${migrationName} (${version}) executed successfully`,- );-- break;- }- }- }- }-private async checkWorkspaceVersionSafety(options: RunInstanceCommandsOptions,): Promise<void> {diff --git a/packages/twenty-server/src/database/commands/upgrade-version-command/__tests__/upgrade.command.spec.ts b/packages/twenty-server/src/database/commands/upgrade-version-command/__tests__/upgrade.command.spec.tsindex 600a7eabf95..e1d1714db64 100644--- a/packages/twenty-server/src/database/commands/upgrade-version-command/__tests__/upgrade.command.spec.ts+++ b/packages/twenty-server/src/database/commands/upgrade-version-command/__tests__/upgrade.command.spec.ts@@ -3,11 +3,10 @@ import {eachTestingContextFilter,type EachTestingContext,} from 'twenty-shared/testing';-import {- type DataSource,- type MigrationInterface,- type QueryRunner,-} from 'typeorm';+import { type DataSource, type QueryRunner } from 'typeorm';++import { type FastInstanceCommand } from 'src/engine/core-modules/upgrade/interfaces/fast-instance-command.interface';+import { type SlowInstanceCommand } from 'src/engine/core-modules/upgrade/interfaces/slow-instance-command.interface';import { getDataSourceToken } from '@nestjs/typeorm';@@ -61,7 +60,7 @@ type BuildUpgradeCommandModuleArgs = {workspaces: WorkspaceEntity[];appVersion: string | null;commandRunner: CommandRunnerValues;- migrations?: MigrationInterface[];+ migrations?: FastInstanceCommand[];};const buildUpgradeCommandModule = async ({workspaces,@@ -92,8 +91,11 @@ const buildUpgradeCommandModule = async ({: {provide: UpgradeCommandRegistryService,useValue: {- getInstanceCommandsForVersion: jest.fn().mockReturnValue([]),- getWorkspaceCommandsForVersion: jest.fn().mockReturnValue([]),+ getBundleForVersion: jest.fn().mockReturnValue({+ fastInstanceCommands: [],+ slowInstanceCommands: [],+ workspaceCommands: [],+ }),},};@@ -184,7 +186,10 @@ const buildUpgradeCommandModule = async ({{provide: InstanceUpgradeService,useValue: {- runSingleMigration: jest+ runFastInstanceCommand: jest+ .fn()+ .mockResolvedValue({ status: 'success' }),+ runSlowInstanceCommand: jest.fn().mockResolvedValue({ status: 'success' }),},@@ -242,7 +247,7 @@ describe('UpgradeCommandRunner', () => {workspaces?: WorkspaceEntity[];appVersion?: string | null;commandRunner?: CommandRunnerValues;- migrations?: MigrationInterface[];+ migrations?: FastInstanceCommand[];};const buildModuleAndSetupSpies = async ({numberOfWorkspace = 1,@@ -365,26 +370,26 @@ describe('UpgradeCommandRunner', () => {);});- it('should call runSingleMigration for each current-version instance command', async () => {+ it('should call runFastInstanceCommand for each current-version instance command', async () => {@RegisteredInstanceCommand(CURRENT_VERSION, 1770000000000)- class AddIndexToUsers1770000000000 implements MigrationInterface {+ class AddIndexToUsers1770000000000 implements FastInstanceCommand {async up(_queryRunner: QueryRunner) {}async down(_queryRunner: QueryRunner) {}}@RegisteredInstanceCommand(CURRENT_VERSION, 1771000000000)- class AddColumnToAccounts1771000000000 implements MigrationInterface {+ class AddColumnToAccounts1771000000000 implements FastInstanceCommand {async up(_queryRunner: QueryRunner) {}async down(_queryRunner: QueryRunner) {}}@RegisteredInstanceCommand(PREVIOUS_VERSION, 1769000000000)- class DropLegacyTable1769000000000 implements MigrationInterface {+ class DropLegacyTable1769000000000 implements FastInstanceCommand {async up(_queryRunner: QueryRunner) {}async down(_queryRunner: QueryRunner) {}}- class UndecoratedMigration1768000000000 implements MigrationInterface {+ class UndecoratedMigration1768000000000 implements FastInstanceCommand {async up(_queryRunner: QueryRunner) {}async down(_queryRunner: QueryRunner) {}}@@ -400,105 +405,46 @@ describe('UpgradeCommandRunner', () => {const instanceUpgradeService = module.get(InstanceUpgradeService);- const passedParams: string[] = [];- const options: UpgradeCommandOptions = {};-- await upgradeCommandRunner.run(passedParams, options);+ await upgradeCommandRunner.run([], {});- expect(instanceUpgradeService.runSingleMigration).toHaveBeenCalledTimes(2);- expect(instanceUpgradeService.runSingleMigration).toHaveBeenNthCalledWith(- 1,- addIndex,- );- expect(instanceUpgradeService.runSingleMigration).toHaveBeenNthCalledWith(+ expect(instanceUpgradeService.runFastInstanceCommand).toHaveBeenCalledTimes(2,- addColumn,);- });-- it('should skip already-executed instance commands', async () => {- @RegisteredInstanceCommand(CURRENT_VERSION, 1770000000000)- class AlreadyRunMigration1770000000000 implements MigrationInterface {- async up(_queryRunner: QueryRunner) {}- async down(_queryRunner: QueryRunner) {}- }-- const alreadyRun = new AlreadyRunMigration1770000000000();-- const module = await buildModuleAndSetupSpies({- migrations: [alreadyRun],+ expect(+ instanceUpgradeService.runFastInstanceCommand,+ ).toHaveBeenNthCalledWith(1, {+ command: addIndex,+ name: `${CURRENT_VERSION}_AddIndexToUsers1770000000000_1770000000000`,});-- const instanceUpgradeService = module.get(InstanceUpgradeService);-- (instanceUpgradeService.runSingleMigration as jest.Mock).mockResolvedValue({- status: 'already-executed',+ expect(+ instanceUpgradeService.runFastInstanceCommand,+ ).toHaveBeenNthCalledWith(2, {+ command: addColumn,+ name: `${CURRENT_VERSION}_AddColumnToAccounts1771000000000_1771000000000`,});-- const passedParams: string[] = [];- const options: UpgradeCommandOptions = {};-- await upgradeCommandRunner.run(passedParams, options);-- expect(upgradeCommandRunner['logger'].warn).toHaveBeenCalledWith(- expect.stringContaining('already executed'),- );});- it('should throw when a migration fails', async () => {+ it('should propagate errors from runFastInstanceCommand', async () => {@RegisteredInstanceCommand(CURRENT_VERSION, 1770000000000)- class FailingMigration1770000000000 implements MigrationInterface {+ class FailingMigration1770000000000 implements FastInstanceCommand {async up(_queryRunner: QueryRunner) {}async down(_queryRunner: QueryRunner) {}}- const failing = new FailingMigration1770000000000();-const module = await buildModuleAndSetupSpies({- migrations: [failing],+ migrations: [new FailingMigration1770000000000()],});const instanceUpgradeService = module.get(InstanceUpgradeService);- (instanceUpgradeService.runSingleMigration as jest.Mock).mockResolvedValue({+ (+ instanceUpgradeService.runFastInstanceCommand as jest.Mock+ ).mockResolvedValue({status: 'failed',error: new Error('SQL error'),});- const passedParams: string[] = [];- const options: UpgradeCommandOptions = {};-- await expect(- upgradeCommandRunner.run(passedParams, options),- ).rejects.toThrow('Core migration FailingMigration1770000000000 failed');- });-- it('should log success when a migration succeeds', async () => {- @RegisteredInstanceCommand(CURRENT_VERSION, 1770000000000)- class SuccessMigration1770000000000 implements MigrationInterface {- async up(_queryRunner: QueryRunner) {}- async down(_queryRunner: QueryRunner) {}- }-- const success = new SuccessMigration1770000000000();-- const module = await buildModuleAndSetupSpies({- migrations: [success],- });-- const instanceUpgradeService = module.get(InstanceUpgradeService);-- const passedParams: string[] = [];- const options: UpgradeCommandOptions = {};-- await upgradeCommandRunner.run(passedParams, options);-- expect(instanceUpgradeService.runSingleMigration).toHaveBeenCalledWith(- success,- );- expect(upgradeCommandRunner['logger'].log).toHaveBeenCalledWith(- expect.stringContaining('executed successfully'),- );+ await expect(upgradeCommandRunner.run([], {})).rejects.toThrow('SQL error');});describe('Workspace upgrade should fail', () => {@@ -565,4 +511,146 @@ describe('UpgradeCommandRunner', () => {},);});++ it('should call runSlowInstanceCommand for each current-version slow command', async () => {+ @RegisteredInstanceCommand(CURRENT_VERSION, 1780000000000, {+ type: 'slow',+ })+ class SlowMigration1780000000000 implements SlowInstanceCommand {+ async runDataMigration(_dataSource: DataSource): Promise<void> {}+ async up(_queryRunner: QueryRunner) {}+ async down(_queryRunner: QueryRunner) {}+ }++ const slowMigration = new SlowMigration1780000000000();++ const module = await buildModuleAndSetupSpies({+ migrations: [slowMigration],+ });++ const instanceUpgradeService = module.get(InstanceUpgradeService);++ await upgradeCommandRunner.run([], {});++ expect(instanceUpgradeService.runSlowInstanceCommand).toHaveBeenCalledTimes(+ 1,+ );+ expect(instanceUpgradeService.runSlowInstanceCommand).toHaveBeenCalledWith({+ command: slowMigration,+ name: `${CURRENT_VERSION}_SlowMigration1780000000000_1780000000000`,+ skipDataMigration: false,+ });+ });++ it('should run slow commands after fast commands but before workspace commands', async () => {+ const executionOrder: string[] = [];++ @RegisteredInstanceCommand(CURRENT_VERSION, 1770000000000)+ class FastMigration1770000000000 implements FastInstanceCommand {+ async up(_queryRunner: QueryRunner) {}+ async down(_queryRunner: QueryRunner) {}+ }++ @RegisteredInstanceCommand(CURRENT_VERSION, 1780000000000, {+ type: 'slow',+ })+ class SlowMigration1780000000000 implements SlowInstanceCommand {+ async runDataMigration(_dataSource: DataSource): Promise<void> {}+ async up(_queryRunner: QueryRunner) {}+ async down(_queryRunner: QueryRunner) {}+ }++ const module = await buildModuleAndSetupSpies({+ migrations: [+ new FastMigration1770000000000(),+ new SlowMigration1780000000000(),+ ],+ });++ const instanceUpgradeService = module.get(InstanceUpgradeService);++ (+ instanceUpgradeService.runFastInstanceCommand as jest.Mock+ ).mockImplementation(async () => {+ executionOrder.push('fast');++ return { status: 'success' };+ });++ (+ instanceUpgradeService.runSlowInstanceCommand as jest.Mock+ ).mockImplementation(async () => {+ executionOrder.push('slow');++ return { status: 'success' };+ });++ const workspaceIteratorService = module.get(WorkspaceIteratorService);++ (workspaceIteratorService.iterate as jest.Mock).mockImplementation(+ async () => {+ executionOrder.push('workspace');++ return { success: [], fail: [] };+ },+ );++ await upgradeCommandRunner.run([], {});++ expect(executionOrder).toStrictEqual(['fast', 'slow', 'workspace']);+ });++ it('should pass skipDataMigration: true on fresh install (no workspaces)', async () => {+ @RegisteredInstanceCommand(CURRENT_VERSION, 1780000000000, {+ type: 'slow',+ })+ class SlowMigrationFreshInstall implements SlowInstanceCommand {+ async runDataMigration(_dataSource: DataSource): Promise<void> {}+ async up(_queryRunner: QueryRunner) {}+ async down(_queryRunner: QueryRunner) {}+ }++ const module = await buildModuleAndSetupSpies({+ numberOfWorkspace: 0,+ migrations: [new SlowMigrationFreshInstall()],+ });++ const instanceUpgradeService = module.get(InstanceUpgradeService);++ await upgradeCommandRunner.run([], {});++ expect(instanceUpgradeService.runSlowInstanceCommand).toHaveBeenCalledWith({+ command: expect.any(SlowMigrationFreshInstall),+ name: `${CURRENT_VERSION}_SlowMigrationFreshInstall_1780000000000`,+ skipDataMigration: true,+ });+ });++ it('should propagate errors from runSlowInstanceCommand', async () => {+ @RegisteredInstanceCommand(CURRENT_VERSION, 1780000000000, {+ type: 'slow',+ })+ class FailingSlowMigration implements SlowInstanceCommand {+ async runDataMigration(_dataSource: DataSource): Promise<void> {}+ async up(_queryRunner: QueryRunner) {}+ async down(_queryRunner: QueryRunner) {}+ }++ const module = await buildModuleAndSetupSpies({+ migrations: [new FailingSlowMigration()],+ });++ const instanceUpgradeService = module.get(InstanceUpgradeService);++ (+ instanceUpgradeService.runSlowInstanceCommand as jest.Mock+ ).mockResolvedValue({+ status: 'failed',+ error: new Error('Data migration error'),+ });++ await expect(upgradeCommandRunner.run([], {})).rejects.toThrow(+ 'Data migration error',+ );+ });});diff --git a/packages/twenty-server/src/database/commands/upgrade-version-command/upgrade.command.ts b/packages/twenty-server/src/database/commands/upgrade-version-command/upgrade.command.tsindex 0215e223c00..dc38627c909 100644--- a/packages/twenty-server/src/database/commands/upgrade-version-command/upgrade.command.ts+++ b/packages/twenty-server/src/database/commands/upgrade-version-command/upgrade.command.ts@@ -3,8 +3,7 @@ import { InjectDataSource } from '@nestjs/typeorm';import chalk from 'chalk';import { Command, CommandRunner, Option } from 'nest-commander';import { SemVer } from 'semver';-import { assertUnreachable, isDefined } from 'twenty-shared/utils';-import { DataSource, MigrationInterface } from 'typeorm';+import { DataSource } from 'typeorm';import { ActiveOrSuspendedWorkspaceCommandRunner } from 'src/database/commands/command-runners/active-or-suspended-workspace.command-runner';import { WorkspaceIteratorService } from 'src/database/commands/command-runners/workspace-iterator.service';@@ -13,7 +12,10 @@ import { CommandLogger } from 'src/database/commands/logger';import { type UpgradeCommandVersion } from 'src/engine/constants/upgrade-command-supported-versions.constant';import { CoreEngineVersionService } from 'src/engine/core-engine-version/services/core-engine-version.service';import { InstanceUpgradeService } from 'src/engine/core-modules/upgrade/services/instance-upgrade.service';-import { UpgradeCommandRegistryService } from 'src/engine/core-modules/upgrade/services/upgrade-command-registry.service';+import {+ UpgradeCommandRegistryService,+ type VersionBundle,+} from 'src/engine/core-modules/upgrade/services/upgrade-command-registry.service';import { WorkspaceUpgradeService } from 'src/engine/core-modules/upgrade/services/workspace-upgrade.service';import { WorkspaceVersionService } from 'src/engine/workspace-manager/workspace-version/services/workspace-version.service';@@ -30,12 +32,10 @@ export type UpgradeCommandOptions = {verbose?: boolean;};-type VersionContext = {+type VersionContext = VersionBundle & {fromWorkspaceVersion: SemVer;currentAppVersion: SemVer;currentVersionMajorMinor: UpgradeCommandVersion;- instanceCommands: MigrationInterface[];- workspaceCommands: VersionCommands;};@Command({@@ -143,7 +143,8 @@ export class UpgradeCommand extends CommandRunner {'Initialized upgrade context with:',`- currentVersion (migrating to): ${versionContext.currentAppVersion}`,`- fromWorkspaceVersion: ${versionContext.fromWorkspaceVersion}`,- `- ${versionContext.instanceCommands.length} instance commands (from registry)`,+ `- ${versionContext.fastInstanceCommands.length} fast instance commands (from registry)`,+ `- ${versionContext.slowInstanceCommands.length} slow instance commands (from registry)`,`- ${versionContext.workspaceCommands.length} workspace commands`,].join('\n '),),@@ -167,11 +168,37 @@ Please roll back to that version and run the upgrade command again.`,}await this.runLegacyPendingTypeOrmMigrations();- await this.runInstanceCommandsOrThrow(versionContext);++ for (const { command, name } of versionContext.fastInstanceCommands) {+ const result = await this.instanceUpgradeService.runFastInstanceCommand(+ {+ command,+ name,+ },+ );++ if (result.status === 'failed') {+ throw result.error;+ }+ }const hasWorkspaces =await this.workspaceVersionService.hasActiveOrSuspendedWorkspaces();+ for (const { command, name } of versionContext.slowInstanceCommands) {+ const result = await this.instanceUpgradeService.runSlowInstanceCommand(+ {+ command,+ name,+ skipDataMigration: !hasWorkspaces,+ },+ );++ if (result.status === 'failed') {+ throw result.error;+ }+ }+if (!hasWorkspaces) {this.logger.log(chalk.blue(@@ -220,64 +247,16 @@ Please roll back to that version and run the upgrade command again.`,}}- private async runInstanceCommandsOrThrow(- versionContext: VersionContext,- ): Promise<void> {- for (const instanceCommand of versionContext.instanceCommands) {- const migrationName = instanceCommand.constructor.name;- const result =- await this.instanceUpgradeService.runSingleMigration(instanceCommand);-- switch (result.status) {- case 'already-executed': {- this.logger.warn(- `Core migration ${migrationName} already executed, skipping`,- );-- break;- }- case 'failed': {- this.logger.error(`Core migration ${migrationName} failed`);-- if (isDefined(result.error)) {- this.logger.error(- result.error instanceof Error- ? (result.error.stack ?? result.error.message)- : String(result.error),- );- }-- throw new Error(`Core migration ${migrationName} failed`);- }- case 'success': {- this.logger.log(- `Core migration ${migrationName} executed successfully`,- );-- break;- }- default: {- assertUnreachable(result);- }- }- }- }-private resolveVersionContext(): VersionContext {const currentAppVersion = this.coreEngineVersionService.getCurrentVersion();const currentVersionMajorMinor =`${currentAppVersion.major}.${currentAppVersion.minor}.0` as UpgradeCommandVersion;- const workspaceCommands =- this.upgradeCommandRegistryService.getWorkspaceCommandsForVersion(- currentVersionMajorMinor,- );-const fromWorkspaceVersion =this.coreEngineVersionService.getPreviousVersion();- const instanceCommands =- this.upgradeCommandRegistryService.getInstanceCommandsForVersion(+ const { fastInstanceCommands, slowInstanceCommands, workspaceCommands } =+ this.upgradeCommandRegistryService.getBundleForVersion(currentVersionMajorMinor,);@@ -285,8 +264,9 @@ Please roll back to that version and run the upgrade command again.`,fromWorkspaceVersion,currentAppVersion,currentVersionMajorMinor,+ fastInstanceCommands,+ slowInstanceCommands,workspaceCommands,- instanceCommands,};}@@ -308,7 +288,9 @@ Please roll back to that version and run the upgrade command again.`,options,fromWorkspaceVersion: versionContext.fromWorkspaceVersion,currentAppVersion: versionContext.currentAppVersion,- workspaceCommands: versionContext.workspaceCommands,+ workspaceCommands: versionContext.workspaceCommands.map(+ (entry) => entry.command,+ ),});},});diff --git a/packages/twenty-server/src/engine/core-modules/upgrade/decorators/registered-instance-command.decorator.ts b/packages/twenty-server/src/engine/core-modules/upgrade/decorators/registered-instance-command.decorator.tsindex dc7ed58dd21..b54be481f0d 100644--- a/packages/twenty-server/src/engine/core-modules/upgrade/decorators/registered-instance-command.decorator.ts+++ b/packages/twenty-server/src/engine/core-modules/upgrade/decorators/registered-instance-command.decorator.ts@@ -4,9 +4,12 @@ import { Injectable } from '@nestjs/common';import { type UpgradeCommandVersion } from 'src/engine/constants/upgrade-command-supported-versions.constant';+export type InstanceCommandType = 'fast' | 'slow';+export type RegisteredInstanceCommandMetadata = {version: UpgradeCommandVersion;timestamp: number;+ type: InstanceCommandType;};const REGISTERED_INSTANCE_COMMAND_KEY = 'REGISTERED_INSTANCE_COMMAND';@@ -15,12 +18,16 @@ const REGISTERED_INSTANCE_COMMAND_KEY = 'REGISTERED_INSTANCE_COMMAND';// remove the @RegisteredInstanceCommand decorator from its associated// command files.export const RegisteredInstanceCommand =- (version: UpgradeCommandVersion, timestamp: number): ClassDecorator =>+ (+ version: UpgradeCommandVersion,+ timestamp: number,+ options?: { type: 'slow' },+ ): ClassDecorator =>(target) => {Injectable()(target);Reflect.defineMetadata(REGISTERED_INSTANCE_COMMAND_KEY,- { version, timestamp },+ { version, timestamp, type: options?.type ?? 'fast' },target,);};diff --git a/packages/twenty-server/src/engine/core-modules/upgrade/interfaces/fast-instance-command.interface.ts b/packages/twenty-server/src/engine/core-modules/upgrade/interfaces/fast-instance-command.interface.tsnew file mode 100644index 00000000000..3bd624100ca--- /dev/null+++ b/packages/twenty-server/src/engine/core-modules/upgrade/interfaces/fast-instance-command.interface.ts@@ -0,0 +1,6 @@+import { type QueryRunner } from 'typeorm';++export interface FastInstanceCommand {+ up(queryRunner: QueryRunner): Promise<void>;+ down(queryRunner: QueryRunner): Promise<void>;+}diff --git a/packages/twenty-server/src/engine/core-modules/upgrade/interfaces/slow-instance-command.interface.ts b/packages/twenty-server/src/engine/core-modules/upgrade/interfaces/slow-instance-command.interface.tsnew file mode 100644index 00000000000..0839ba93455--- /dev/null+++ b/packages/twenty-server/src/engine/core-modules/upgrade/interfaces/slow-instance-command.interface.ts@@ -0,0 +1,7 @@+import { type DataSource } from 'typeorm';++import { type FastInstanceCommand } from 'src/engine/core-modules/upgrade/interfaces/fast-instance-command.interface';++export interface SlowInstanceCommand extends FastInstanceCommand {+ runDataMigration(dataSource: DataSource): Promise<void>;+}diff --git a/packages/twenty-server/src/engine/core-modules/upgrade/services/__tests__/upgrade-command-registry.service.spec.ts b/packages/twenty-server/src/engine/core-modules/upgrade/services/__tests__/upgrade-command-registry.service.spec.tsindex 3836e04324a..b0ff1fec588 100644--- a/packages/twenty-server/src/engine/core-modules/upgrade/services/__tests__/upgrade-command-registry.service.spec.ts+++ b/packages/twenty-server/src/engine/core-modules/upgrade/services/__tests__/upgrade-command-registry.service.spec.ts@@ -3,14 +3,17 @@ import 'reflect-metadata';import { Test } from '@nestjs/testing';import { DiscoveryService } from '@nestjs/core';-import { type MigrationInterface } from 'typeorm';+import { type DataSource } from 'typeorm';++import { type FastInstanceCommand } from 'src/engine/core-modules/upgrade/interfaces/fast-instance-command.interface';import { UpgradeCommandRegistryService } from 'src/engine/core-modules/upgrade/services/upgrade-command-registry.service';import { RegisteredInstanceCommand } from 'src/engine/core-modules/upgrade/decorators/registered-instance-command.decorator';import { RegisteredWorkspaceCommand } from 'src/engine/core-modules/upgrade/decorators/registered-workspace-command.decorator';+import { type SlowInstanceCommand } from 'src/engine/core-modules/upgrade/interfaces/slow-instance-command.interface';@RegisteredInstanceCommand('1.21.0', 1770000000000)-class MigrationA1770000000000 implements MigrationInterface {+class MigrationA1770000000000 implements FastInstanceCommand {name = 'MigrationA1770000000000';async up(): Promise<void> {}@@ -18,7 +21,7 @@ class MigrationA1770000000000 implements MigrationInterface {}@RegisteredInstanceCommand('1.21.0', 1771000000000)-class MigrationB1771000000000 implements MigrationInterface {+class MigrationB1771000000000 implements FastInstanceCommand {name = 'MigrationB1771000000000';async up(): Promise<void> {}@@ -26,7 +29,7 @@ class MigrationB1771000000000 implements MigrationInterface {}@RegisteredInstanceCommand('1.21.0', 1772000000000)-class MigrationC1772000000000 implements MigrationInterface {+class MigrationC1772000000000 implements FastInstanceCommand {name = 'MigrationC1772000000000';async up(): Promise<void> {}@@ -34,14 +37,14 @@ class MigrationC1772000000000 implements MigrationInterface {}@RegisteredInstanceCommand('1.20.0', 1769000000000)-class MigrationD1769000000000 implements MigrationInterface {+class MigrationD1769000000000 implements FastInstanceCommand {name = 'MigrationD1769000000000';async up(): Promise<void> {}async down(): Promise<void> {}}-class UndecoratedMigration1768000000000 implements MigrationInterface {+class UndecoratedMigration1768000000000 implements FastInstanceCommand {name = 'UndecoratedMigration1768000000000';async up(): Promise<void> {}@@ -94,14 +97,16 @@ describe('UpgradeCommandRegistryService', () => {new MigrationC1772000000000(),]);- const v120 = service.getInstanceCommandsForVersion('1.20.0');- const v121 = service.getInstanceCommandsForVersion('1.21.0');+ const v120 = service.getBundleForVersion('1.20.0');+ const v121 = service.getBundleForVersion('1.21.0');- expect(v120.map((migration) => migration.constructor.name)).toStrictEqual([- 'MigrationD1769000000000',- ]);+ expect(+ v120.fastInstanceCommands.map((entry) => entry.command.constructor.name),+ ).toStrictEqual(['MigrationD1769000000000']);- expect(v121.map((migration) => migration.constructor.name)).toStrictEqual([+ expect(+ v121.fastInstanceCommands.map((entry) => entry.command.constructor.name),+ ).toStrictEqual(['MigrationA1770000000000','MigrationB1771000000000','MigrationC1772000000000',@@ -116,8 +121,8 @@ describe('UpgradeCommandRegistryService', () => {]);const names = service- .getInstanceCommandsForVersion('1.21.0')- .map((migration) => migration.constructor.name);+ .getBundleForVersion('1.21.0')+ .fastInstanceCommands.map((entry) => entry.command.constructor.name);expect(names).toStrictEqual(['MigrationA1770000000000',@@ -132,26 +137,32 @@ describe('UpgradeCommandRegistryService', () => {new MigrationA1770000000000(),]);- const v121 = service.getInstanceCommandsForVersion('1.21.0');+ const v121 = service.getBundleForVersion('1.21.0');- expect(v121).toHaveLength(1);- expect(v121[0].constructor.name).toBe('MigrationA1770000000000');+ expect(v121.fastInstanceCommands).toHaveLength(1);+ expect(v121.fastInstanceCommands[0].command.constructor.name).toBe(+ 'MigrationA1770000000000',+ );});it('should return empty array for version with no commands', async () => {const service = await buildRegistryService([]);- expect(service.getInstanceCommandsForVersion('1.20.0')).toStrictEqual([]);- expect(service.getInstanceCommandsForVersion('1.21.0')).toStrictEqual([]);- expect(service.getWorkspaceCommandsForVersion('1.20.0')).toStrictEqual([]);- expect(service.getWorkspaceCommandsForVersion('1.21.0')).toStrictEqual([]);+ const v120 = service.getBundleForVersion('1.20.0');+ const v121 = service.getBundleForVersion('1.21.0');++ expect(v120.fastInstanceCommands).toStrictEqual([]);+ expect(v121.fastInstanceCommands).toStrictEqual([]);+ expect(v120.workspaceCommands).toStrictEqual([]);+ expect(v121.workspaceCommands).toStrictEqual([]);});it('should return empty array for unsupported version', async () => {const service = await buildRegistryService([]);expect(- service.getInstanceCommandsForVersion('99.0.0' as unknown as '1.21.0'),+ service.getBundleForVersion('99.0.0' as unknown as '1.21.0')+ .fastInstanceCommands,).toStrictEqual([]);});@@ -161,12 +172,11 @@ describe('UpgradeCommandRegistryService', () => {new WorkspaceCommandA(),]);- const commands = service.getWorkspaceCommandsForVersion('1.21.0');+ const { workspaceCommands } = service.getBundleForVersion('1.21.0');- expect(commands.map((command) => command.constructor.name)).toStrictEqual([- 'WorkspaceCommandA',- 'WorkspaceCommandB',- ]);+ expect(+ workspaceCommands.map((entry) => entry.command.constructor.name),+ ).toStrictEqual(['WorkspaceCommandA', 'WorkspaceCommandB']);});it('should discover both instance and workspace commands for the same version', async () => {@@ -177,11 +187,10 @@ describe('UpgradeCommandRegistryService', () => {new WorkspaceCommandB(),]);- const instanceCommands = service.getInstanceCommandsForVersion('1.21.0');- const workspaceCommands = service.getWorkspaceCommandsForVersion('1.21.0');+ const bucket = service.getBundleForVersion('1.21.0');- expect(instanceCommands).toHaveLength(2);- expect(workspaceCommands).toHaveLength(2);+ expect(bucket.fastInstanceCommands).toHaveLength(2);+ expect(bucket.workspaceCommands).toHaveLength(2);});it('should allow same timestamp across different kinds', async () => {@@ -195,13 +204,15 @@ describe('UpgradeCommandRegistryService', () => {new WorkspaceCommandSameTimestamp(),]);- expect(service.getInstanceCommandsForVersion('1.21.0')).toHaveLength(1);- expect(service.getWorkspaceCommandsForVersion('1.21.0')).toHaveLength(1);+ const bucket = service.getBundleForVersion('1.21.0');++ expect(bucket.fastInstanceCommands).toHaveLength(1);+ expect(bucket.workspaceCommands).toHaveLength(1);});it('should throw on duplicate timestamps within the same kind', async () => {@RegisteredInstanceCommand('1.21.0', 1770000000000)- class DuplicateInstanceTimestamp implements MigrationInterface {+ class DuplicateInstanceTimestamp implements FastInstanceCommand {name = 'DuplicateInstanceTimestamp';async up(): Promise<void> {}@@ -213,7 +224,9 @@ describe('UpgradeCommandRegistryService', () => {new MigrationA1770000000000(),new DuplicateInstanceTimestamp(),]),- ).rejects.toThrow('Duplicate instance command timestamp 1770000000000');+ ).rejects.toThrow(+ 'Duplicate fast-instance command timestamp 1770000000000',+ );});it('should throw on duplicate computed names across kinds', async () => {@@ -244,32 +257,20 @@ describe('UpgradeCommandRegistryService', () => {new MigrationB1771000000000(),]);- const allCommands = service.getAllInstanceCommands();+ const allCommands = service.getAllFastInstanceCommands();- expect(allCommands).toStrictEqual([- {- version: '1.20.0',- migration: expect.objectContaining({ name: 'MigrationD1769000000000' }),- },- {- version: '1.21.0',- migration: expect.objectContaining({ name: 'MigrationA1770000000000' }),- },- {- version: '1.21.0',- migration: expect.objectContaining({ name: 'MigrationB1771000000000' }),- },- {- version: '1.21.0',- migration: expect.objectContaining({ name: 'MigrationC1772000000000' }),- },+ expect(allCommands.map((entry) => entry.name)).toStrictEqual([+ '1.20.0_MigrationD1769000000000_1769000000000',+ '1.21.0_MigrationA1770000000000_1770000000000',+ '1.21.0_MigrationB1771000000000_1771000000000',+ '1.21.0_MigrationC1772000000000_1772000000000',]);});- it('should return empty array from getAllInstanceCommands when no commands registered', async () => {+ it('should return empty array from getAllFastInstanceCommands when no commands registered', async () => {const service = await buildRegistryService([]);- expect(service.getAllInstanceCommands()).toStrictEqual([]);+ expect(service.getAllFastInstanceCommands()).toStrictEqual([]);});it('should allow same class name with different timestamps across kinds', async () => {@@ -287,7 +288,146 @@ describe('UpgradeCommandRegistryService', () => {new MigrationA1770000000000_WS(),]);- expect(service.getInstanceCommandsForVersion('1.21.0')).toHaveLength(1);- expect(service.getWorkspaceCommandsForVersion('1.21.0')).toHaveLength(1);+ const bucket = service.getBundleForVersion('1.21.0');++ expect(bucket.fastInstanceCommands).toHaveLength(1);+ expect(bucket.workspaceCommands).toHaveLength(1);+ });++ it('should discover slow instance commands and sort by timestamp', async () => {+ @RegisteredInstanceCommand('1.21.0', 1780000000000, { type: 'slow' })+ class SlowMigrationB1780000000000 implements SlowInstanceCommand {+ name = 'SlowMigrationB1780000000000';++ async runDataMigration(_dataSource: DataSource): Promise<void> {}+ async up(): Promise<void> {}+ async down(): Promise<void> {}+ }++ @RegisteredInstanceCommand('1.21.0', 1779000000000, { type: 'slow' })+ class SlowMigrationA1779000000000 implements SlowInstanceCommand {+ name = 'SlowMigrationA1779000000000';++ async runDataMigration(_dataSource: DataSource): Promise<void> {}+ async up(): Promise<void> {}+ async down(): Promise<void> {}+ }++ const service = await buildRegistryService([+ new SlowMigrationB1780000000000(),+ new SlowMigrationA1779000000000(),+ ]);++ const { slowInstanceCommands } = service.getBundleForVersion('1.21.0');++ expect(+ slowInstanceCommands.map((entry) => entry.command.constructor.name),+ ).toStrictEqual([+ 'SlowMigrationA1779000000000',+ 'SlowMigrationB1780000000000',+ ]);+ });++ it('should separate fast and slow instance commands in the same version', async () => {+ @RegisteredInstanceCommand('1.21.0', 1780000000000, { type: 'slow' })+ class SlowMigration1780000000000 implements SlowInstanceCommand {+ name = 'SlowMigration1780000000000';++ async runDataMigration(_dataSource: DataSource): Promise<void> {}+ async up(): Promise<void> {}+ async down(): Promise<void> {}+ }++ const service = await buildRegistryService([+ new MigrationA1770000000000(),+ new SlowMigration1780000000000(),+ ]);++ const bucket = service.getBundleForVersion('1.21.0');++ expect(bucket.fastInstanceCommands).toHaveLength(1);+ expect(bucket.slowInstanceCommands).toHaveLength(1);+ });++ it('should throw on duplicate timestamps within slow instance commands', async () => {+ @RegisteredInstanceCommand('1.21.0', 1780000000000, { type: 'slow' })+ class SlowMigrationA1780000000000 implements SlowInstanceCommand {+ name = 'SlowMigrationA1780000000000';++ async runDataMigration(_dataSource: DataSource): Promise<void> {}+ async up(): Promise<void> {}+ async down(): Promise<void> {}+ }++ @RegisteredInstanceCommand('1.21.0', 1780000000000, { type: 'slow' })+ class SlowMigrationB1780000000000 implements SlowInstanceCommand {+ name = 'SlowMigrationB1780000000000';++ async runDataMigration(_dataSource: DataSource): Promise<void> {}+ async up(): Promise<void> {}+ async down(): Promise<void> {}+ }++ await expect(+ buildRegistryService([+ new SlowMigrationA1780000000000(),+ new SlowMigrationB1780000000000(),+ ]),+ ).rejects.toThrow(+ 'Duplicate slow-instance command timestamp 1780000000000',+ );+ });++ it('should allow same timestamp across fast and slow instance commands', async () => {+ @RegisteredInstanceCommand('1.21.0', 1770000000000, { type: 'slow' })+ class SlowMigrationSameTimestamp implements SlowInstanceCommand {+ name = 'SlowMigrationSameTimestamp';++ async runDataMigration(_dataSource: DataSource): Promise<void> {}+ async up(): Promise<void> {}+ async down(): Promise<void> {}+ }++ const service = await buildRegistryService([+ new MigrationA1770000000000(),+ new SlowMigrationSameTimestamp(),+ ]);++ const bucket = service.getBundleForVersion('1.21.0');++ expect(bucket.fastInstanceCommands).toHaveLength(1);+ expect(bucket.slowInstanceCommands).toHaveLength(1);+ });++ it('should return all slow instance commands across versions', async () => {+ @RegisteredInstanceCommand('1.21.0', 1780000000000, { type: 'slow' })+ class SlowMigration1780000000000 implements SlowInstanceCommand {+ name = 'SlowMigration1780000000000';++ async runDataMigration(_dataSource: DataSource): Promise<void> {}+ async up(): Promise<void> {}+ async down(): Promise<void> {}+ }++ @RegisteredInstanceCommand('1.20.0', 1768000000000, { type: 'slow' })+ class SlowMigration1768000000000 implements SlowInstanceCommand {+ name = 'SlowMigration1768000000000';++ async runDataMigration(_dataSource: DataSource): Promise<void> {}+ async up(): Promise<void> {}+ async down(): Promise<void> {}+ }++ const service = await buildRegistryService([+ new SlowMigration1780000000000(),+ new SlowMigration1768000000000(),+ ]);++ const allSlowCommands = service.getAllSlowInstanceCommands();++ expect(allSlowCommands.map((entry) => entry.name)).toStrictEqual([+ '1.20.0_SlowMigration1768000000000_1768000000000',+ '1.21.0_SlowMigration1780000000000_1780000000000',+ ]);});});diff --git a/packages/twenty-server/src/engine/core-modules/upgrade/services/instance-upgrade.service.ts b/packages/twenty-server/src/engine/core-modules/upgrade/services/instance-upgrade.service.tsindex a5dfcdd16c5..52601677306 100644--- a/packages/twenty-server/src/engine/core-modules/upgrade/services/instance-upgrade.service.ts+++ b/packages/twenty-server/src/engine/core-modules/upgrade/services/instance-upgrade.service.ts@@ -1,18 +1,22 @@-import { Injectable } from '@nestjs/common';+import { Injectable, Logger } from '@nestjs/common';import { InjectDataSource } from '@nestjs/typeorm';-import { DataSource, MigrationInterface } from 'typeorm';+import { DataSource } from 'typeorm';import { TwentyConfigService } from 'src/engine/core-modules/twenty-config/twenty-config.service';+import { type FastInstanceCommand } from 'src/engine/core-modules/upgrade/interfaces/fast-instance-command.interface';+import { type SlowInstanceCommand } from 'src/engine/core-modules/upgrade/interfaces/slow-instance-command.interface';import { UpgradeMigrationService } from 'src/engine/core-modules/upgrade/services/upgrade-migration.service';-export type RunSingleMigrationResult =+type RunSingleMigrationResult =| { status: 'success' }| { status: 'already-executed' }| { status: 'failed'; error: unknown };@Injectable()export class InstanceUpgradeService {+ private readonly logger = new Logger(InstanceUpgradeService.name);+constructor(@InjectDataSource()private readonly dataSource: DataSource,@@ -20,20 +24,25 @@ export class InstanceUpgradeService {private readonly upgradeMigrationService: UpgradeMigrationService,) {}- async runSingleMigration(- migration: MigrationInterface,- ): Promise<RunSingleMigrationResult> {- const migrationName = migration.constructor.name;+ async runFastInstanceCommand({+ command,+ name,+ }: {+ command: FastInstanceCommand;+ name: string;+ }): Promise<RunSingleMigrationResult> {const executedByVersion =this.twentyConfigService.get('APP_VERSION') ?? 'unknown';const isAlreadyCompleted =await this.upgradeMigrationService.isLastAttemptCompleted({- name: migrationName,+ name,workspaceId: null,});if (isAlreadyCompleted) {+ this.logger.log(`${name} already executed, skipping`);+return { status: 'already-executed' };}@@ -43,10 +52,10 @@ export class InstanceUpgradeService {await queryRunner.connect();await queryRunner.startTransaction();- await migration.up(queryRunner);+ await command.up(queryRunner);await this.upgradeMigrationService.markAsCompleted({- name: migrationName,+ name,workspaceId: null,executedByVersion,queryRunner,@@ -59,16 +68,69 @@ export class InstanceUpgradeService {}await this.upgradeMigrationService.markAsFailed({- name: migrationName,+ name,workspaceId: null,executedByVersion,});+ this.logger.error(+ `${name} failed`,+ error instanceof Error ? error.stack : String(error),+ );+return { status: 'failed', error };} finally {await queryRunner.release();}+ this.logger.log(`${name} executed successfully`);+return { status: 'success' };}++ async runSlowInstanceCommand({+ command,+ name,+ skipDataMigration,+ }: {+ command: SlowInstanceCommand;+ name: string;+ skipDataMigration?: boolean;+ }): Promise<RunSingleMigrationResult> {+ const isAlreadyCompleted =+ await this.upgradeMigrationService.isLastAttemptCompleted({+ name,+ workspaceId: null,+ });++ if (isAlreadyCompleted) {+ this.logger.log(`${name} already executed, skipping`);++ return { status: 'already-executed' };+ }++ if (!skipDataMigration) {+ const executedByVersion =+ this.twentyConfigService.get('APP_VERSION') ?? 'unknown';++ try {+ await command.runDataMigration(this.dataSource);+ } catch (error) {+ await this.upgradeMigrationService.markAsFailed({+ name,+ workspaceId: null,+ executedByVersion,+ });++ this.logger.error(+ `${name} data migration failed`,+ error instanceof Error ? error.stack : String(error),+ );++ return { status: 'failed', error };+ }+ }++ return this.runFastInstanceCommand({ command, name });+ }}diff --git a/packages/twenty-server/src/engine/core-modules/upgrade/services/upgrade-command-registry.service.ts b/packages/twenty-server/src/engine/core-modules/upgrade/services/upgrade-command-registry.service.tsindex fb10727367f..d768ec5fd26 100644--- a/packages/twenty-server/src/engine/core-modules/upgrade/services/upgrade-command-registry.service.ts+++ b/packages/twenty-server/src/engine/core-modules/upgrade/services/upgrade-command-registry.service.ts@@ -1,12 +1,12 @@import { Injectable, Logger, type OnModuleInit } from '@nestjs/common';import { DiscoveryService } from '@nestjs/core';-import { type MigrationInterface } from 'typeorm';-import { type ActiveOrSuspendedWorkspaceCommandRunner } from 'src/database/commands/command-runners/active-or-suspended-workspace.command-runner';import { type WorkspaceCommandRunner } from 'src/database/commands/command-runners/workspace.command-runner';-import { getRegisteredWorkspaceCommandMetadata } from 'src/engine/core-modules/upgrade/decorators/registered-workspace-command.decorator';import { getRegisteredInstanceCommandMetadata } from 'src/engine/core-modules/upgrade/decorators/registered-instance-command.decorator';+import { getRegisteredWorkspaceCommandMetadata } from 'src/engine/core-modules/upgrade/decorators/registered-workspace-command.decorator';+import { type FastInstanceCommand } from 'src/engine/core-modules/upgrade/interfaces/fast-instance-command.interface';+import { type SlowInstanceCommand } from 'src/engine/core-modules/upgrade/interfaces/slow-instance-command.interface';import {UPGRADE_COMMAND_SUPPORTED_VERSIONS,type UpgradeCommandVersion,@@ -17,38 +17,52 @@ type WorkspaceCommand =| WorkspaceCommandRunner| ActiveOrSuspendedWorkspaceCommandRunner;-type RegisteredInstanceCommand = {+export type RegisteredFastInstanceCommand = {+ name: string;+ command: FastInstanceCommand;+ timestamp: number;+};++export type RegisteredSlowInstanceCommand = {name: string;- command: MigrationInterface;+ command: SlowInstanceCommand;timestamp: number;};-type RegisteredWorkspaceCommand = {+export type RegisteredWorkspaceCommand = {name: string;command: WorkspaceCommand;timestamp: number;};-type VersionBucket = {- instanceCommands: RegisteredInstanceCommand[];+export type VersionBundle = {+ fastInstanceCommands: RegisteredFastInstanceCommand[];+ slowInstanceCommands: RegisteredSlowInstanceCommand[];workspaceCommands: RegisteredWorkspaceCommand[];};+const buildEmptyVersionBundle = (): VersionBundle => ({+ fastInstanceCommands: [],+ slowInstanceCommands: [],+ workspaceCommands: [],+});+@Injectable()export class UpgradeCommandRegistryService implements OnModuleInit {private readonly logger = new Logger(UpgradeCommandRegistryService.name);- private readonly bucketsByVersion = new Map<+ private readonly bundlesByVersion = new Map<UpgradeCommandVersion,- VersionBucket+ VersionBundle>();constructor(private readonly discoveryService: DiscoveryService) {}onModuleInit(): void {for (const version of UPGRADE_COMMAND_SUPPORTED_VERSIONS) {- this.bucketsByVersion.set(version, {- instanceCommands: [],+ this.bundlesByVersion.set(version, {+ fastInstanceCommands: [],+ slowInstanceCommands: [],workspaceCommands: [],});}@@ -66,20 +80,31 @@ export class UpgradeCommandRegistryService implements OnModuleInit {getRegisteredInstanceCommandMetadata(metatype);if (isDefined(instanceCommandMetadata)) {- const bucket = this.bucketsByVersion.get(+ const bundle = this.bundlesByVersion.get(instanceCommandMetadata.version,);- if (isDefined(bucket)) {- bucket.instanceCommands.push({+ if (isDefined(bundle)) {+ const entry = {name: this.computeCommandName(instanceCommandMetadata.version,- (instance as MigrationInterface).constructor.name,+ (instance as FastInstanceCommand).constructor.name,instanceCommandMetadata.timestamp,),- command: instance as MigrationInterface,timestamp: instanceCommandMetadata.timestamp,- });+ };++ if (instanceCommandMetadata.type === 'slow') {+ bundle.slowInstanceCommands.push({+ ...entry,+ command: instance as SlowInstanceCommand,+ });+ } else {+ bundle.fastInstanceCommands.push({+ ...entry,+ command: instance as FastInstanceCommand,+ });+ }}continue;@@ -89,12 +114,12 @@ export class UpgradeCommandRegistryService implements OnModuleInit {getRegisteredWorkspaceCommandMetadata(metatype);if (isDefined(workspaceCommandMetadata)) {- const bucket = this.bucketsByVersion.get(+ const bundle = this.bundlesByVersion.get(workspaceCommandMetadata.version,);- if (isDefined(bucket)) {- bucket.workspaceCommands.push({+ if (isDefined(bundle)) {+ bundle.workspaceCommands.push({name: this.computeCommandName(workspaceCommandMetadata.version,(instance as WorkspaceCommand).constructor.name,@@ -107,65 +132,48 @@ export class UpgradeCommandRegistryService implements OnModuleInit {}}- for (const [, bucket] of this.bucketsByVersion) {- bucket.instanceCommands.sort(+ for (const [, bundle] of this.bundlesByVersion) {+ bundle.fastInstanceCommands.sort((entryA, entryB) => entryA.timestamp - entryB.timestamp,);- bucket.workspaceCommands.sort(+ bundle.slowInstanceCommands.sort(+ (entryA, entryB) => entryA.timestamp - entryB.timestamp,+ );+ bundle.workspaceCommands.sort((entryA, entryB) => entryA.timestamp - entryB.timestamp,);}this.validateNoDuplicates();- for (const [version, bucket] of this.bucketsByVersion) {+ for (const [version, bundle] of this.bundlesByVersion) {const totalCount =- bucket.instanceCommands.length + bucket.workspaceCommands.length;+ bundle.fastInstanceCommands.length ++ bundle.slowInstanceCommands.length ++ bundle.workspaceCommands.length;if (totalCount > 0) {this.logger.log(- `Registered ${bucket.instanceCommands.length} instance command(s) and ${bucket.workspaceCommands.length} workspace command(s) for ${version}`,+ `Registered ${bundle.fastInstanceCommands.length} fast instance, ${bundle.slowInstanceCommands.length} slow instance, and ${bundle.workspaceCommands.length} workspace command(s) for ${version}`,);}}}- getInstanceCommandsForVersion(- version: UpgradeCommandVersion,- ): MigrationInterface[] {- return (- this.bucketsByVersion- .get(version)- ?.instanceCommands.map((entry) => entry.command) ?? []- );+ getBundleForVersion(version: UpgradeCommandVersion): VersionBundle {+ return this.bundlesByVersion.get(version) ?? buildEmptyVersionBundle();}- getWorkspaceCommandsForVersion(- version: UpgradeCommandVersion,- ): WorkspaceCommand[] {- return (- this.bucketsByVersion- .get(version)- ?.workspaceCommands.map((entry) => entry.command) ?? []+ getAllFastInstanceCommands(): RegisteredFastInstanceCommand[] {+ return UPGRADE_COMMAND_SUPPORTED_VERSIONS.flatMap(+ (version) => this.getBundleForVersion(version).fastInstanceCommands,);}- getAllInstanceCommands(): {- version: UpgradeCommandVersion;- migration: MigrationInterface;- }[] {- const result: {- version: UpgradeCommandVersion;- migration: MigrationInterface;- }[] = [];-- for (const version of UPGRADE_COMMAND_SUPPORTED_VERSIONS) {- for (const command of this.getInstanceCommandsForVersion(version)) {- result.push({ version, migration: command });- }- }-- return result;+ getAllSlowInstanceCommands(): RegisteredSlowInstanceCommand[] {+ return UPGRADE_COMMAND_SUPPORTED_VERSIONS.flatMap(+ (version) => this.getBundleForVersion(version).slowInstanceCommands,+ );}private computeCommandName(@@ -177,23 +185,29 @@ export class UpgradeCommandRegistryService implements OnModuleInit {}private validateNoDuplicates(): void {- for (const [version, bucket] of this.bucketsByVersion) {+ for (const [version, bundle] of this.bundlesByVersion) {+ this.validateNoTimestampDuplicatesWithinKind(+ version,+ 'fast-instance',+ bundle.fastInstanceCommands,+ );this.validateNoTimestampDuplicatesWithinKind(version,- 'instance',- bucket.instanceCommands,+ 'slow-instance',+ bundle.slowInstanceCommands,);this.validateNoTimestampDuplicatesWithinKind(version,'workspace',- bucket.workspaceCommands,+ bundle.workspaceCommands,);const seenNames = new Set<string>();const allNames = [- ...bucket.instanceCommands.map((entry) => entry.name),- ...bucket.workspaceCommands.map((entry) => entry.name),+ ...bundle.fastInstanceCommands.map((entry) => entry.name),+ ...bundle.slowInstanceCommands.map((entry) => entry.name),+ ...bundle.workspaceCommands.map((entry) => entry.name),];for (const name of allNames) {@@ -210,8 +224,11 @@ export class UpgradeCommandRegistryService implements OnModuleInit {private validateNoTimestampDuplicatesWithinKind(version: UpgradeCommandVersion,- kind: 'instance' | 'workspace',- entries: RegisteredInstanceCommand[] | RegisteredWorkspaceCommand[],+ kind: 'fast-instance' | 'slow-instance' | 'workspace',+ entries:+ | RegisteredFastInstanceCommand[]+ | RegisteredSlowInstanceCommand[]+ | RegisteredWorkspaceCommand[],): void {const seenTimestamps = new Set<number>();