The open alternative to Salesforce, designed for AI.
TypeScript crmcrm-systemcustomergood-first-issuegraphqlhacktoberfestjavascriptmarketingmonoreponestjsopen-sourcepostgresqlreactreactjssalestypescriptweb
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.tsindex 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/wWorkspaceMigrationRunnerModule,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.tsnew file mode 100644index 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.tsindex 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 godiff --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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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();+ });+});