Skip to content

The open alternative to Salesforce, designed for AI.

feat(workflow): add coreWorkflowId to core workflow versions (#25679)

Thomas Trompette0dc40c8764e0
diff --git a/packages/twenty-server/src/database/commands/upgrade-version-command/2-40/2-40-instance-command-fast-1788960408161-add-core-workflow-id-to-workflow-version.ts b/packages/twenty-server/src/database/commands/upgrade-version-command/2-40/2-40-instance-command-fast-1788960408161-add-core-workflow-id-to-workflow-version.ts
new file mode 100644
index 00000000000..3930d837ad7
--- /dev/null
+++ b/packages/twenty-server/src/database/commands/upgrade-version-command/2-40/2-40-instance-command-fast-1788960408161-add-core-workflow-id-to-workflow-version.ts
@@ -0,0 +1,19 @@
+import { type QueryRunner } from 'typeorm';
+
+import { RegisteredInstanceCommand } from 'src/engine/core-modules/upgrade/decorators/registered-instance-command.decorator';
+import { type FastInstanceCommand } from 'src/engine/core-modules/upgrade/interfaces/fast-instance-command.interface';
+
+@RegisteredInstanceCommand('2.40.0', 1788960408161)
+export class AddCoreWorkflowIdToWorkflowVersionFastInstanceCommand implements FastInstanceCommand {
+ public async up(queryRunner: QueryRunner): Promise<void> {
+ await queryRunner.query(
+ `ALTER TABLE "core"."workflowVersion" ADD COLUMN IF NOT EXISTS "coreWorkflowId" uuid`,
+ );
+ }
+
+ public async down(queryRunner: QueryRunner): Promise<void> {
+ await queryRunner.query(
+ `ALTER TABLE "core"."workflowVersion" DROP COLUMN "coreWorkflowId"`,
+ );
+ }
+}
diff --git a/packages/twenty-server/src/database/commands/upgrade-version-command/2-40/2-40-upgrade-version-command.module.ts b/packages/twenty-server/src/database/commands/upgrade-version-command/2-40/2-40-upgrade-version-command.module.ts
index 31c137ed4f2..98641d8c9a3 100644
--- a/packages/twenty-server/src/database/commands/upgrade-version-command/2-40/2-40-upgrade-version-command.module.ts
+++ b/packages/twenty-server/src/database/commands/upgrade-version-command/2-40/2-40-upgrade-version-command.module.ts
@@ -3,6 +3,7 @@ import { Module } from '@nestjs/common';
import { WorkspaceIteratorModule } from 'src/database/commands/command-runners/workspace-iterator.module';
import { SyncRecordShareObjectCommand } from 'src/database/commands/upgrade-version-command/2-40/2-40-workspace-command-1788794677636-sync-record-share-object.command';
import { AddMessageCampaignScheduledAtCommand } from 'src/database/commands/upgrade-version-command/2-40/2-40-workspace-command-1788957151735-add-message-campaign-scheduled-at.command';
+import { BackfillCoreWorkflowIdOnWorkflowVersionsCommand } from 'src/database/commands/upgrade-version-command/2-40/2-40-workspace-command-1788960408162-backfill-core-workflow-id-on-workflow-versions.command';
import { ApplicationModule } from 'src/engine/core-modules/application/application.module';
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';
@@ -21,6 +22,7 @@ import { WorkspaceSchemaMigrationRunnerActionHandlersModule } from 'src/engine/w
providers: [
SyncRecordShareObjectCommand,
AddMessageCampaignScheduledAtCommand,
+ BackfillCoreWorkflowIdOnWorkflowVersionsCommand,
],
})
export class V2_40_UpgradeVersionCommandModule {}
diff --git a/packages/twenty-server/src/database/commands/upgrade-version-command/2-40/2-40-workspace-command-1788960408162-backfill-core-workflow-id-on-workflow-versions.command.ts b/packages/twenty-server/src/database/commands/upgrade-version-command/2-40/2-40-workspace-command-1788960408162-backfill-core-workflow-id-on-workflow-versions.command.ts
new file mode 100644
index 00000000000..f241a7dfacf
--- /dev/null
+++ b/packages/twenty-server/src/database/commands/upgrade-version-command/2-40/2-40-workspace-command-1788960408162-backfill-core-workflow-id-on-workflow-versions.command.ts
@@ -0,0 +1,102 @@
+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 { isWorkspaceObjectNotFoundError } from 'src/database/commands/upgrade-version-command/utils/is-workspace-object-not-found-error.util';
+import { RegisteredWorkspaceCommand } from 'src/engine/core-modules/upgrade/decorators/registered-workspace-command.decorator';
+import { buildSystemAuthContext } from 'src/engine/twenty-orm/utils/build-system-auth-context.util';
+import { WorkspaceOrmManager } from 'src/engine/twenty-orm/workspace-orm.manager';
+import { getWorkspaceSchemaName } from 'src/engine/workspace-datasource/utils/get-workspace-schema-name.util';
+import { type WorkflowWorkspaceEntity } from 'src/modules/workflow/common/standard-objects/workflow.workspace-entity';
+
+@RegisteredWorkspaceCommand('2.40.0', 1788960408162)
+@Command({
+ name: 'upgrade:2-40:backfill-core-workflow-id-on-workflow-versions',
+ description:
+ 'Backfill coreWorkflowId on core workflowVersion rows from the workspace workflow mapping',
+})
+export class BackfillCoreWorkflowIdOnWorkflowVersionsCommand extends ProvisionedWorkspaceCommandRunner {
+ constructor(
+ protected readonly workspaceIteratorService: WorkspaceIteratorService,
+ private readonly workspaceOrmManager: WorkspaceOrmManager,
+ ) {
+ super(workspaceIteratorService);
+ }
+
+ override async runOnWorkspace({
+ workspaceId,
+ options,
+ dataSource,
+ }: RunOnWorkspaceArgs): Promise<void> {
+ if (!isDefined(dataSource)) {
+ return;
+ }
+
+ try {
+ await this.workspaceOrmManager.executeInWorkspaceContext(async () => {
+ const workflowRepository =
+ this.workspaceOrmManager.getRepository<WorkflowWorkspaceEntity>(
+ 'workflow',
+ { shouldBypassPermissionChecks: true },
+ );
+
+ return workflowRepository.count();
+ }, buildSystemAuthContext(workspaceId));
+ } catch (error) {
+ if (isWorkspaceObjectNotFoundError(error)) {
+ return;
+ }
+
+ throw error;
+ }
+
+ const schema = getWorkspaceSchemaName(workspaceId);
+
+ const backfillClause = `
+ "${schema}"."workflow" w
+ WHERE cv."workspaceId" = $1
+ AND cv."coreWorkflowId" IS NULL
+ AND cv."workflowId" = w.id
+ AND w."coreWorkflowId" IS NOT NULL`;
+
+ const queryRunner = dataSource.createQueryRunner();
+
+ await queryRunner.connect();
+
+ try {
+ const [counts] = await queryRunner.query(
+ `SELECT count(*)::int AS total
+ FROM core."workflowVersion" cv,
+ ${backfillClause}`,
+ [workspaceId],
+ );
+
+ if (counts.total === 0) {
+ return;
+ }
+
+ if (options.dryRun) {
+ this.logger.log(
+ `[DRY RUN] Would backfill coreWorkflowId on ${counts.total} core workflowVersion row(s) for workspace ${workspaceId}`,
+ );
+
+ return;
+ }
+
+ await queryRunner.query(
+ `UPDATE core."workflowVersion" cv
+ SET "coreWorkflowId" = w."coreWorkflowId"
+ FROM ${backfillClause}`,
+ [workspaceId],
+ );
+
+ this.logger.log(
+ `Backfilled coreWorkflowId on ${counts.total} core workflowVersion row(s) for workspace ${workspaceId}`,
+ );
+ } finally {
+ await queryRunner.release();
+ }
+ }
+}
diff --git a/packages/twenty-server/src/database/commands/upgrade-version-command/2-40/__tests__/2-40-workspace-command-1788960408162-backfill-core-workflow-id-on-workflow-versions.command.spec.ts b/packages/twenty-server/src/database/commands/upgrade-version-command/2-40/__tests__/2-40-workspace-command-1788960408162-backfill-core-workflow-id-on-workflow-versions.command.spec.ts
new file mode 100644
index 00000000000..d096bd5ff6c
--- /dev/null
+++ b/packages/twenty-server/src/database/commands/upgrade-version-command/2-40/__tests__/2-40-workspace-command-1788960408162-backfill-core-workflow-id-on-workflow-versions.command.spec.ts
@@ -0,0 +1,132 @@
+import { type DataSource } from 'typeorm';
+
+import {
+ TwentyOrmException,
+ TwentyOrmExceptionCode,
+} from 'src/engine/twenty-orm/exceptions/twenty-orm.exception';
+
+import { type WorkspaceIteratorService } from 'src/database/commands/command-runners/workspace-iterator.service';
+import { BackfillCoreWorkflowIdOnWorkflowVersionsCommand } from 'src/database/commands/upgrade-version-command/2-40/2-40-workspace-command-1788960408162-backfill-core-workflow-id-on-workflow-versions.command';
+import { type WorkspaceOrmManager } from 'src/engine/twenty-orm/workspace-orm.manager';
+
+const WORKSPACE_ID = '20202020-0000-0000-0000-000000000001';
+
+const isUpdate = (sql: unknown) =>
+ typeof sql === 'string' && sql.trimStart().startsWith('UPDATE');
+
+const setup = ({
+ total = 0,
+ objectMissing = false,
+}: {
+ total?: number;
+ objectMissing?: boolean;
+} = {}) => {
+ const query = jest.fn(async (...args: unknown[]) => {
+ const sql = args[0] as string;
+
+ if (isUpdate(sql)) {
+ return [];
+ }
+ if (sql.includes('count(*)')) {
+ return [{ total }];
+ }
+
+ return [];
+ });
+
+ const queryRunner = {
+ connect: jest.fn(),
+ release: jest.fn(),
+ query,
+ };
+
+ const count = objectMissing
+ ? jest
+ .fn()
+ .mockRejectedValue(
+ new TwentyOrmException(
+ 'Object "workflow" does not exist in this workspace',
+ TwentyOrmExceptionCode.UNKNOWN_OBJECT,
+ ),
+ )
+ : jest.fn().mockResolvedValue(0);
+
+ const dataSource = {
+ createQueryRunner: () => queryRunner,
+ } as unknown as DataSource;
+
+ const workspaceOrmManager = {
+ executeInWorkspaceContext: (fn: () => Promise<unknown>) => fn(),
+ getRepository: () => ({ count }),
+ } as unknown as WorkspaceOrmManager;
+
+ const command = new BackfillCoreWorkflowIdOnWorkflowVersionsCommand(
+ {} as WorkspaceIteratorService,
+ workspaceOrmManager,
+ );
+
+ const run = (dryRun = false) =>
+ command.runOnWorkspace({
+ workspaceId: WORKSPACE_ID,
+ dataSource: dataSource as never,
+ options: { dryRun },
+ index: 0,
+ total: 1,
+ });
+
+ return { run, query };
+};
+
+describe('BackfillCoreWorkflowIdOnWorkflowVersionsCommand', () => {
+ beforeEach(() => jest.clearAllMocks());
+
+ it('backfills only unset rows from workflows that carry a core workflow id', async () => {
+ const { run, query } = setup({ total: 3 });
+
+ await run();
+
+ const updateCall = query.mock.calls.find((call) => isUpdate(call[0]));
+
+ expect(updateCall?.[0]).toContain(
+ 'SET "coreWorkflowId" = w."coreWorkflowId"',
+ );
+ expect(updateCall?.[0]).toContain('cv."coreWorkflowId" IS NULL');
+ expect(updateCall?.[0]).toContain('w."coreWorkflowId" IS NOT NULL');
+ expect(updateCall?.[0]).toContain('cv."workflowId" = w.id');
+ expect(updateCall?.[1]).toEqual([WORKSPACE_ID]);
+ });
+
+ it('does not filter out soft-deleted workspace workflows', async () => {
+ const { run, query } = setup({ total: 1 });
+
+ await run();
+
+ const updateCall = query.mock.calls.find((call) => isUpdate(call[0]));
+
+ expect(updateCall?.[0]).not.toContain('deletedAt');
+ });
+
+ it('does not update on a dry run', async () => {
+ const { run, query } = setup({ total: 3 });
+
+ await run(true);
+
+ expect(query.mock.calls.some((call) => isUpdate(call[0]))).toBe(false);
+ });
+
+ it('is a no-op when every row is already backfilled', async () => {
+ const { run, query } = setup({ total: 0 });
+
+ await run();
+
+ expect(query.mock.calls.some((call) => isUpdate(call[0]))).toBe(false);
+ });
+
+ it('skips a workspace that never provisioned the workflow object', async () => {
+ const { run, query } = setup({ total: 3, objectMissing: true });
+
+ await run();
+
+ expect(query).not.toHaveBeenCalled();
+ });
+});
diff --git a/packages/twenty-server/src/database/commands/upgrade-version-command/2-40/add-core-workflow-id-to-workflow-version-upgrade-command-name.constant.ts b/packages/twenty-server/src/database/commands/upgrade-version-command/2-40/add-core-workflow-id-to-workflow-version-upgrade-command-name.constant.ts
new file mode 100644
index 00000000000..533c20ccd0e
--- /dev/null
+++ b/packages/twenty-server/src/database/commands/upgrade-version-command/2-40/add-core-workflow-id-to-workflow-version-upgrade-command-name.constant.ts
@@ -0,0 +1,2 @@
+export const ADD_CORE_WORKFLOW_ID_TO_WORKFLOW_VERSION_UPGRADE_COMMAND_NAME =
+ '2.40.0_AddCoreWorkflowIdToWorkflowVersionFastInstanceCommand_1788960408161';
diff --git a/packages/twenty-server/src/database/commands/upgrade-version-command/instance-commands.constant.ts b/packages/twenty-server/src/database/commands/upgrade-version-command/instance-commands.constant.ts
index fa8ae292e5b..0ff8511831b 100644
--- a/packages/twenty-server/src/database/commands/upgrade-version-command/instance-commands.constant.ts
+++ b/packages/twenty-server/src/database/commands/upgrade-version-command/instance-commands.constant.ts
@@ -183,6 +183,7 @@ import { MakeBillingCreditGrantExpiresAtNullableFastInstanceCommand } from 'src/
import { ConvertLiveCreditGrantsToNoExpirySlowInstanceCommand } from 'src/database/commands/upgrade-version-command/2-40/2-40-instance-command-slow-1788877128693-convert-live-credit-grants-to-no-expiry';
import { AddIsAuditLoggedToFieldMetadataFastInstanceCommand } from 'src/database/commands/upgrade-version-command/2-40/2-40-instance-command-fast-1788885873410-add-is-audit-logged-to-field-metadata';
import { BackfillIsAuditLoggedOnPositionFieldMetadataSlowInstanceCommand } from 'src/database/commands/upgrade-version-command/2-40/2-40-instance-command-slow-1788885873411-backfill-is-audit-logged-on-position-field-metadata';
+import { AddCoreWorkflowIdToWorkflowVersionFastInstanceCommand } from 'src/database/commands/upgrade-version-command/2-40/2-40-instance-command-fast-1788960408161-add-core-workflow-id-to-workflow-version';
export const INSTANCE_COMMANDS = [
AddViewFieldGroupIdIndexOnViewFieldFastInstanceCommand,
@@ -368,4 +369,5 @@ export const INSTANCE_COMMANDS = [
ConvertLiveCreditGrantsToNoExpirySlowInstanceCommand,
AddIsAuditLoggedToFieldMetadataFastInstanceCommand,
BackfillIsAuditLoggedOnPositionFieldMetadataSlowInstanceCommand,
+ AddCoreWorkflowIdToWorkflowVersionFastInstanceCommand,
];
diff --git a/packages/twenty-server/src/engine/core-modules/workflow/entities/workflow-version.entity.ts b/packages/twenty-server/src/engine/core-modules/workflow/entities/workflow-version.entity.ts
index 02835d09818..a5ffc3a5d82 100644
--- a/packages/twenty-server/src/engine/core-modules/workflow/entities/workflow-version.entity.ts
+++ b/packages/twenty-server/src/engine/core-modules/workflow/entities/workflow-version.entity.ts
@@ -8,6 +8,7 @@ import {
} from 'typeorm';
import { CREATE_WORKFLOW_VERSION_CORE_TABLE_UPGRADE_COMMAND_NAME } from 'src/database/commands/upgrade-version-command/2-20/create-workflow-version-core-table-upgrade-command-name.constant';
+import { ADD_CORE_WORKFLOW_ID_TO_WORKFLOW_VERSION_UPGRADE_COMMAND_NAME } from 'src/database/commands/upgrade-version-command/2-40/add-core-workflow-id-to-workflow-version-upgrade-command-name.constant';
import { WasIntroducedInUpgrade } from 'src/engine/core-modules/upgrade/decorators/was-introduced-in-upgrade.decorator';
import { SyncableEntity } from 'src/engine/workspace-manager/types/syncable-entity.interface';
import { type WorkflowAction } from 'src/modules/workflow/workflow-executor/workflow-actions/types/workflow-action.type';
@@ -55,6 +56,13 @@ export class WorkflowVersionEntity extends SyncableEntity {
@Column({ type: 'uuid', nullable: false })
workflowId: string;
+ @WasIntroducedInUpgrade({
+ upgradeCommandName:
+ ADD_CORE_WORKFLOW_ID_TO_WORKFLOW_VERSION_UPGRADE_COMMAND_NAME,
+ })
+ @Column({ type: 'uuid', nullable: true })
+ coreWorkflowId: string | null;
+
@CreateDateColumn({ type: 'timestamptz' })
createdAt: Date;
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 e914bc98eb9..c04d271f820 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
@@ -21,6 +21,7 @@ import { WorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scope
import { buildSystemAuthContext } from 'src/engine/twenty-orm/utils/build-system-auth-context.util';
import { WorkspaceCacheService } from 'src/engine/workspace-cache/services/workspace-cache.service';
import { type WorkflowVersionWorkspaceEntity } from 'src/modules/workflow/common/standard-objects/workflow-version.workspace-entity';
+import { type WorkflowWorkspaceEntity } from 'src/modules/workflow/common/standard-objects/workflow.workspace-entity';
@Injectable()
export class WorkflowVersionCoreSyncService {
@@ -46,7 +47,13 @@ export class WorkflowVersionCoreSyncService {
const applicationId = await this.getCustomApplicationIdOrThrow(workspaceId);
- const linkedCoreVersionIds = await this.resolveOwnedCoreVersionIds(
+ const coreWorkflowIdByWorkflowId =
+ await this.resolveCoreWorkflowIdByWorkflowId(
+ workspaceId,
+ workflowVersions.map((workflowVersion) => workflowVersion.workflowId),
+ );
+
+ const ownedCoreVersions = await this.resolveOwnedCoreVersions(
workspaceId,
workflowVersions,
);
@@ -58,7 +65,7 @@ export class WorkflowVersionCoreSyncService {
const linkedCoreVersionId =
isNonEmptyString(candidateCoreVersionId) &&
- linkedCoreVersionIds.has(candidateCoreVersionId)
+ ownedCoreVersions.has(candidateCoreVersionId)
? candidateCoreVersionId
: null;
@@ -71,9 +78,16 @@ export class WorkflowVersionCoreSyncService {
);
}
+ const resolvedCoreWorkflowId =
+ coreWorkflowIdByWorkflowId.get(workflowVersion.workflowId) ??
+ (isDefined(linkedCoreVersionId)
+ ? (ownedCoreVersions.get(linkedCoreVersionId) ?? null)
+ : null);
+
return {
id: coreWorkflowVersionId,
workflowId: workflowVersion.workflowId,
+ coreWorkflowId: resolvedCoreWorkflowId,
triggers: isDefined(workflowVersion.trigger)
? [workflowVersion.trigger]
: null,
@@ -97,27 +111,29 @@ export class WorkflowVersionCoreSyncService {
}
// Same caller-writable column as coreWorkflowId, see WorkflowCoreSyncService.
- private async resolveOwnedCoreVersionIds(
+ private async resolveOwnedCoreVersions(
workspaceId: string,
workflowVersions: WorkflowVersionWorkspaceEntity[],
- ): Promise<Set<string>> {
+ ): Promise<Map<string, string | null>> {
const candidateIds = workflowVersions
.map((workflowVersion) => workflowVersion.coreWorkflowVersionId)
.filter(isNonEmptyString);
if (candidateIds.length === 0) {
- return new Set();
+ return new Map();
}
const ownedRows = await this.coreWorkflowVersionRepository.find(
workspaceId,
{
where: { id: In(candidateIds) },
- select: { id: true },
+ select: { id: true, coreWorkflowId: true },
},
);
- return new Set(ownedRows.map((row) => row.id));
+ return new Map(
+ ownedRows.map((row) => [row.id, row.coreWorkflowId ?? null]),
+ );
}
async deleteFromCore(
@@ -181,17 +197,23 @@ export class WorkflowVersionCoreSyncService {
const isNewLink = !isDefined(linkedCoreVersionId);
const coreWorkflowVersionId = linkedCoreVersionId ?? uuidv4();
+ const coreWorkflowId = await this.resolveCoreWorkflowIdInTransaction(
+ 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
// and steps overwritten.
await transactionScope.executeRawQuery(
`INSERT INTO core."workflowVersion"
- ("id", "workspaceId", "workflowId", "triggers", "steps", "status", "universalIdentifier", "applicationId")
- VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
+ ("id", "workspaceId", "workflowId", "triggers", "steps", "status", "universalIdentifier", "applicationId", "coreWorkflowId")
+ VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)
ON CONFLICT ("id") DO UPDATE SET
"triggers" = EXCLUDED."triggers",
"steps" = EXCLUDED."steps",
- "status" = EXCLUDED."status"
+ "status" = EXCLUDED."status",
+ "coreWorkflowId" = COALESCE(EXCLUDED."coreWorkflowId", core."workflowVersion"."coreWorkflowId")
WHERE core."workflowVersion"."workspaceId" = EXCLUDED."workspaceId"`,
[
coreWorkflowVersionId,
@@ -206,6 +228,7 @@ export class WorkflowVersionCoreSyncService {
workflowVersion.status,
uuidv4(),
resolvedApplicationId,
+ coreWorkflowId,
],
);
@@ -220,6 +243,62 @@ export class WorkflowVersionCoreSyncService {
return { coreWorkflowVersionId };
}
+ private async resolveCoreWorkflowIdByWorkflowId(
+ workspaceId: string,
+ workflowIds: string[],
+ ): Promise<Map<string, string>> {
+ const distinctWorkflowIds = [...new Set(workflowIds)];
+
+ if (distinctWorkflowIds.length === 0) {
+ return new Map();
+ }
+
+ const workflows = await this.workspaceOrmManager.executeInWorkspaceContext(
+ async () => {
+ const workflowRepository =
+ this.workspaceOrmManager.getRepository<WorkflowWorkspaceEntity>(
+ 'workflow',
+ { shouldBypassPermissionChecks: true },
+ );
+
+ return workflowRepository.find({
+ where: { id: In(distinctWorkflowIds) },
+ withDeleted: true,
+ });
+ },
+ buildSystemAuthContext(workspaceId),
+ );
+
+ const coreWorkflowIdByWorkflowId = new Map<string, string>();
+
+ for (const workflow of workflows) {
+ if (isNonEmptyString(workflow.coreWorkflowId)) {
+ coreWorkflowIdByWorkflowId.set(workflow.id, workflow.coreWorkflowId);
+ }
+ }
+
+ return coreWorkflowIdByWorkflowId;
+ }
+
+ private async resolveCoreWorkflowIdInTransaction(
+ workflowId: string,
+ transactionScope: WorkspaceTransactionScope,
+ ): Promise<string | null> {
+ const workflowRepository =
+ transactionScope.getRepository<WorkflowWorkspaceEntity>('workflow', {
+ shouldBypassPermissionChecks: true,
+ });
+
+ const workflow = await workflowRepository.findOne({
+ where: { id: workflowId },
+ withDeleted: true,
+ });
+
+ const coreWorkflowId = workflow?.coreWorkflowId ?? null;
+
+ return isNonEmptyString(coreWorkflowId) ? coreWorkflowId : null;
+ }
+
// Must run inside the caller's transaction so the ownership answer cannot go
// stale before the insert below uses it.
private async isCoreVersionOwnedByWorkspace({
diff --git a/packages/twenty-server/src/engine/workspace-manager/standard-objects-prefill-data/utils/prefill-workflows.util.ts b/packages/twenty-server/src/engine/workspace-manager/standard-objects-prefill-data/utils/prefill-workflows.util.ts
index 29bd8d6db79..7483a4bc711 100644
--- a/packages/twenty-server/src/engine/workspace-manager/standard-objects-prefill-data/utils/prefill-workflows.util.ts
+++ b/packages/twenty-server/src/engine/workspace-manager/standard-objects-prefill-data/utils/prefill-workflows.util.ts
@@ -887,6 +887,7 @@ export const prefillWorkflows = async (
'steps',
'status',
'workflowId',
+ 'coreWorkflowId',
])
.orIgnore()
.values([
@@ -899,6 +900,7 @@ export const prefillWorkflows = async (
steps: JSON.parse(quickLeadSteps),
status: 'ACTIVE',
workflowId: quickLeadWorkflowId,
+ coreWorkflowId: coreQuickLeadWorkflowId,
},
{
id: coreCreateCompanyWorkflowVersionId,
@@ -909,6 +911,7 @@ export const prefillWorkflows = async (
steps: JSON.parse(createCompanySteps),
status: 'ACTIVE',
workflowId: createCompanyWorkflowId,
+ coreWorkflowId: coreCreateCompanyWorkflowId,
},
])
.execute();
diff --git a/packages/twenty-server/test/integration/graphql/suites/workflow/workflow-version-core-workflow-id.integration-spec.ts b/packages/twenty-server/test/integration/graphql/suites/workflow/workflow-version-core-workflow-id.integration-spec.ts
new file mode 100644
index 00000000000..968415a294b
--- /dev/null
+++ b/packages/twenty-server/test/integration/graphql/suites/workflow/workflow-version-core-workflow-id.integration-spec.ts
@@ -0,0 +1,151 @@
+import request from 'supertest';
+import { updateWorkflowVersionTrigger } from 'test/integration/graphql/suites/workflow/utils/update-workflow-version-trigger.util';
+import { assertIsDefinedOrThrow, isDefined } from 'twenty-shared/utils';
+
+import { getWorkspaceSchemaName } from 'src/engine/workspace-datasource/utils/get-workspace-schema-name.util';
+import { SEED_APPLE_WORKSPACE_ID } from 'src/engine/workspace-manager/dev-seeder/core/constants/seeder-workspaces.constant';
+
+const client = request(`http://localhost:${APP_PORT}`);
+
+const graphql = (query: string, variables?: object) =>
+ client
+ .post('/graphql')
+ .set('Authorization', `Bearer ${APPLE_JANE_ADMIN_ACCESS_TOKEN}`)
+ .send({ query, variables });
+
+const WORKSPACE_SCHEMA = getWorkspaceSchemaName(SEED_APPLE_WORKSPACE_ID);
+
+const POLL_ATTEMPTS = 20;
+const POLL_INTERVAL_MS = 250;
+
+describe('workflow version core workflow id dual write (e2e)', () => {
+ let workflowId: string;
+ let workflowVersionId: string;
+
+ const fetchWorkspaceCoreWorkflowId = async (): Promise<
+ string | null | undefined
+ > => {
+ const rows = await global.testDataSource.query(
+ `SELECT "coreWorkflowId" FROM "${WORKSPACE_SCHEMA}"."workflow" WHERE "id" = $1`,
+ [workflowId],
+ );
+
+ return rows[0]?.coreWorkflowId;
+ };
+
+ const waitForWorkspaceCoreWorkflowId = async (): Promise<
+ string | null | undefined
+ > => {
+ for (let attempt = 0; attempt < POLL_ATTEMPTS; attempt++) {
+ const coreWorkflowId = await fetchWorkspaceCoreWorkflowId();
+
+ if (isDefined(coreWorkflowId)) {
+ return coreWorkflowId;
+ }
+
+ await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
+ }
+
+ return fetchWorkspaceCoreWorkflowId();
+ };
+
+ const countCoreVersionRowsPointingAt = async (
+ coreWorkflowId: string,
+ ): Promise<number> => {
+ const rows = await global.testDataSource.query(
+ `SELECT cv."id" FROM core."workflowVersion" cv
+ JOIN core."workflow" cw ON cw."id" = cv."coreWorkflowId"
+ WHERE cv."workspaceId" = $1
+ AND cv."workflowId" = $2
+ AND cv."coreWorkflowId" = $3`,
+ [SEED_APPLE_WORKSPACE_ID, workflowId, coreWorkflowId],
+ );
+
+ return rows.length;
+ };
+
+ const waitForCoreVersionRowsPointingAt = async (
+ coreWorkflowId: string,
+ ): Promise<number> => {
+ for (let attempt = 0; attempt < POLL_ATTEMPTS; attempt++) {
+ const count = await countCoreVersionRowsPointingAt(coreWorkflowId);
+
+ if (count > 0) {
+ return count;
+ }
+
+ await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
+ }
+
+ return countCoreVersionRowsPointingAt(coreWorkflowId);
+ };
+
+ beforeAll(async () => {
+ const createResponse = await graphql(`
+ mutation {
+ createWorkflow(data: { name: "Core Workflow Id Dual Write" }) {
+ id
+ }
+ }
+ `);
+
+ expect(createResponse.body.errors).toBeUndefined();
+ workflowId = createResponse.body.data.createWorkflow.id;
+
+ const getResponse = await graphql(
+ `
+ query GetWorkflow($id: UUID!) {
+ workflow(filter: { id: { eq: $id } }) {
+ versions {
+ edges {
+ node {
+ id
+ }
+ }
+ }
+ }
+ }
+ `,
+ { id: workflowId },
+ );
+
+ workflowVersionId =
+ getResponse.body.data.workflow.versions.edges[0].node.id;
+ });
+
+ afterAll(async () => {
+ if (workflowId) {
+ await graphql(
+ `
+ mutation DestroyWorkflow($id: ID!) {
+ destroyWorkflow(id: $id) {
+ id
+ }
+ }
+ `,
+ { id: workflowId },
+ );
+ }
+ });
+
+ it('stamps the core version row with the core workflow id on mirror writes', async () => {
+ const coreWorkflowId = await waitForWorkspaceCoreWorkflowId();
+
+ assertIsDefinedOrThrow(coreWorkflowId);
+
+ await updateWorkflowVersionTrigger({
+ workflowVersionId,
+ trigger: {
+ name: 'Manual Trigger',
+ type: 'MANUAL',
+ settings: { outputSchema: {} },
+ nextStepIds: [],
+ position: { x: 0, y: 0 },
+ },
+ });
+
+ expect(
+ await waitForCoreVersionRowsPointingAt(coreWorkflowId),
+ ).toBeGreaterThan(0);
+ });
+});