Skip to content

The open alternative to Salesforce, designed for AI.

fix(workflow): never freeze a null core workflow link on version mirror (#26076)

Thomas Trompette561794d7843d
diff --git a/packages/twenty-server/src/database/commands/upgrade-version-command/2-42/2-42-upgrade-version-command.module.ts b/packages/twenty-server/src/database/commands/upgrade-version-command/2-42/2-42-upgrade-version-command.module.ts
index 09257f6ad32..4c50ace3a6b 100644
--- a/packages/twenty-server/src/database/commands/upgrade-version-command/2-42/2-42-upgrade-version-command.module.ts
+++ b/packages/twenty-server/src/database/commands/upgrade-version-command/2-42/2-42-upgrade-version-command.module.ts
@@ -2,6 +2,7 @@ import { Module } from '@nestjs/common';
import { WorkspaceIteratorModule } from 'src/database/commands/command-runners/workspace-iterator.module';
import { UnpinCreationCommandsOnRecordSelectionCommand } from 'src/database/commands/upgrade-version-command/2-42/2-42-workspace-command-1789634112046-unpin-creation-commands-on-record-selection.command';
+import { RelinkWorkflowVersionsToCoreWorkflowsCommand } from 'src/database/commands/upgrade-version-command/2-42/2-42-workspace-command-1789645879295-relink-workflow-versions-to-core-workflows.command';
import { WorkspaceCacheModule } from 'src/engine/workspace-cache/workspace-cache.module';
import { WorkspaceMigrationRunnerModule } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-runner/workspace-migration-runner.module';
import { WorkspaceMigrationModule } from 'src/engine/workspace-manager/workspace-migration/workspace-migration.module';
@@ -15,6 +16,10 @@ import { WorkspaceSchemaMigrationRunnerActionHandlersModule } from 'src/engine/w
WorkspaceMigrationRunnerModule,
WorkspaceSchemaMigrationRunnerActionHandlersModule,
],
- providers: [UnpinCreationCommandsOnRecordSelectionCommand],
+ providers: [
+ UnpinCreationCommandsOnRecordSelectionCommand,
+ RelinkWorkflowVersionsToCoreWorkflowsCommand,
+ ],
+ exports: [RelinkWorkflowVersionsToCoreWorkflowsCommand],
})
export class V2_42_UpgradeVersionCommandModule {}
diff --git a/packages/twenty-server/src/database/commands/upgrade-version-command/2-42/2-42-workspace-command-1789645879295-relink-workflow-versions-to-core-workflows.command.ts b/packages/twenty-server/src/database/commands/upgrade-version-command/2-42/2-42-workspace-command-1789645879295-relink-workflow-versions-to-core-workflows.command.ts
new file mode 100644
index 00000000000..765a192fb5f
--- /dev/null
+++ b/packages/twenty-server/src/database/commands/upgrade-version-command/2-42/2-42-workspace-command-1789645879295-relink-workflow-versions-to-core-workflows.command.ts
@@ -0,0 +1,108 @@
+import { Command } from 'nest-commander';
+import { isDefined } from 'twenty-shared/utils';
+
+import { ProvisionedWorkspaceCommandRunner } from 'src/database/commands/command-runners/provisioned-workspace.command-runner';
+import { WorkspaceIteratorService } from 'src/database/commands/command-runners/workspace-iterator.service';
+import { type RunOnWorkspaceArgs } from 'src/database/commands/command-runners/workspace.command-runner';
+import { RegisteredWorkspaceCommand } from 'src/engine/core-modules/upgrade/decorators/registered-workspace-command.decorator';
+import { getWorkspaceSchemaName } from 'src/engine/workspace-datasource/utils/get-workspace-schema-name.util';
+
+@RegisteredWorkspaceCommand('2.42.0', 1789645879295)
+@Command({
+ name: 'upgrade:2-42:relink-workflow-versions-to-core-workflows',
+ description:
+ 'Backfill coreWorkflowId on core workflow versions left unlinked by the mirror creation race',
+})
+export class RelinkWorkflowVersionsToCoreWorkflowsCommand extends ProvisionedWorkspaceCommandRunner {
+ constructor(
+ protected readonly workspaceIteratorService: WorkspaceIteratorService,
+ ) {
+ super(workspaceIteratorService);
+ }
+
+ override async runOnWorkspace({
+ workspaceId,
+ options,
+ dataSource,
+ }: RunOnWorkspaceArgs): Promise<void> {
+ if (!isDefined(dataSource)) {
+ this.logger.warn(
+ `No data source for workspace ${workspaceId}, skipping relink`,
+ );
+
+ return;
+ }
+
+ const queryRunner = dataSource.createQueryRunner();
+
+ await queryRunner.connect();
+
+ const schema = getWorkspaceSchemaName(workspaceId);
+
+ const canonicalParentId = `
+ SELECT coalesce(
+ (
+ SELECT ww."coreWorkflowId"
+ FROM "${schema}"."workflow" ww
+ WHERE ww."id" = v."workflowId"
+ AND ww."coreWorkflowId" IS NOT NULL
+ ),
+ (
+ SELECT c."id"
+ FROM core."workflow" c
+ WHERE c."workspaceId" = v."workspaceId"
+ AND c."workspaceWorkflowId" = v."workflowId"
+ ORDER BY c."createdAt" ASC, c."id" ASC
+ LIMIT 1
+ )
+ )`;
+
+ const predicate = `
+ WHERE v."workspaceId" = $1
+ AND v."coreWorkflowId" IS NULL
+ AND (${canonicalParentId}) IS NOT NULL`;
+
+ try {
+ const [workflowTable] = await queryRunner.query(
+ `SELECT to_regclass($1) AS "table"`,
+ [`"${schema}"."workflow"`],
+ );
+
+ if (!isDefined(workflowTable?.table)) {
+ return;
+ }
+
+ const [counts] = await queryRunner.query(
+ `SELECT count(*)::int AS total
+ FROM core."workflowVersion" v
+ ${predicate}`,
+ [workspaceId],
+ );
+
+ if (counts.total === 0) {
+ return;
+ }
+
+ if (options.dryRun) {
+ this.logger.log(
+ `[DRY RUN] Would relink ${counts.total} core workflow version row(s) for workspace ${workspaceId}`,
+ );
+
+ return;
+ }
+
+ await queryRunner.query(
+ `UPDATE core."workflowVersion" v
+ SET "coreWorkflowId" = (${canonicalParentId})
+ ${predicate}`,
+ [workspaceId],
+ );
+
+ this.logger.log(
+ `Relinked ${counts.total} core workflow version row(s) for workspace ${workspaceId}`,
+ );
+ } finally {
+ await queryRunner.release();
+ }
+ }
+}
diff --git a/packages/twenty-server/src/engine/core-modules/workflow/services/workflow-version-core-sync.service.ts b/packages/twenty-server/src/engine/core-modules/workflow/services/workflow-version-core-sync.service.ts
index 5685490afc4..3431957f4ee 100644
--- a/packages/twenty-server/src/engine/core-modules/workflow/services/workflow-version-core-sync.service.ts
+++ b/packages/twenty-server/src/engine/core-modules/workflow/services/workflow-version-core-sync.service.ts
@@ -12,6 +12,7 @@ import {
WorkflowVersionStatus,
} from 'src/engine/core-modules/workflow/entities/workflow-version.entity';
import { RecordPositionService } from 'src/engine/core-modules/record-position/services/record-position.service';
+import { resolveCoreWorkflowIdsByWorkspaceWorkflowId } from 'src/engine/core-modules/workflow/utils/resolve-core-workflow-ids-by-workspace-workflow-id.util';
import { WorkspaceEntity } from 'src/engine/core-modules/workspace/workspace.entity';
import { WorkspaceOrmManager } from 'src/engine/twenty-orm/workspace-orm.manager';
import { type WorkspaceTransactionScope } from 'src/engine/twenty-orm/types/workspace-transaction-scope.type';
@@ -200,10 +201,11 @@ export class WorkflowVersionCoreSyncService {
const isNewLink = !isDefined(linkedCoreVersionId);
const coreWorkflowVersionId = linkedCoreVersionId ?? uuidv4();
- const coreWorkflowId = await this.resolveCoreWorkflowIdInTransaction(
- workflowVersion.workflowId,
+ const coreWorkflowId = await this.resolveCoreWorkflowIdInTransaction({
+ workspaceId,
+ workflowId: workflowVersion.workflowId,
transactionScope,
- );
+ });
// The conflict target is the primary key alone, so without the workspaceId
// predicate a core row owned by another workspace would have its triggers
@@ -280,26 +282,61 @@ export class WorkflowVersionCoreSyncService {
}
}
+ const unresolvedWorkflowIds = distinctWorkflowIds.filter(
+ (candidateWorkflowId) =>
+ !coreWorkflowIdByWorkflowId.has(candidateWorkflowId),
+ );
+
+ const reverseMappedCoreWorkflowIds =
+ await resolveCoreWorkflowIdsByWorkspaceWorkflowId({
+ executeQuery: (query, parameters) =>
+ this.workspaceRepository.manager.query(query, parameters),
+ workspaceId,
+ workspaceWorkflowIds: unresolvedWorkflowIds,
+ });
+
+ for (const [
+ workspaceWorkflowId,
+ coreWorkflowId,
+ ] of reverseMappedCoreWorkflowIds) {
+ if (!coreWorkflowIdByWorkflowId.has(workspaceWorkflowId)) {
+ coreWorkflowIdByWorkflowId.set(workspaceWorkflowId, coreWorkflowId);
+ }
+ }
+
return coreWorkflowIdByWorkflowId;
}
- private async resolveCoreWorkflowIdInTransaction(
- workflowId: string,
- transactionScope: WorkspaceTransactionScope,
- ): Promise<string | null> {
- const workflowRepository =
- transactionScope.getRepository<WorkflowWorkspaceEntity>('workflow', {
+ private async resolveCoreWorkflowIdInTransaction({
+ workspaceId,
+ workflowId,
+ transactionScope,
+ }: {
+ workspaceId: string;
+ workflowId: string;
+ transactionScope: WorkspaceTransactionScope;
+ }): Promise<string | null> {
+ const workflow = await transactionScope
+ .getRepository<WorkflowWorkspaceEntity>('workflow', {
shouldBypassPermissionChecks: true,
- });
+ })
+ .findOne({ where: { id: workflowId }, withDeleted: true });
- const workflow = await workflowRepository.findOne({
- where: { id: workflowId },
- withDeleted: true,
- });
+ const pointedCoreWorkflowId = workflow?.coreWorkflowId ?? null;
+
+ if (isNonEmptyString(pointedCoreWorkflowId)) {
+ return pointedCoreWorkflowId;
+ }
- const coreWorkflowId = workflow?.coreWorkflowId ?? null;
+ const coreWorkflowIdByWorkspaceWorkflowId =
+ await resolveCoreWorkflowIdsByWorkspaceWorkflowId({
+ executeQuery: (query, parameters) =>
+ transactionScope.executeRawQuery(query, parameters),
+ workspaceId,
+ workspaceWorkflowIds: [workflowId],
+ });
- return isNonEmptyString(coreWorkflowId) ? coreWorkflowId : null;
+ return coreWorkflowIdByWorkspaceWorkflowId.get(workflowId) ?? null;
}
// Must run inside the caller's transaction so the ownership answer cannot go
diff --git a/packages/twenty-server/src/engine/core-modules/workflow/utils/has-core-workflow-workspace-workflow-id-column.util.ts b/packages/twenty-server/src/engine/core-modules/workflow/utils/has-core-workflow-workspace-workflow-id-column.util.ts
new file mode 100644
index 00000000000..3b53c5de4ba
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/workflow/utils/has-core-workflow-workspace-workflow-id-column.util.ts
@@ -0,0 +1,24 @@
+// Cached only once true: the column is added mid-upgrade, so a false answer has
+// to stay re-checkable, while a true answer can never become false again.
+let hasColumn = false;
+
+export const hasCoreWorkflowWorkspaceWorkflowIdColumn = async (
+ executeQuery: (query: string) => Promise<unknown[]>,
+): Promise<boolean> => {
+ if (hasColumn) {
+ return true;
+ }
+
+ const rows = await executeQuery(
+ `SELECT 1
+ FROM information_schema.columns
+ WHERE table_schema = 'core'
+ AND table_name = 'workflow'
+ AND column_name = 'workspaceWorkflowId'
+ LIMIT 1`,
+ );
+
+ hasColumn = rows.length > 0;
+
+ return hasColumn;
+};
diff --git a/packages/twenty-server/src/engine/core-modules/workflow/utils/resolve-core-workflow-ids-by-workspace-workflow-id.util.ts b/packages/twenty-server/src/engine/core-modules/workflow/utils/resolve-core-workflow-ids-by-workspace-workflow-id.util.ts
new file mode 100644
index 00000000000..9210a16e6ac
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/workflow/utils/resolve-core-workflow-ids-by-workspace-workflow-id.util.ts
@@ -0,0 +1,50 @@
+import { isNonEmptyString } from '@sniptt/guards';
+
+import { hasCoreWorkflowWorkspaceWorkflowIdColumn } from 'src/engine/core-modules/workflow/utils/has-core-workflow-workspace-workflow-id-column.util';
+
+type CoreWorkflowReverseRow = {
+ workspaceWorkflowId: string;
+ id: string;
+};
+
+export const resolveCoreWorkflowIdsByWorkspaceWorkflowId = async ({
+ executeQuery,
+ workspaceId,
+ workspaceWorkflowIds,
+}: {
+ executeQuery: (
+ query: string,
+ parameters?: unknown[],
+ ) => Promise<Record<string, unknown>[]>;
+ workspaceId: string;
+ workspaceWorkflowIds: string[];
+}): Promise<Map<string, string>> => {
+ const coreWorkflowIdByWorkspaceWorkflowId = new Map<string, string>();
+
+ if (workspaceWorkflowIds.length === 0) {
+ return coreWorkflowIdByWorkspaceWorkflowId;
+ }
+
+ if (!(await hasCoreWorkflowWorkspaceWorkflowIdColumn(executeQuery))) {
+ return coreWorkflowIdByWorkspaceWorkflowId;
+ }
+
+ const reverseMappedCoreWorkflows = (await executeQuery(
+ `SELECT DISTINCT ON ("workspaceWorkflowId") "workspaceWorkflowId", "id"
+ FROM core."workflow"
+ WHERE "workspaceId" = $1 AND "workspaceWorkflowId" = ANY($2::uuid[])
+ ORDER BY "workspaceWorkflowId", "createdAt" ASC, "id" ASC`,
+ [workspaceId, workspaceWorkflowIds],
+ )) as CoreWorkflowReverseRow[];
+
+ for (const coreWorkflow of reverseMappedCoreWorkflows) {
+ if (isNonEmptyString(coreWorkflow.workspaceWorkflowId)) {
+ coreWorkflowIdByWorkspaceWorkflowId.set(
+ coreWorkflow.workspaceWorkflowId,
+ coreWorkflow.id,
+ );
+ }
+ }
+
+ return coreWorkflowIdByWorkspaceWorkflowId;
+};
diff --git a/packages/twenty-server/test/integration/upgrade/suites/2-42-workspace-command-1789645879295-relink-workflow-versions-to-core-workflows.integration-spec.ts b/packages/twenty-server/test/integration/upgrade/suites/2-42-workspace-command-1789645879295-relink-workflow-versions-to-core-workflows.integration-spec.ts
new file mode 100644
index 00000000000..8891addf18b
--- /dev/null
+++ b/packages/twenty-server/test/integration/upgrade/suites/2-42-workspace-command-1789645879295-relink-workflow-versions-to-core-workflows.integration-spec.ts
@@ -0,0 +1,181 @@
+import { getAppProviderByClassName } from 'test/integration/utils/get-app-provider-by-class-name.util';
+import { DataSource } from 'typeorm';
+import { v4 } from 'uuid';
+
+import { type RelinkWorkflowVersionsToCoreWorkflowsCommand } from 'src/database/commands/upgrade-version-command/2-42/2-42-workspace-command-1789645879295-relink-workflow-versions-to-core-workflows.command';
+import { SEED_APPLE_WORKSPACE_ID } from 'src/engine/workspace-manager/dev-seeder/core/constants/seeder-workspaces.constant';
+
+jest.useRealTimers();
+
+describe('RelinkWorkflowVersionsToCoreWorkflowsCommand (integration)', () => {
+ let dataSource: DataSource;
+ let command: RelinkWorkflowVersionsToCoreWorkflowsCommand;
+ let applicationId: string;
+
+ const seededCoreWorkflowIds: string[] = [];
+ const seededCoreVersionIds: string[] = [];
+
+ const seedCoreWorkflow = async (
+ workspaceWorkflowId: string,
+ createdAt?: string,
+ ): Promise<string> => {
+ const coreWorkflowId = v4();
+
+ await dataSource.query(
+ `INSERT INTO core."workflow"
+ ("id", "workspaceId", "name", "workspaceWorkflowId", "universalIdentifier", "applicationId", "createdAt")
+ VALUES ($1, $2, $3, $4, $5, $6, coalesce($7::timestamptz, now()))`,
+ [
+ coreWorkflowId,
+ SEED_APPLE_WORKSPACE_ID,
+ 'Relink Command Spec',
+ workspaceWorkflowId,
+ v4(),
+ applicationId,
+ createdAt ?? null,
+ ],
+ );
+
+ seededCoreWorkflowIds.push(coreWorkflowId);
+
+ return coreWorkflowId;
+ };
+
+ const seedUnlinkedCoreVersion = async (
+ workspaceWorkflowId: string,
+ ): Promise<string> => {
+ const coreVersionId = v4();
+
+ await dataSource.query(
+ `INSERT INTO core."workflowVersion"
+ ("id", "workspaceId", "workflowId", "coreWorkflowId", "status", "universalIdentifier", "applicationId")
+ VALUES ($1, $2, $3, NULL, 'DRAFT', $4, $5)`,
+ [
+ coreVersionId,
+ SEED_APPLE_WORKSPACE_ID,
+ workspaceWorkflowId,
+ v4(),
+ applicationId,
+ ],
+ );
+
+ seededCoreVersionIds.push(coreVersionId);
+
+ return coreVersionId;
+ };
+
+ const readCoreWorkflowIdOfVersion = async (
+ coreVersionId: string,
+ ): Promise<string | null> => {
+ const [row] = await dataSource.query(
+ `SELECT "coreWorkflowId" FROM core."workflowVersion" WHERE "id" = $1`,
+ [coreVersionId],
+ );
+
+ return row?.coreWorkflowId ?? null;
+ };
+
+ const runCommand = async ({ dryRun }: { dryRun?: boolean } = {}) =>
+ command.runOnWorkspace({
+ workspaceId: SEED_APPLE_WORKSPACE_ID,
+ options: { dryRun },
+ index: 0,
+ total: 1,
+ dataSource,
+ });
+
+ beforeAll(async () => {
+ dataSource = new DataSource({
+ type: 'postgres',
+ url: process.env.PG_DATABASE_URL,
+ schema: 'core',
+ entities: [],
+ synchronize: false,
+ });
+
+ await dataSource.initialize();
+
+ command =
+ getAppProviderByClassName<RelinkWorkflowVersionsToCoreWorkflowsCommand>(
+ 'RelinkWorkflowVersionsToCoreWorkflowsCommand',
+ );
+
+ const [workspace] = await dataSource.query(
+ `SELECT "workspaceCustomApplicationId" FROM core."workspace" WHERE "id" = $1`,
+ [SEED_APPLE_WORKSPACE_ID],
+ );
+
+ applicationId = workspace.workspaceCustomApplicationId;
+ });
+
+ afterAll(async () => {
+ if (seededCoreVersionIds.length > 0) {
+ await dataSource.query(
+ `DELETE FROM core."workflowVersion" WHERE "id" = ANY($1::uuid[])`,
+ [seededCoreVersionIds],
+ );
+ }
+
+ if (seededCoreWorkflowIds.length > 0) {
+ await dataSource.query(
+ `DELETE FROM core."workflow" WHERE "id" = ANY($1::uuid[])`,
+ [seededCoreWorkflowIds],
+ );
+ }
+
+ await dataSource.destroy();
+ });
+
+ it('relinks an unlinked version to the core workflow mirroring its workspace workflow', async () => {
+ const workspaceWorkflowId = v4();
+ const coreWorkflowId = await seedCoreWorkflow(workspaceWorkflowId);
+ const coreVersionId = await seedUnlinkedCoreVersion(workspaceWorkflowId);
+
+ expect(await readCoreWorkflowIdOfVersion(coreVersionId)).toBeNull();
+
+ await runCommand();
+
+ expect(await readCoreWorkflowIdOfVersion(coreVersionId)).toBe(
+ coreWorkflowId,
+ );
+ });
+
+ it('leaves a version whose workspace workflow has no core mirror untouched', async () => {
+ const coreVersionId = await seedUnlinkedCoreVersion(v4());
+
+ await runCommand();
+
+ expect(await readCoreWorkflowIdOfVersion(coreVersionId)).toBeNull();
+ });
+
+ it('links to the oldest core workflow when several mirror the same workspace workflow and no pointer resolves', async () => {
+ const workspaceWorkflowId = v4();
+
+ const oldestCoreWorkflowId = await seedCoreWorkflow(
+ workspaceWorkflowId,
+ '2020-01-01T00:00:00.000Z',
+ );
+
+ await seedCoreWorkflow(workspaceWorkflowId, '2021-01-01T00:00:00.000Z');
+
+ const coreVersionId = await seedUnlinkedCoreVersion(workspaceWorkflowId);
+
+ await runCommand();
+
+ expect(await readCoreWorkflowIdOfVersion(coreVersionId)).toBe(
+ oldestCoreWorkflowId,
+ );
+ });
+
+ it('writes nothing on a dry run', async () => {
+ const workspaceWorkflowId = v4();
+
+ await seedCoreWorkflow(workspaceWorkflowId);
+
+ const coreVersionId = await seedUnlinkedCoreVersion(workspaceWorkflowId);
+
+ await runCommand({ dryRun: true });
+
+ expect(await readCoreWorkflowIdOfVersion(coreVersionId)).toBeNull();
+ });
+});