The open alternative to Salesforce, designed for AI.
TypeScript crmcrm-systemcustomergood-first-issuegraphqlhacktoberfestjavascriptmarketingmonoreponestjsopen-sourcepostgresqlreactreactjssalestypescriptweb
feat(workflow): core-only workflow execution and background processing (#26098)
Thomas Trompette4176ec634453
diff --git a/packages/twenty-server/@types/jest.d.ts b/packages/twenty-server/@types/jest.d.tsindex 38954c3a655..2bc6e852fe3 100644--- a/packages/twenty-server/@types/jest.d.ts+++ b/packages/twenty-server/@types/jest.d.ts@@ -1,3 +1,4 @@+import { type createWorkflowTestServices } from '../test/integration/utils/create-workflow-test-services';import { type INestApplication } from '@nestjs/common';import 'jest';@@ -32,6 +33,7 @@ declare global {const APPLE_SARAH_IMPERSONATE_TIM_INVALID_ACCESS_TOKEN: string;var testDataSource: DataSource;+ var workflowTestServices: ReturnType<typeof createWorkflowTestServices>;var app: INestApplication;var dataSourceService: DataSourceService;}diff --git a/packages/twenty-server/docs/WORKFLOW_CORE_EXECUTION.md b/packages/twenty-server/docs/WORKFLOW_CORE_EXECUTION.mdnew file mode 100644index 00000000000..e629ef883e0--- /dev/null+++ b/packages/twenty-server/docs/WORKFLOW_CORE_EXECUTION.md@@ -0,0 +1,52 @@+# Core workflow execution++Workflow execution uses `core.workflow`, `core.workflowVersion`, and the persisted run snapshot. The workflow UI feature flag only selects editing and display APIs. Turning it off does not switch workers back to workspace definitions.++## Storage and compatibility++| Field | Purpose and lifetime |+| --- | --- |+| `core.workflow.id` | Authoritative workflow identity. |+| `core.workflowVersion.coreWorkflowId` | Authoritative version parent, scoped to the same workspace. |+| `core.workflow.workspaceWorkflowId` | Durable alias for existing webhook URLs and historical billing spender IDs. Keep this alias for the lifetime of those URLs and billing identities. |+| `core.workflowVersion.workspaceWorkflowVersionId` | Durable alias for legacy run requests and pinned queued payloads. Keep it while any legacy callers or queued jobs can exist. |+| `core.workflowVersion.workflowId` | Nullable legacy parent alias maintained for rollback projections. It is not the execution parent. |+| `workflowRun.coreWorkflowId`, `workflowRun.coreWorkflowVersionId` | Authoritative identities recorded when a run is created and backfilled for existing runs. |+| `workflowRun.workflowId`, `workflowRun.workflowVersionId` | Nullable projection relations. Mirrorless runs leave both null. |+| `workflowRun.state.flow` | Captured trigger and steps. Startup, retry, delay, and form continuation use this snapshot rather than a subsequently edited definition. |++Legacy and core run mutations delegate to the same core runner. Core-owned mappings determine projection relation values and billing spenders. Missing or conflicting tenant, parent, or version mappings fail explicitly. A webhook alias can resolve only a workflow in the requested workspace, and its published version must belong to that workflow, be active, and have a webhook trigger.++## Background execution inventory++| Entry point | Definition source |+| --- | --- |+| `WorkflowTriggerJob` | Core version supplied in the payload; otherwise the durable legacy version mapping; otherwise the core workflow's published pointer for genuinely unversioned legacy jobs. |+| `RunWorkflowJob` startup | Pinned core version identity and the run's captured trigger and steps. |+| `RunWorkflowJob` resume and retry | Persisted run state and step information. |+| `ResumeDelayedWorkflowJob` and form submission | Existing run ID and step ID; the continuation reads the run snapshot. |+| Database event listener | Core-derived automated trigger cache, with workspace business records and metadata used for filtering. |+| `WorkflowCronTriggerCronJob` | Current active core cron definition, including when decoding old Redis entries. |+| Enqueue sweeps, throttling, stalled-run repair | Workspace run rows and run counters; no workflow definition lookup. |+| Workflow run retention | Core workflow identity, with a legacy fallback for historical runs. |+| `WorkflowStatusesUpdateJob` | Workspace projections for UI status maintenance only. |+| `WorkflowCoreConsistencyService` | Compares core definitions and rollback projections for diagnostics. Missing projections are distinguished from missing core definitions; mirrorless definitions are not classified as orphaned. |++Cron workers share the historical workflow lock key for mapped workflows and the core ID for mirrorless workflows. Cached cron entries are normalized before taking the lock, so an obsolete entry cannot consume the current definition's occurrence. Queue producers retain legacy aliases when available, and consumers continue accepting old envelopes.++## Writes++Dedicated legacy builder and lifecycle mutations mirror execution changes within their transactions. Generated single and bulk workflow creation use the existing workflow writer to create the core parent before inserting initial versions. Version mirroring resolves an existing parent. Initial versions and core-created drafts persist the durable version alias synchronously. Generic workflow mutations cannot change execution links directly; generic version content and lifecycle writes remain restricted to dedicated mutations. Allowed workflow updates, deletion, and restoration synchronize core before returning.++Core writes use workspace repositories for outgoing projection changes, preserving database events. The reverse workflow listener uses event IDs to lock and read current workspace records. It does not apply historical event snapshots, preventing a delayed update or delete event from overwriting a newer projection.++## Deployment and rollback++1. Include the parent-link repair and core mutation prerequisites. The core API prerequisite owns the 2.42 version-alias schema and backfill; both APIs and execution use that same alias. Apply that schema command and the 2.42 execution-compatibility schema command before deploying consumers that select the alias. The latter makes the legacy parent nullable and enforces unambiguous version aliases; it does not create a second alias column.+2. Establish a write barrier for the initial cutover: pause workflow mutation and run API traffic, application imports and workspace provisioning, schedulers, database-event dispatch, and workflow consumers. Wait for in-flight transactions to finish. Keep queued and delayed jobs intact. Old writers do not populate the new version alias, so running a backfill while those writers remain active is unsafe.+3. With that barrier held, run the 2.42 parent-link repair, shared version-alias backfill, workflow execution mapping backfill, and projection-nullability command. Dry-run and resolve reported mapping conflicts, then commit and verify the backfill. The execution backfill requires the shared aliases to be populated, then validates pending runs and published pointers transactionally; it does not overwrite or independently populate version aliases.+4. Deploy upgraded workers and queue consumers before the API and scheduler producers. Keep the barrier until every definition writer uses synchronous durable mappings and every consumer supports core-only execution. Then resume traffic and consumers. A UI flag change does not establish this barrier. A zero-downtime rollout instead requires a separate preparatory release that maintains the durable mappings on every writer before the backfill; this PR does not assume that release already exists.+5. Verify old webhook URLs, legacy version requests, queued runs, delayed jobs, form continuations, and cron overlap. No queue purge or delayed-job renaming is required. Compatible envelopes allow old queued work to drain after the cutover; do not resume old definition writers or introduce mirrorless producers while old consumers remain.+6. The UI flag can move ON → OFF → ON independently. Preserve synchronous projections during the rollback window; run execution remains core-only throughout. Rolling the binaries back also requires pausing writes and consumers and re-establishing mappings before the next core-only cutover.++Do not drop legacy payload decoding or aliases merely because the UI rollback window has ended. Delayed jobs and integrations can outlive that window. Removing workspace workflow objects, rebuilding workflow show pages, rekeying MCP tools, and migrating historical usage are separate changes.diff --git a/packages/twenty-server/src/database/commands/upgrade-version-command/2-42/2-42-instance-command-fast-1789719131000-add-workflow-execution-compatibility.ts b/packages/twenty-server/src/database/commands/upgrade-version-command/2-42/2-42-instance-command-fast-1789719131000-add-workflow-execution-compatibility.tsnew file mode 100644index 00000000000..e46e6cdfdc7--- /dev/null+++ b/packages/twenty-server/src/database/commands/upgrade-version-command/2-42/2-42-instance-command-fast-1789719131000-add-workflow-execution-compatibility.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.42.0', 1789719131000)+export class AddWorkflowExecutionCompatibilityFastInstanceCommand implements FastInstanceCommand {+ public async up(queryRunner: QueryRunner): Promise<void> {+ await queryRunner.query('DROP INDEX IF EXISTS "core"."IDX_WORKFLOW_VERSION_WORKSPACE_WORKFLOW_VERSION_ID"');+ await queryRunner.query('ALTER TABLE "core"."workflowVersion" ALTER COLUMN "workflowId" DROP NOT NULL');+ await queryRunner.query('CREATE UNIQUE INDEX IF NOT EXISTS "IDX_WORKFLOW_VERSION_WORKSPACE_VERSION_ID" ON "core"."workflowVersion" ("workspaceId", "workspaceWorkflowVersionId") WHERE "workspaceWorkflowVersionId" IS NOT NULL');+ }++ public async down(queryRunner: QueryRunner): Promise<void> {+ await queryRunner.query('DROP INDEX IF EXISTS "core"."IDX_WORKFLOW_VERSION_WORKSPACE_VERSION_ID"');+ await queryRunner.query('ALTER TABLE "core"."workflowVersion" ALTER COLUMN "workflowId" SET NOT NULL');+ await queryRunner.query('CREATE INDEX IF NOT EXISTS "IDX_WORKFLOW_VERSION_WORKSPACE_WORKFLOW_VERSION_ID" ON "core"."workflowVersion" ("workspaceId", "workspaceWorkflowVersionId")');+ }+}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 6847bf7f5fd..6dd4015bc87 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@@ -1,4 +1,6 @@import { BackfillWorkspaceWorkflowVersionIdCommand } from 'src/database/commands/upgrade-version-command/2-42/2-42-workspace-command-1789652804001-backfill-workspace-workflow-version-id.command';+import { BackfillWorkflowExecutionCoreIdsCommand } from 'src/database/commands/upgrade-version-command/2-42/2-42-workspace-command-1789719131001-backfill-workflow-execution-core-ids.command';+import { MakeWorkflowRunProjectionRelationsNullableCommand } from 'src/database/commands/upgrade-version-command/2-42/2-42-workspace-command-1789719131002-make-workflow-run-projection-relations-nullable.command';import { Module } from '@nestjs/common';import { WorkspaceIteratorModule } from 'src/database/commands/command-runners/workspace-iterator.module';@@ -26,6 +28,8 @@ import { WorkspaceSchemaMigrationRunnerActionHandlersModule } from 'src/engine/wUnpinCreationCommandsOnRecordSelectionCommand,RelinkWorkflowVersionsToCoreWorkflowsCommand,BackfillWorkspaceWorkflowVersionIdCommand,+ BackfillWorkflowExecutionCoreIdsCommand,+ MakeWorkflowRunProjectionRelationsNullableCommand,BackfillMissingSystemRelationIndexesCommand,],exports: [RelinkWorkflowVersionsToCoreWorkflowsCommand],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.tsindex 765a192fb5f..10760e2bbc0 100644--- 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@@ -5,6 +5,7 @@ import { ProvisionedWorkspaceCommandRunner } from 'src/database/commands/commandimport { 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 { hasCoreWorkflowWorkspaceWorkflowIdColumn } from 'src/engine/core-modules/workflow/utils/has-core-workflow-workspace-workflow-id-column.util';import { getWorkspaceSchemaName } from 'src/engine/workspace-datasource/utils/get-workspace-schema-name.util';@RegisteredWorkspaceCommand('2.42.0', 1789645879295)@@ -72,6 +73,18 @@ export class RelinkWorkflowVersionsToCoreWorkflowsCommand extends ProvisionedWorreturn;}+ if (+ !(await hasCoreWorkflowWorkspaceWorkflowIdColumn((query) =>+ queryRunner.query(query),+ ))+ ) {+ this.logger.warn(+ `core.workflow.workspaceWorkflowId missing for workspace ${workspaceId}, skipping relink`,+ );++ return;+ }+const [counts] = await queryRunner.query(`SELECT count(*)::int AS totalFROM core."workflowVersion" vdiff --git a/packages/twenty-server/src/database/commands/upgrade-version-command/2-42/2-42-workspace-command-1789719131001-backfill-workflow-execution-core-ids.command.ts b/packages/twenty-server/src/database/commands/upgrade-version-command/2-42/2-42-workspace-command-1789719131001-backfill-workflow-execution-core-ids.command.tsnew file mode 100644index 00000000000..c668f571a97--- /dev/null+++ b/packages/twenty-server/src/database/commands/upgrade-version-command/2-42/2-42-workspace-command-1789719131001-backfill-workflow-execution-core-ids.command.ts@@ -0,0 +1,193 @@+import { Command } from 'nest-commander';+import { isDefined } from 'twenty-shared/utils';+import { type QueryRunner } from 'typeorm';++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';+import { WorkspaceCacheService } from 'src/engine/workspace-cache/services/workspace-cache.service';++@RegisteredWorkspaceCommand('2.42.0', 1789719131001)+@Command({+ name: 'upgrade:2-42:backfill-workflow-execution-core-ids',+ description:+ 'Validate durable workflow mappings and backfill workflow run core ids',+})+export class BackfillWorkflowExecutionCoreIdsCommand extends ProvisionedWorkspaceCommandRunner {+ constructor(+ protected readonly workspaceIteratorService: WorkspaceIteratorService,+ private readonly workspaceCacheService: WorkspaceCacheService,+ ) {+ super(workspaceIteratorService);+ }++ override async runOnWorkspace({+ workspaceId,+ options,+ dataSource,+ }: RunOnWorkspaceArgs): Promise<void> {+ if (!isDefined(dataSource)) {+ return;+ }++ const queryRunner = dataSource.createQueryRunner();++ await queryRunner.connect();++ try {+ const schema = getWorkspaceSchemaName(workspaceId);++ if (!(await queryRunner.hasTable(`${schema}.workflowVersion`))) {+ this.logger.log(`Workflow version table absent in workspace ${workspaceId}, skipping backfill`);++ return;+ }++ if (!(await this.hasRequiredColumns(queryRunner, schema))) {+ throw new Error(`Workflow execution schema is not ready in workspace ${workspaceId}`);+ }++ await queryRunner.startTransaction();++ const invalidMappings = await queryRunner.query(+ `SELECT wv.id FROM "${schema}"."workflowVersion" wv+ LEFT JOIN core."workflowVersion" cv ON cv.id = wv."coreWorkflowVersionId"+ LEFT JOIN core."workflow" cw ON cw.id = cv."coreWorkflowId"+ WHERE (wv."deletedAt" IS NULL OR cv.id IS NOT NULL) AND (+ cv.id IS NULL OR cv."workspaceId" <> $1 OR+ cv."workflowId" IS DISTINCT FROM wv."workflowId" OR+ cw.id IS NULL OR cw."workspaceId" <> $1 OR+ cw."workspaceWorkflowId" IS DISTINCT FROM wv."workflowId" OR+ cv."workspaceWorkflowVersionId" IS DISTINCT FROM wv.id+ ) LIMIT 1`,+ [workspaceId],+ );+ const duplicates = await queryRunner.query(+ `SELECT wv."coreWorkflowVersionId" FROM "${schema}"."workflowVersion" wv+ JOIN core."workflowVersion" cv ON cv.id = wv."coreWorkflowVersionId" AND cv."workspaceId" = $1+ GROUP BY wv."coreWorkflowVersionId" HAVING count(*) > 1 LIMIT 1`,+ [workspaceId],+ );++ if (invalidMappings.length > 0 || duplicates.length > 0) {+ throw new Error(`Missing or conflicting workflow version mapping in workspace ${workspaceId}`);+ }++ const conflictingRuns = await queryRunner.query(+ `SELECT r.id FROM "${schema}"."workflowRun" r+ LEFT JOIN core."workflowVersion" cv+ ON cv."workspaceId" = $1 AND cv."workspaceWorkflowVersionId" = r."workflowVersionId"+ LEFT JOIN core."workflow" cw+ ON cw."workspaceId" = $1 AND cw."workspaceWorkflowId" = r."workflowId"+ WHERE (r."coreWorkflowVersionId" IS NOT NULL AND cv.id IS NOT NULL AND r."coreWorkflowVersionId" <> cv.id)+ OR (r."coreWorkflowId" IS NOT NULL AND cw.id IS NOT NULL AND r."coreWorkflowId" <> cw.id)+ OR (cv.id IS NOT NULL AND cw.id IS NOT NULL AND cv."coreWorkflowId" <> cw.id)+ LIMIT 1`,+ [workspaceId],+ );++ if (conflictingRuns.length > 0) {+ throw new Error(`Conflicting workflow run core ids in workspace ${workspaceId}`);+ }++ await queryRunner.query(+ `UPDATE "${schema}"."workflowRun" r+ SET "coreWorkflowVersionId" = cv.id+ FROM core."workflowVersion" cv+ WHERE cv."workspaceId" = $1 AND cv."workspaceWorkflowVersionId" = r."workflowVersionId"+ AND r."coreWorkflowVersionId" IS NULL`,+ [workspaceId],+ );+ await queryRunner.query(+ `UPDATE "${schema}"."workflowRun" r+ SET "coreWorkflowId" = cv."coreWorkflowId"+ FROM core."workflowVersion" cv+ WHERE cv."workspaceId" = $1 AND cv.id = r."coreWorkflowVersionId"+ AND r."coreWorkflowId" IS NULL`,+ [workspaceId],+ );+ await queryRunner.query(+ `UPDATE "${schema}"."workflowRun" r+ SET "coreWorkflowId" = cw.id+ FROM core."workflow" cw+ WHERE cw."workspaceId" = $1 AND cw."workspaceWorkflowId" = r."workflowId"+ AND r."coreWorkflowId" IS NULL`,+ [workspaceId],+ );++ const unmappedPendingRuns = await queryRunner.query(+ `SELECT r.id FROM "${schema}"."workflowRun" r+ LEFT JOIN core."workflowVersion" cv ON cv.id = r."coreWorkflowVersionId" AND cv."workspaceId" = $1+ LEFT JOIN core."workflow" cw ON cw.id = r."coreWorkflowId" AND cw."workspaceId" = $1+ WHERE r."deletedAt" IS NULL AND r.status IN ('NOT_STARTED', 'ENQUEUED', 'RUNNING')+ AND (cv.id IS NULL OR cw.id IS NULL OR cv."coreWorkflowId" <> cw.id)+ LIMIT 1`,+ [workspaceId],+ );++ if (unmappedPendingRuns.length > 0) {+ throw new Error(`Pending workflow runs have no valid core mapping in workspace ${workspaceId}`);+ }++ const conflictingPublishedVersions = await queryRunner.query(+ `SELECT cw.id FROM core."workflow" cw+ LEFT JOIN core."workflowVersion" cv ON cv."workspaceId" = cw."workspaceId"+ AND cv."workspaceWorkflowVersionId" = cw."lastPublishedVersionId"+ WHERE cw."workspaceId" = $1 AND cw."lastPublishedVersionId" IS NOT NULL+ AND (cv.id IS NULL OR cv."coreWorkflowId" <> cw.id OR+ (cw."lastPublishedCoreWorkflowVersionId" IS NOT NULL AND cw."lastPublishedCoreWorkflowVersionId" <> cv.id))+ LIMIT 1`,+ [workspaceId],+ );++ if (conflictingPublishedVersions.length > 0) {+ throw new Error(`Invalid published core version mapping in workspace ${workspaceId}`);+ }++ await queryRunner.query(+ `UPDATE core."workflow" cw SET "lastPublishedCoreWorkflowVersionId" = cv.id+ FROM core."workflowVersion" cv+ WHERE cw."workspaceId" = $1 AND cv."workspaceId" = $1+ AND cv."workspaceWorkflowVersionId" = cw."lastPublishedVersionId"+ AND cv."coreWorkflowId" = cw.id AND cw."lastPublishedCoreWorkflowVersionId" IS NULL`,+ [workspaceId],+ );++ if (options.dryRun) {+ await queryRunner.rollbackTransaction();+ this.logger.log(`[DRY RUN] Workflow execution mappings validated in workspace ${workspaceId}`);+ } else {+ await queryRunner.commitTransaction();+ await this.workspaceCacheService.invalidateAndRecompute(workspaceId, [+ 'workflowAutomatedTriggerMaps',+ ]);+ this.logger.log(`Workflow execution mappings backfilled in workspace ${workspaceId}`);+ }+ } catch (error) {+ if (queryRunner.isTransactionActive) {+ await queryRunner.rollbackTransaction();+ }+ throw error;+ } finally {+ await queryRunner.release();+ }+ }++ private async hasRequiredColumns(+ queryRunner: QueryRunner,+ schema: string,+ ): Promise<boolean> {+ const rows = await queryRunner.query(+ `SELECT count(*)::int AS count+ FROM information_schema.columns+ WHERE (table_schema = 'core' AND table_name = 'workflowVersion' AND column_name = 'workspaceWorkflowVersionId')+ OR (table_schema = $1 AND table_name = 'workflowVersion' AND column_name = 'coreWorkflowVersionId')+ OR (table_schema = $1 AND table_name = 'workflowRun' AND column_name IN ('coreWorkflowId', 'coreWorkflowVersionId'))`,+ [schema],+ );++ return rows[0]?.count === 4;+ }+}diff --git a/packages/twenty-server/src/database/commands/upgrade-version-command/2-42/2-42-workspace-command-1789719131002-make-workflow-run-projection-relations-nullable.command.ts b/packages/twenty-server/src/database/commands/upgrade-version-command/2-42/2-42-workspace-command-1789719131002-make-workflow-run-projection-relations-nullable.command.tsnew file mode 100644index 00000000000..1585ac10898--- /dev/null+++ b/packages/twenty-server/src/database/commands/upgrade-version-command/2-42/2-42-workspace-command-1789719131002-make-workflow-run-projection-relations-nullable.command.ts@@ -0,0 +1,66 @@+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 { WorkspaceMigrationRunnerService } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-runner/services/workspace-migration-runner.service';+import { getWorkspaceSchemaName } from 'src/engine/workspace-datasource/utils/get-workspace-schema-name.util';++@RegisteredWorkspaceCommand('2.42.0', 1789719131002)+@Command({+ name: 'upgrade:2-42:make-workflow-run-projection-relations-nullable',+ description:+ 'Allow core-only workflows to persist runs without rollback projection relations',+})+export class MakeWorkflowRunProjectionRelationsNullableCommand extends ProvisionedWorkspaceCommandRunner {+ constructor(+ protected readonly workspaceIteratorService: WorkspaceIteratorService,+ private readonly workspaceMigrationRunnerService: WorkspaceMigrationRunnerService,+ ) {+ super(workspaceIteratorService);+ }++ override async runOnWorkspace({+ workspaceId,+ options,+ dataSource,+ }: RunOnWorkspaceArgs): Promise<void> {+ if (!isDefined(dataSource) || options.dryRun) {+ return;+ }++ const schema = getWorkspaceSchemaName(workspaceId);+ const [table] = await dataSource.query(+ 'SELECT to_regclass($1) AS name',+ [`"${schema}"."workflowRun"`],+ );++ if (!isDefined(table?.name)) {+ this.logger.log(`Workflow run table absent in workspace ${workspaceId}, skipping projection relations`);++ return;+ }++ await dataSource.query(+ `ALTER TABLE "${schema}"."workflowRun"+ ALTER COLUMN "workflowId" DROP NOT NULL,+ ALTER COLUMN "workflowVersionId" DROP NOT NULL`,+ );+ await dataSource.query(+ `UPDATE core."fieldMetadata" field+ SET "isNullable" = true+ FROM core."objectMetadata" object+ WHERE field."objectMetadataId" = object.id+ AND object."workspaceId" = $1+ AND object."nameSingular" = 'workflowRun'+ AND field.name IN ('workflow', 'workflowVersion')`,+ [workspaceId],+ );+ await this.workspaceMigrationRunnerService.invalidateCache({+ allFlatEntityMapsKeys: ['flatFieldMetadataMaps', 'flatObjectMetadataMaps'],+ workspaceId,+ });+ }+}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.tsindex 10ae2daee28..a7e6985493a 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@@ -194,6 +194,7 @@ import { AddWorkspaceWorkflowVersionIdToWorkflowVersionFastInstanceCommand } froimport { AddReadabilityParentFieldsToObjectMetadataFastInstanceCommand } from 'src/database/commands/upgrade-version-command/2-41/2-41-instance-command-fast-1789373200000-add-readability-parent-fields-to-object-metadata';import { AddAppMessageChannelTypeFastInstanceCommand } from 'src/database/commands/upgrade-version-command/2-41/2-41-instance-command-fast-1789395506192-add-app-message-channel-type';import { AddAppMessageChannelUniqueHandleFastInstanceCommand } from 'src/database/commands/upgrade-version-command/2-41/2-41-instance-command-fast-1789418882171-add-app-message-channel-unique-handle';+import { AddWorkflowExecutionCompatibilityFastInstanceCommand } from 'src/database/commands/upgrade-version-command/2-42/2-42-instance-command-fast-1789719131000-add-workflow-execution-compatibility';export const INSTANCE_COMMANDS = [AddViewFieldGroupIdIndexOnViewFieldFastInstanceCommand,@@ -387,6 +388,7 @@ export const INSTANCE_COMMANDS = [AddWorkspaceWorkflowIdToWorkflowFastInstanceCommand,AddCoreVersionPointersFastInstanceCommand,AddWorkspaceWorkflowVersionIdToWorkflowVersionFastInstanceCommand,+ AddWorkflowExecutionCompatibilityFastInstanceCommand,AddReadabilityParentFieldsToObjectMetadataFastInstanceCommand,AddAppMessageChannelTypeFastInstanceCommand,AddAppMessageChannelUniqueHandleFastInstanceCommand,diff --git a/packages/twenty-server/src/engine/core-modules/workflow/controllers/workflow-trigger.controller.ts b/packages/twenty-server/src/engine/core-modules/workflow/controllers/workflow-trigger.controller.tsindex 9946951d297..63c8a30b093 100644--- a/packages/twenty-server/src/engine/core-modules/workflow/controllers/workflow-trigger.controller.ts+++ b/packages/twenty-server/src/engine/core-modules/workflow/controllers/workflow-trigger.controller.ts@@ -19,23 +19,19 @@ import { WorkspaceEntity } from 'src/engine/core-modules/workspace/workspace.entimport { NoPermissionGuard } from 'src/engine/guards/no-permission.guard';import { PublicEndpointGuard } from 'src/engine/guards/public-endpoint.guard';import { PermissionsGraphqlApiExceptionFilter } from 'src/engine/metadata-modules/permissions/utils/permissions-graphql-api-exception.filter';-import { WorkspaceOrmManager } from 'src/engine/twenty-orm/workspace-orm.manager';import {TwentyOrmException,TwentyOrmExceptionCode,} from 'src/engine/twenty-orm/exceptions/twenty-orm.exception';-import { buildSystemAuthContext } from 'src/engine/twenty-orm/utils/build-system-auth-context.util';-import {- WorkflowVersionStatus,- 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';+import { WorkflowVersionStatus } from 'src/engine/core-modules/workflow/entities/workflow-version.entity';+import { WorkflowCoreSyncService } from 'src/engine/core-modules/workflow/services/workflow-core-sync.service';+import { WorkflowVersionCoreSyncService } from 'src/engine/core-modules/workflow/services/workflow-version-core-sync.service';+import { CoreWorkflowRunnerService } from 'src/modules/workflow/workflow-runner/services/core-workflow-runner.service';import {WorkflowTriggerException,WorkflowTriggerExceptionCode,} from 'src/modules/workflow/workflow-trigger/exceptions/workflow-trigger.exception';import { WorkflowTriggerType } from 'src/modules/workflow/workflow-trigger/types/workflow-trigger.type';-import { WorkflowTriggerWorkspaceService } from 'src/modules/workflow/workflow-trigger/workspace-services/workflow-trigger.workspace-service';@Controller(ApiPath.Webhooks)@UseFilters(@@ -44,8 +40,9 @@ import { WorkflowTriggerWorkspaceService } from 'src/modules/workflow/workflow-t)export class WorkflowTriggerController {constructor(- private readonly workspaceOrmManager: WorkspaceOrmManager,- private readonly workflowTriggerWorkspaceService: WorkflowTriggerWorkspaceService,+ private readonly workflowCoreSyncService: WorkflowCoreSyncService,+ private readonly workflowVersionCoreSyncService: WorkflowVersionCoreSyncService,+ private readonly coreWorkflowRunnerService: CoreWorkflowRunnerService,@InjectRepository(WorkspaceEntity)protected readonly workspaceRepository: Repository<WorkspaceEntity>,) {}@@ -93,83 +90,68 @@ export class WorkflowTriggerController {);}- const authContext = buildSystemAuthContext(workspaceId);-try {- const { workflow } =- await this.workspaceOrmManager.executeInWorkspaceContext(async () => {- const workflowRepository =- this.workspaceOrmManager.getRepository<WorkflowWorkspaceEntity>(- 'workflow',- { shouldBypassPermissionChecks: true },- );-- const workflow = await workflowRepository.findOne({- where: { id: workflowId },- });-- if (!isDefined(workflow)) {- throw new WorkflowTriggerException(- `[Webhook trigger] Workflow ${workflowId} not found in workspace ${workspaceId}`,- WorkflowTriggerExceptionCode.NOT_FOUND,- );- }-- if (- !isDefined(workflow.lastPublishedVersionId) ||- workflow.lastPublishedVersionId === ''- ) {- throw new WorkflowTriggerException(- `[Webhook trigger] Workflow ${workflowId} has not been activated in workspace ${workspaceId}`,- WorkflowTriggerExceptionCode.INVALID_WORKFLOW_STATUS,- );- }-- const workflowVersionRepository =- this.workspaceOrmManager.getRepository<WorkflowVersionWorkspaceEntity>(- 'workflowVersion',- { shouldBypassPermissionChecks: true },- );- const workflowVersion = await workflowVersionRepository.findOne({- where: { id: workflow.lastPublishedVersionId },- });-- if (!isDefined(workflowVersion)) {- throw new WorkflowTriggerException(- `[Webhook trigger] No workflow version activated for workflow ${workflowId} in workspace ${workspaceId}`,- WorkflowTriggerExceptionCode.INVALID_WORKFLOW_VERSION,- );- }-- if (workflowVersion.trigger?.type !== WorkflowTriggerType.WEBHOOK) {- throw new WorkflowTriggerException(- `[Webhook trigger] Workflow ${workflowId} does not have a Webhook trigger in workspace ${workspaceId}`,- WorkflowTriggerExceptionCode.INVALID_WORKFLOW_TRIGGER,- );- }-- if (workflowVersion.status !== WorkflowVersionStatus.ACTIVE) {- throw new WorkflowTriggerException(- `[Webhook trigger] Workflow version ${workflowVersion.id} is not active in workspace ${workspaceId}`,- WorkflowTriggerExceptionCode.INVALID_WORKFLOW_STATUS,- );- }-- return { workflow, workflowVersion };- }, authContext);-- const { workflowRunId } =- await this.workflowTriggerWorkspaceService.runWorkflowVersion({- workflowVersionId: workflow.lastPublishedVersionId!,- payload: payload || {},- createdBy: {- source: FieldActorSource.WEBHOOK,- workspaceMemberId: null,- name: 'Webhook',- context: {},- },+ const workflow =+ await this.workflowCoreSyncService.findCoreWorkflowByIdOrWorkspaceWorkflowId(+ workspaceId,+ workflowId,+ );++ if (!isDefined(workflow)) {+ throw new WorkflowTriggerException(+ `[Webhook trigger] Workflow ${workflowId} not found in workspace ${workspaceId}`,+ WorkflowTriggerExceptionCode.NOT_FOUND,+ );+ }++ if (!isDefined(workflow.lastPublishedCoreWorkflowVersionId)) {+ throw new WorkflowTriggerException(+ `[Webhook trigger] Workflow ${workflowId} has not been activated in workspace ${workspaceId}`,+ WorkflowTriggerExceptionCode.INVALID_WORKFLOW_STATUS,+ );+ }++ const workflowVersion =+ await this.workflowVersionCoreSyncService.findCoreVersionById(workspaceId,- });+ workflow.lastPublishedCoreWorkflowVersionId,+ );++ if (+ !isDefined(workflowVersion) ||+ workflowVersion.coreWorkflowId !== workflow.id+ ) {+ throw new WorkflowTriggerException(+ `[Webhook trigger] No workflow version activated for workflow ${workflowId} in workspace ${workspaceId}`,+ WorkflowTriggerExceptionCode.INVALID_WORKFLOW_VERSION,+ );+ }++ if (workflowVersion.triggers?.[0]?.type !== WorkflowTriggerType.WEBHOOK) {+ throw new WorkflowTriggerException(+ `[Webhook trigger] Workflow ${workflowId} does not have a Webhook trigger in workspace ${workspaceId}`,+ WorkflowTriggerExceptionCode.INVALID_WORKFLOW_TRIGGER,+ );+ }++ if (workflowVersion.status !== WorkflowVersionStatus.ACTIVE) {+ throw new WorkflowTriggerException(+ `[Webhook trigger] Workflow version ${workflowVersion.id} is not active in workspace ${workspaceId}`,+ WorkflowTriggerExceptionCode.INVALID_WORKFLOW_STATUS,+ );+ }++ const { workflowRunId } = await this.coreWorkflowRunnerService.run({+ coreWorkflowVersionId: workflowVersion.id,+ payload: payload || {},+ source: {+ source: FieldActorSource.WEBHOOK,+ workspaceMemberId: null,+ name: 'Webhook',+ context: {},+ },+ workspaceId,+ });return {workflowName: workflow.name,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.tsindex b78901b465a..ffa364c25b9 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@@ -35,11 +35,15 @@ export enum WorkflowVersionStatus {where: `"status" = 'ACTIVE'`,},)+@Index(+ 'IDX_WORKFLOW_VERSION_WORKSPACE_VERSION_ID',+ ['workspaceId', 'workspaceWorkflowVersionId'],+ {+ unique: true,+ where: '"workspaceWorkflowVersionId" IS NOT NULL',+ },+)@Index('IDX_WORKFLOW_VERSION_APPLICATION_ID', ['applicationId'])-@Index('IDX_WORKFLOW_VERSION_WORKSPACE_WORKFLOW_VERSION_ID', [- 'workspaceId',- 'workspaceWorkflowVersionId',-])export class WorkflowVersionEntity extends SyncableEntity {@PrimaryGeneratedColumn('uuid')id: string;@@ -58,8 +62,8 @@ export class WorkflowVersionEntity extends SyncableEntity {})status: WorkflowVersionStatus;- @Column({ type: 'uuid', nullable: false })- workflowId: string;+ @Column({ type: 'uuid', nullable: true })+ workflowId: string | null;@WasIntroducedInUpgrade({upgradeCommandName:diff --git a/packages/twenty-server/src/engine/core-modules/workflow/resolvers/core-workflow-version-mutation.resolver.ts b/packages/twenty-server/src/engine/core-modules/workflow/resolvers/core-workflow-version-mutation.resolver.tsindex d9aa2107705..d246c822891 100644--- a/packages/twenty-server/src/engine/core-modules/workflow/resolvers/core-workflow-version-mutation.resolver.ts+++ b/packages/twenty-server/src/engine/core-modules/workflow/resolvers/core-workflow-version-mutation.resolver.ts@@ -41,6 +41,7 @@ import { buildSystemAuthContext } from 'src/engine/twenty-orm/utils/build-systemimport { WorkspaceOrmManager } from 'src/engine/twenty-orm/workspace-orm.manager';import { buildWorkflowRunTriggerContext } from 'src/modules/workflow/workflow-trigger/utils/build-workflow-run-trigger-context.util';import { type WorkspaceMemberWorkspaceEntity } from 'src/modules/workspace-member/standard-objects/workspace-member.workspace-entity';+import { CoreWorkflowRunnerService } from 'src/modules/workflow/workflow-runner/services/core-workflow-runner.service';@CoreResolver()@UsePipes(ResolverValidationPipe)@@ -62,6 +63,7 @@ export class CoreWorkflowVersionMutationResolver {constructor(private readonly coreWorkflowVersionMutationWorkspaceService: CoreWorkflowVersionMutationWorkspaceService,private readonly coreWorkflowLifecycleWorkspaceService: CoreWorkflowLifecycleWorkspaceService,+ private readonly coreWorkflowRunnerService: CoreWorkflowRunnerService,private readonly workspaceOrmManager: WorkspaceOrmManager,) {}@@ -134,12 +136,12 @@ export class CoreWorkflowVersionMutationResolver {const { payload: triggerPayload, createdBy } =buildWorkflowRunTriggerContext({ workspaceMember, payload });- return this.coreWorkflowLifecycleWorkspaceService.runCoreWorkflowVersion({+ return this.coreWorkflowRunnerService.run({workspaceId,coreWorkflowVersionId,workflowRunId: workflowRunId ?? undefined,payload: triggerPayload,- createdBy,+ source: createdBy,});}diff --git a/packages/twenty-server/src/engine/core-modules/workflow/services/__tests__/core-workflow-version-mutation.workspace-service.spec.ts b/packages/twenty-server/src/engine/core-modules/workflow/services/__tests__/core-workflow-version-mutation.workspace-service.spec.tsnew file mode 100644index 00000000000..83c45bd8546--- /dev/null+++ b/packages/twenty-server/src/engine/core-modules/workflow/services/__tests__/core-workflow-version-mutation.workspace-service.spec.ts@@ -0,0 +1,150 @@+import { WorkflowActionType } from 'twenty-shared/workflow';++import { CoreWorkflowVersionMutationWorkspaceService } from 'src/engine/core-modules/workflow/services/core-workflow-version-mutation.workspace-service';+import { CoreWorkflowVersionPostCommitError } from 'src/engine/core-modules/workflow/services/core-workflow-version-write.service';+import { type WorkflowAction } from 'src/modules/workflow/workflow-executor/workflow-actions/types/workflow-action.type';++const workspaceId = '20202020-0000-0000-0000-000000000001';+const coreWorkflowVersionId = '20202020-0000-0000-0000-000000000002';+const stepId = '20202020-0000-0000-0000-000000000003';++const existingCodeStep = {+ id: stepId,+ name: 'Code',+ type: WorkflowActionType.CODE,+ valid: true,+ settings: {+ input: {+ logicFunctionId: '20202020-0000-0000-0000-000000000004',+ logicFunctionInput: {},+ },+ outputSchema: {},+ errorHandlingOptions: {+ retryOnFailure: { value: 0 },+ continueOnFailure: { value: false },+ },+ },+ nextStepIds: [],+} as WorkflowAction;++const replacementEmptyStep = {+ id: '20202020-0000-0000-0000-000000000005',+ name: 'Empty',+ type: WorkflowActionType.EMPTY,+ valid: true,+ settings: {+ input: {},+ outputSchema: {},+ errorHandlingOptions: {+ retryOnFailure: { value: 0 },+ continueOnFailure: { value: false },+ },+ },+ nextStepIds: [],+} as WorkflowAction;++describe('CoreWorkflowVersionMutationWorkspaceService', () => {+ const getValidatedDraftCoreWorkflowVersion = jest.fn();+ const writeContentAndMirror = jest.fn();+ const runStepCreationSideEffectsAndBuildStep = jest.fn();+ const runWorkflowVersionStepDeletionSideEffects = jest.fn();+ const enrichOutputSchema = jest.fn();++ const service = new CoreWorkflowVersionMutationWorkspaceService(+ {} as never,+ {} as never,+ {+ getValidatedDraftCoreWorkflowVersion,+ writeContentAndMirror,+ } as never,+ {} as never,+ {} as never,+ {+ runStepCreationSideEffectsAndBuildStep,+ runWorkflowVersionStepDeletionSideEffects,+ } as never,+ { enrichOutputSchema } as never,+ );++ beforeEach(() => {+ jest.clearAllMocks();+ getValidatedDraftCoreWorkflowVersion.mockResolvedValue({+ coreWorkflowVersion: {+ triggers: [],+ steps: [existingCodeStep],+ },+ trigger: null,+ steps: [existingCodeStep],+ });+ runStepCreationSideEffectsAndBuildStep.mockResolvedValue({+ builtStep: replacementEmptyStep,+ });+ enrichOutputSchema.mockImplementation(+ async ({ step }: { step: WorkflowAction }) => step,+ );+ runWorkflowVersionStepDeletionSideEffects.mockResolvedValue(undefined);+ });++ it('keeps the existing step resource when the optimistic write is rejected', async () => {+ const writeError = new Error('Workflow version changed');++ writeContentAndMirror.mockRejectedValue(writeError);++ await expect(+ service.updateStep({+ workspaceId,+ coreWorkflowVersionId,+ step: { ...replacementEmptyStep, id: stepId },+ }),+ ).rejects.toBe(writeError);++ expect(runWorkflowVersionStepDeletionSideEffects).not.toHaveBeenCalledWith({+ step: existingCodeStep,+ workspaceId,+ });+ expect(runWorkflowVersionStepDeletionSideEffects).toHaveBeenCalledWith({+ step: expect.objectContaining({ type: WorkflowActionType.EMPTY }),+ workspaceId,+ });+ });++ it('deletes the existing step resource only after the replacement is stored', async () => {+ writeContentAndMirror.mockResolvedValue(undefined);++ await service.updateStep({+ workspaceId,+ coreWorkflowVersionId,+ step: { ...replacementEmptyStep, id: stepId },+ });++ expect(runWorkflowVersionStepDeletionSideEffects).toHaveBeenCalledWith({+ step: existingCodeStep,+ workspaceId,+ });+ expect(writeContentAndMirror.mock.invocationCallOrder[0]).toBeLessThan(+ runWorkflowVersionStepDeletionSideEffects.mock.invocationCallOrder[0],+ );+ });++ it('keeps the committed replacement and deletes the old resource when cache invalidation fails', async () => {+ const cacheError = new CoreWorkflowVersionPostCommitError(+ new Error('Cache unavailable'),+ );++ writeContentAndMirror.mockRejectedValue(cacheError);++ await expect(+ service.updateStep({+ workspaceId,+ coreWorkflowVersionId,+ step: { ...replacementEmptyStep, id: stepId },+ }),+ ).rejects.toBe(cacheError);++ expect(runWorkflowVersionStepDeletionSideEffects).toHaveBeenCalledTimes(1);+ expect(runWorkflowVersionStepDeletionSideEffects).toHaveBeenCalledWith({+ step: existingCodeStep,+ workspaceId,+ });+ });+});diff --git a/packages/twenty-server/src/engine/core-modules/workflow/services/__tests__/core-workflow-version-write.service.spec.ts b/packages/twenty-server/src/engine/core-modules/workflow/services/__tests__/core-workflow-version-write.service.spec.tsnew file mode 100644index 00000000000..78c4a4d218c--- /dev/null+++ b/packages/twenty-server/src/engine/core-modules/workflow/services/__tests__/core-workflow-version-write.service.spec.ts@@ -0,0 +1,61 @@+import {+ CoreWorkflowVersionPostCommitError,+ CoreWorkflowVersionWriteService,+} from 'src/engine/core-modules/workflow/services/core-workflow-version-write.service';++const workspaceId = '20202020-0000-0000-0000-000000000001';+const coreWorkflowVersionId = '20202020-0000-0000-0000-000000000002';++describe('CoreWorkflowVersionWriteService', () => {+ it('reports cache invalidation failures as post-commit errors', async () => {+ const cacheError = new Error('Cache unavailable');+ const invalidateAutomatedTriggerMaps = jest+ .fn()+ .mockRejectedValue(cacheError);+ const update = jest.fn().mockResolvedValue({ affected: 1 });+ const executeRawQuery = jest+ .fn()+ .mockResolvedValue([{ id: coreWorkflowVersionId }]);+ const runInWorkspaceTransaction = jest+ .fn()+ .mockImplementation(async (callback) =>+ callback({+ getRepository: () => ({ update }),+ executeRawQuery,+ }),+ );+ const executeInWorkspaceContext = jest+ .fn()+ .mockImplementation(async (callback) => callback());++ const service = new CoreWorkflowVersionWriteService(+ {} as never,+ { invalidateAutomatedTriggerMaps } as never,+ {+ getFlatEntityMaps: jest.fn().mockResolvedValue({+ flatObjectMetadataMaps: {},+ flatFieldMetadataMaps: {},+ objectIdByNameSingular: {},+ }),+ } as never,+ { executeInWorkspaceContext, runInWorkspaceTransaction } as never,+ {} as never,+ );++ const writePromise = service.writeContentAndMirror({+ workspaceId,+ coreWorkflowVersionId,+ expectedVersion: { triggers: null, steps: null },+ trigger: null,+ steps: null,+ });++ const writeError = await writePromise.catch((error) => error);++ expect(writeError).toBeInstanceOf(CoreWorkflowVersionPostCommitError);+ expect(writeError).toMatchObject({ cause: cacheError });+ expect(update).toHaveBeenCalledTimes(1);+ expect(executeRawQuery).toHaveBeenCalledTimes(1);+ expect(invalidateAutomatedTriggerMaps).toHaveBeenCalledWith(workspaceId);+ });+});diff --git a/packages/twenty-server/src/engine/core-modules/workflow/services/core-workflow-lifecycle.workspace-service.ts b/packages/twenty-server/src/engine/core-modules/workflow/services/core-workflow-lifecycle.workspace-service.tsindex 5395f0bff2e..7a7f74d5779 100644--- a/packages/twenty-server/src/engine/core-modules/workflow/services/core-workflow-lifecycle.workspace-service.ts+++ b/packages/twenty-server/src/engine/core-modules/workflow/services/core-workflow-lifecycle.workspace-service.ts@@ -26,6 +26,7 @@ import { WorkspaceOrmManager } from 'src/engine/twenty-orm/workspace-orm.managerimport { InjectWorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/inject-workspace-scoped-repository.decorator';import { WorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/workspace-scoped-repository';import { type WorkspaceTransactionScope } from 'src/engine/twenty-orm/types/workspace-transaction-scope.type';+import { getWorkspaceSchemaName } from 'src/engine/workspace-datasource/utils/get-workspace-schema-name.util';import { WorkspaceEventEmitter } from 'src/engine/workspace-event-emitter/workspace-event-emitter';import { AutomatedTriggerType } from 'src/modules/workflow/common/standard-objects/workflow-automated-trigger.workspace-entity';import {@@ -185,84 +186,122 @@ export class CoreWorkflowLifecycleWorkspaceService {steps: steps ?? [],});- const previousPublishedCoreVersionId =- await this.findPreviousPublishedCoreVersionId({- workspaceId,- coreWorkflow,- });-- if (- isDefined(previousPublishedCoreVersionId) &&- previousPublishedCoreVersionId !== coreWorkflowVersion.id- ) {- await this.deactivateCoreWorkflowVersion({- workspaceId,- coreWorkflowVersionId: previousPublishedCoreVersionId,- });- }-- const activeSiblingsCount = await this.coreWorkflowVersionRepository.count(- workspaceId,- {- where: {- coreWorkflowId: coreWorkflow.id,- status: CoreWorkflowVersionStatus.ACTIVE,- },- },- );-- if (activeSiblingsCount > 0) {- throw new WorkflowTriggerException(- 'Cannot have more than one active workflow version',- WorkflowTriggerExceptionCode.FORBIDDEN,- {- userFriendlyMessage: msg`Cannot have more than one active workflow version`,- },- );- }+ let previousResolved: ResolvedCoreVersion | undefined;await this.workspaceOrmManager.executeInWorkspaceContext(async () => {await this.workspaceOrmManager.runInWorkspaceTransaction(async (transactionScope) => {+ await transactionScope.executeRawQuery(+ `SELECT id FROM "${getWorkspaceSchemaName(workspaceId)}".workflow WHERE id = $1 FOR NO KEY UPDATE`,+ [resolved.workspaceWorkflowId],+ );+ await transactionScope.executeRawQuery(+ `SELECT id FROM "${getWorkspaceSchemaName(workspaceId)}"."workflowVersion" WHERE "workflowId" = $1 ORDER BY id FOR NO KEY UPDATE`,+ [resolved.workspaceWorkflowId],+ );+ const [lockedCoreWorkflow] = await transactionScope.executeRawQuery(+ `SELECT "lastPublishedCoreWorkflowVersionId" FROM core."workflow"+ WHERE "id" = $1 AND "workspaceId" = $2 FOR NO KEY UPDATE`,+ [coreWorkflow.id, workspaceId],+ );++ const unchangedVersion = await transactionScope.executeRawQuery(+ `SELECT id FROM core."workflowVersion" WHERE id = $1 AND "workspaceId" = $2+ AND status = $3 AND triggers IS NOT DISTINCT FROM $4::jsonb AND steps IS NOT DISTINCT FROM $5::jsonb`,+ [+ coreWorkflowVersion.id,+ workspaceId,+ coreWorkflowVersion.status,+ JSON.stringify(coreWorkflowVersion.triggers),+ JSON.stringify(coreWorkflowVersion.steps),+ ],+ );++ if (unchangedVersion.length !== 1) {+ throw new WorkflowTriggerException(+ 'Workflow version changed during activation',+ WorkflowTriggerExceptionCode.INVALID_INPUT,+ {+ userFriendlyMessage: msg`Workflow version changed, please reload and retry`,+ },+ );+ }++ const activeVersions = await transactionScope.executeRawQuery(+ `SELECT id FROM core."workflowVersion" WHERE "coreWorkflowId" = $1 AND "workspaceId" = $2 AND status = 'ACTIVE'`,+ [coreWorkflow.id, workspaceId],+ );+if (- isDefined(previousPublishedCoreVersionId) &&- previousPublishedCoreVersionId !== coreWorkflowVersion.id+ activeVersions.length > 1 ||+ activeVersions[0]?.id === coreWorkflowVersion.id) {+ throw new WorkflowTriggerException(+ 'Cannot have more than one active workflow version',+ WorkflowTriggerExceptionCode.FORBIDDEN,+ {+ userFriendlyMessage: msg`Cannot have more than one active workflow version`,+ },+ );+ }++ const previousCoreWorkflowVersionId =+ typeof activeVersions[0]?.id === 'string'+ ? activeVersions[0].id+ : typeof lockedCoreWorkflow?.lastPublishedCoreWorkflowVersionId ===+ 'string' &&+ lockedCoreWorkflow.lastPublishedCoreWorkflowVersionId !==+ coreWorkflowVersion.id+ ? lockedCoreWorkflow.lastPublishedCoreWorkflowVersionId+ : null;++ if (isDefined(previousCoreWorkflowVersionId)) {+ previousResolved = await this.resolveCoreVersionWithWorkflowOrThrow(+ {+ workspaceId,+ coreWorkflowVersionId: previousCoreWorkflowVersionId,+ },+ );++ if (+ previousResolved.coreWorkflowVersion.status ===+ CoreWorkflowVersionStatus.ACTIVE+ ) {+ await this.disableAutomatedTrigger({+ resolved: previousResolved,+ transactionScope,+ });+ }await this.writeVersionStatusInTransaction({transactionScope,workspaceId,- coreWorkflowVersionId: previousPublishedCoreVersionId,+ coreWorkflowVersionId: previousResolved.coreWorkflowVersion.id,status: WorkflowVersionStatus.ARCHIVED,});}- if (- coreWorkflow.lastPublishedCoreWorkflowVersionId !==- coreWorkflowVersion.id- ) {- await transactionScope.executeRawQuery(- `UPDATE core."workflow"- SET "lastPublishedCoreWorkflowVersionId" = $3, "lastPublishedVersionId" = $4, "updatedAt" = now()- WHERE "id" = $1 AND "workspaceId" = $2`,- [- coreWorkflow.id,- workspaceId,- coreWorkflowVersion.id,- resolved.workspaceWorkflowVersionId,- ],+ await transactionScope+ .getRepository<WorkflowWorkspaceEntity>('workflow', {+ shouldBypassPermissionChecks: true,+ })+ .update(+ { id: resolved.workspaceWorkflowId },+ {+ lastPublishedVersionId: resolved.workspaceWorkflowVersionId,+ },);- await transactionScope- .getRepository<WorkflowWorkspaceEntity>('workflow', {- shouldBypassPermissionChecks: true,- })- .update(- { id: resolved.workspaceWorkflowId },- {- lastPublishedVersionId: resolved.workspaceWorkflowVersionId,- },- );- }+ await transactionScope.executeRawQuery(+ `UPDATE core."workflow"+ SET "lastPublishedCoreWorkflowVersionId" = $3, "lastPublishedVersionId" = $4, "updatedAt" = now()+ WHERE "id" = $1 AND "workspaceId" = $2`,+ [+ coreWorkflow.id,+ workspaceId,+ coreWorkflowVersion.id,+ resolved.workspaceWorkflowVersionId,+ ],+ );await this.writeVersionStatusInTransaction({transactionScope,@@ -279,6 +318,18 @@ export class CoreWorkflowLifecycleWorkspaceService {);}, buildSystemAuthContext(workspaceId));+ if (isDefined(previousResolved)) {+ await this.deleteCommandMenuItem({+ workspaceId,+ resolved: previousResolved,+ });+ this.emitStatusUpdateEvent({+ workspaceId,+ resolved: previousResolved,+ newStatus: WorkflowVersionStatus.ARCHIVED,+ });+ }+await this.writeCronTriggerCacheEntryAfterCommit({ resolved });await this.createOrUpdateCommandMenuItem({@@ -317,8 +368,6 @@ export class CoreWorkflowLifecycleWorkspaceService {return true;}- await this.deleteCommandMenuItem({ workspaceId, resolved });-await this.workspaceOrmManager.executeInWorkspaceContext(async () => {await this.workspaceOrmManager.runInWorkspaceTransaction(async (transactionScope) => {@@ -337,6 +386,8 @@ export class CoreWorkflowLifecycleWorkspaceService {);}, buildSystemAuthContext(workspaceId));+ await this.deleteCommandMenuItem({ workspaceId, resolved });+await this.workflowVersionCoreSyncService.invalidateAutomatedTriggerMaps(workspaceId,);@@ -463,13 +514,6 @@ export class CoreWorkflowLifecycleWorkspaceService {coreWorkflowVersionId: string;status: WorkflowVersionStatus;}): Promise<void> {- await transactionScope.executeRawQuery(- `UPDATE core."workflowVersion"- SET "status" = $3, "updatedAt" = now()- WHERE "id" = $1 AND "workspaceId" = $2`,- [coreWorkflowVersionId, workspaceId, status],- );-const mirrorUpdateResult = await transactionScope.getRepository<WorkflowVersionWorkspaceEntity>('workflowVersion', {shouldBypassPermissionChecks: true,@@ -480,6 +524,13 @@ export class CoreWorkflowLifecycleWorkspaceService {affected: mirrorUpdateResult.affected,coreWorkflowVersionId,});++ await transactionScope.executeRawQuery(+ `UPDATE core."workflowVersion"+ SET "status" = $3, "updatedAt" = now()+ WHERE "id" = $1 AND "workspaceId" = $2`,+ [coreWorkflowVersionId, workspaceId, status],+ );}private async enableAutomatedTrigger({@@ -601,9 +652,11 @@ export class CoreWorkflowLifecycleWorkspaceService {transactionScope,});- await this.cacheStorageService.hashDelete({- key: WORKFLOW_CRON_TRIGGER_CACHE_KEY,- field: workspaceWorkflowId,+ transactionScope.afterCommit(async () => {+ await this.cacheStorageService.hashDelete({+ key: WORKFLOW_CRON_TRIGGER_CACHE_KEY,+ field: workspaceWorkflowId,+ });});return;diff --git a/packages/twenty-server/src/engine/core-modules/workflow/services/core-workflow-mutation.workspace-service.ts b/packages/twenty-server/src/engine/core-modules/workflow/services/core-workflow-mutation.workspace-service.tsindex 132c7aee6ca..e03a8ae4673 100644--- a/packages/twenty-server/src/engine/core-modules/workflow/services/core-workflow-mutation.workspace-service.ts+++ b/packages/twenty-server/src/engine/core-modules/workflow/services/core-workflow-mutation.workspace-service.ts@@ -169,6 +169,7 @@ export class CoreWorkflowMutationWorkspaceService {await this.coreWorkflowVersionWriteService.writeContentAndMirror({workspaceId,coreWorkflowVersionId: initialDraft.id,+ expectedVersion: initialDraft,trigger,steps,});@@ -237,16 +238,16 @@ export class CoreWorkflowMutationWorkspaceService {await this.workspaceOrmManager.executeInWorkspaceContext(async () => {await this.workspaceOrmManager.runInWorkspaceTransaction(async (transactionScope) => {- await transactionScope.executeRawQuery(- `UPDATE core."workflow" SET "name" = $1, "updatedAt" = now() WHERE "id" = $2 AND "workspaceId" = $3`,- [name, coreWorkflowId, workspaceId],- );-await transactionScope.getRepository<WorkflowWorkspaceEntity>('workflow', {shouldBypassPermissionChecks: true,}).update({ id: workspaceWorkflowId }, { name });++ await transactionScope.executeRawQuery(+ `UPDATE core."workflow" SET "name" = $1, "updatedAt" = now() WHERE "id" = $2 AND "workspaceId" = $3`,+ [name, coreWorkflowId, workspaceId],+ );},);}, buildSystemAuthContext(workspaceId));diff --git a/packages/twenty-server/src/engine/core-modules/workflow/services/core-workflow-version-mutation.workspace-service.ts b/packages/twenty-server/src/engine/core-modules/workflow/services/core-workflow-version-mutation.workspace-service.tsindex 90440f4959a..a6fd26c4ff9 100644--- a/packages/twenty-server/src/engine/core-modules/workflow/services/core-workflow-version-mutation.workspace-service.ts+++ b/packages/twenty-server/src/engine/core-modules/workflow/services/core-workflow-version-mutation.workspace-service.ts@@ -16,7 +16,10 @@ import {} from 'src/engine/core-modules/workflow/entities/workflow-version.entity';import { CoreWorkflowIdResolutionService } from 'src/engine/core-modules/workflow/services/core-workflow-id-resolution.service';import { CoreWorkflowVersionListService } from 'src/engine/core-modules/workflow/services/core-workflow-version-list.service';-import { CoreWorkflowVersionWriteService } from 'src/engine/core-modules/workflow/services/core-workflow-version-write.service';+import {+ CoreWorkflowVersionPostCommitError,+ CoreWorkflowVersionWriteService,+} from 'src/engine/core-modules/workflow/services/core-workflow-version-write.service';import { WorkflowCoreSyncService } from 'src/engine/core-modules/workflow/services/workflow-core-sync.service';import { InjectWorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/inject-workspace-scoped-repository.decorator';import { WorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/workspace-scoped-repository';@@ -79,7 +82,7 @@ export class CoreWorkflowVersionMutationWorkspaceService {defaultSettings,} = input;- const { trigger, steps } =+ const { coreWorkflowVersion, trigger, steps } =await this.coreWorkflowVersionWriteService.getValidatedDraftCoreWorkflowVersion({ workspaceId, coreWorkflowVersionId },);@@ -115,7 +118,8 @@ export class CoreWorkflowVersionMutationWorkspaceService {await this.coreWorkflowVersionWriteService.writeContentAndMirror({workspaceId,coreWorkflowVersionId,- trigger: updatedTrigger === trigger ? undefined : updatedTrigger,+ expectedVersion: coreWorkflowVersion,+ trigger: updatedTrigger ?? null,steps: updatedSteps,});@@ -136,7 +140,7 @@ export class CoreWorkflowVersionMutationWorkspaceService {coreWorkflowVersionId: string;stepId: string;}): Promise<WorkflowVersionStepChangesDTO> {- const { trigger, steps } =+ const { coreWorkflowVersion, trigger, steps } =await this.coreWorkflowVersionWriteService.getValidatedDraftCoreWorkflowVersion({ workspaceId, coreWorkflowVersionId },);@@ -170,6 +174,8 @@ export class CoreWorkflowVersionMutationWorkspaceService {await this.coreWorkflowVersionWriteService.writeContentAndMirror({workspaceId,coreWorkflowVersionId,+ expectedVersion: coreWorkflowVersion,+ trigger: updatedTrigger ?? null,steps: updatedSteps,});@@ -190,7 +196,7 @@ export class CoreWorkflowVersionMutationWorkspaceService {coreWorkflowVersionId: string;step: WorkflowAction;}): Promise<WorkflowActionDTO> {- const { trigger, steps } =+ const { coreWorkflowVersion, trigger, steps } =await this.coreWorkflowVersionWriteService.getValidatedDraftCoreWorkflowVersion({ workspaceId, coreWorkflowVersionId },);@@ -240,11 +246,44 @@ export class CoreWorkflowVersionMutationWorkspaceService {updatedSteps.push(...additionalCreatedSteps);}- await this.coreWorkflowVersionWriteService.writeContentAndMirror({- workspaceId,- coreWorkflowVersionId,- steps: updatedSteps,- });+ try {+ await this.coreWorkflowVersionWriteService.writeContentAndMirror({+ workspaceId,+ coreWorkflowVersionId,+ expectedVersion: coreWorkflowVersion,+ trigger,+ steps: updatedSteps,+ });+ } catch (error) {+ if (isStepTypeChanged) {+ const stepsToDelete =+ error instanceof CoreWorkflowVersionPostCommitError+ ? [existingStep]+ : [updatedStep, ...(additionalCreatedSteps ?? [])];++ await Promise.allSettled(+ stepsToDelete.map((stepToDelete) =>+ this.workflowVersionStepOperationsWorkspaceService.runWorkflowVersionStepDeletionSideEffects(+ {+ step: stepToDelete,+ workspaceId,+ },+ ),+ ),+ );+ }++ throw error;+ }++ if (isStepTypeChanged) {+ await this.workflowVersionStepOperationsWorkspaceService.runWorkflowVersionStepDeletionSideEffects(+ {+ step: existingStep,+ workspaceId,+ },+ );+ }return updatedStep;}@@ -258,14 +297,17 @@ export class CoreWorkflowVersionMutationWorkspaceService {coreWorkflowVersionId: string;trigger: WorkflowTrigger;}): Promise<WorkflowVersionTriggerDTO> {- await this.coreWorkflowVersionWriteService.getValidatedDraftCoreWorkflowVersion(- { workspaceId, coreWorkflowVersionId },- );+ const { coreWorkflowVersion, steps } =+ await this.coreWorkflowVersionWriteService.getValidatedDraftCoreWorkflowVersion(+ { workspaceId, coreWorkflowVersionId },+ );await this.coreWorkflowVersionWriteService.writeContentAndMirror({workspaceId,coreWorkflowVersionId,+ expectedVersion: coreWorkflowVersion,trigger,+ steps,});return { trigger };@@ -280,7 +322,7 @@ export class CoreWorkflowVersionMutationWorkspaceService {coreWorkflowVersionId: string;stepIdToDelete: string;}): Promise<WorkflowVersionStepChangesDTO> {- const { trigger, steps } =+ const { coreWorkflowVersion, trigger, steps } =await this.coreWorkflowVersionWriteService.getValidatedDraftCoreWorkflowVersion({ workspaceId, coreWorkflowVersionId },);@@ -318,8 +360,9 @@ export class CoreWorkflowVersionMutationWorkspaceService {await this.coreWorkflowVersionWriteService.writeContentAndMirror({workspaceId,coreWorkflowVersionId,- trigger: updatedTrigger === trigger ? undefined : updatedTrigger,- steps: updatedSteps === steps ? undefined : (updatedSteps ?? null),+ expectedVersion: coreWorkflowVersion,+ trigger: updatedTrigger ?? null,+ steps: updatedSteps ?? null,});const removedSteps =@@ -359,11 +402,12 @@ export class CoreWorkflowVersionMutationWorkspaceService {}): Promise<WorkflowVersionStepChangesDTO> {assertEdgeConnectionOptionsAreSupported(sourceConnectionOptions);- const { trigger, steps } = await this.getValidatedDraftWithTargetStep({- workspaceId,- coreWorkflowVersionId,- target,- });+ const { coreWorkflowVersion, trigger, steps } =+ await this.getValidatedDraftWithTargetStep({+ workspaceId,+ coreWorkflowVersionId,+ target,+ });if (source === TRIGGER_STEP_ID) {if (!isDefined(trigger)) {@@ -388,7 +432,9 @@ export class CoreWorkflowVersionMutationWorkspaceService {await this.coreWorkflowVersionWriteService.writeContentAndMirror({workspaceId,coreWorkflowVersionId,+ expectedVersion: coreWorkflowVersion,trigger: updatedTrigger,+ steps,});return computeWorkflowVersionStepChanges({@@ -428,6 +474,8 @@ export class CoreWorkflowVersionMutationWorkspaceService {await this.coreWorkflowVersionWriteService.writeContentAndMirror({workspaceId,coreWorkflowVersionId,+ expectedVersion: coreWorkflowVersion,+ trigger,steps: updatedSteps,});}@@ -454,11 +502,12 @@ export class CoreWorkflowVersionMutationWorkspaceService {}): Promise<WorkflowVersionStepChangesDTO> {assertEdgeConnectionOptionsAreSupported(sourceConnectionOptions);- const { trigger, steps } = await this.getValidatedDraftWithTargetStep({- workspaceId,- coreWorkflowVersionId,- target,- });+ const { coreWorkflowVersion, trigger, steps } =+ await this.getValidatedDraftWithTargetStep({+ workspaceId,+ coreWorkflowVersionId,+ target,+ });if (source === TRIGGER_STEP_ID) {if (!isDefined(trigger)) {@@ -485,7 +534,9 @@ export class CoreWorkflowVersionMutationWorkspaceService {await this.coreWorkflowVersionWriteService.writeContentAndMirror({workspaceId,coreWorkflowVersionId,+ expectedVersion: coreWorkflowVersion,trigger: updatedTrigger,+ steps,});return computeWorkflowVersionStepChanges({@@ -533,6 +584,8 @@ export class CoreWorkflowVersionMutationWorkspaceService {await this.coreWorkflowVersionWriteService.writeContentAndMirror({workspaceId,coreWorkflowVersionId,+ expectedVersion: coreWorkflowVersion,+ trigger,steps: updatedSteps,});@@ -552,7 +605,7 @@ export class CoreWorkflowVersionMutationWorkspaceService {coreWorkflowVersionId: string;positions: WorkflowStepPositionUpdateInput[];}): Promise<void> {- const { trigger, steps } =+ const { coreWorkflowVersion, trigger, steps } =await this.coreWorkflowVersionWriteService.getValidatedDraftCoreWorkflowVersion({ workspaceId, coreWorkflowVersionId },);@@ -579,8 +632,9 @@ export class CoreWorkflowVersionMutationWorkspaceService {await this.coreWorkflowVersionWriteService.writeContentAndMirror({workspaceId,coreWorkflowVersionId,- trigger: updatedTrigger,- steps: updatedSteps,+ expectedVersion: coreWorkflowVersion,+ trigger: updatedTrigger ?? trigger,+ steps: updatedSteps ?? steps,});}@@ -645,6 +699,7 @@ export class CoreWorkflowVersionMutationWorkspaceService {await this.coreWorkflowVersionWriteService.writeContentAndMirror({workspaceId,coreWorkflowVersionId: existingDraft.id,+ expectedVersion: existingDraft,trigger: triggerToCopy,steps: copiedSteps,});@@ -695,13 +750,6 @@ export class CoreWorkflowVersionMutationWorkspaceService {updatedStep: WorkflowAction;additionalCreatedSteps?: WorkflowAction[];}> {- await this.workflowVersionStepOperationsWorkspaceService.runWorkflowVersionStepDeletionSideEffects(- {- step: existingStep,- workspaceId,- },- );-const { builtStep, additionalCreatedSteps } =await this.workflowVersionStepOperationsWorkspaceService.runStepCreationSideEffectsAndBuildStep({diff --git a/packages/twenty-server/src/engine/core-modules/workflow/services/core-workflow-version-write.service.ts b/packages/twenty-server/src/engine/core-modules/workflow/services/core-workflow-version-write.service.tsindex 646d9d17b1a..ca5f875a186 100644--- a/packages/twenty-server/src/engine/core-modules/workflow/services/core-workflow-version-write.service.ts+++ b/packages/twenty-server/src/engine/core-modules/workflow/services/core-workflow-version-write.service.ts@@ -34,6 +34,15 @@ export type ValidatedDraftCoreWorkflowVersion = {steps: WorkflowAction[] | null;};+export class CoreWorkflowVersionPostCommitError extends Error {+ constructor(readonly cause: unknown) {+ super(+ 'Workflow version content was committed, but cache invalidation failed',+ );+ this.name = 'CoreWorkflowVersionPostCommitError';+ }+}+@Injectable()export class CoreWorkflowVersionWriteService {constructor(@@ -87,77 +96,78 @@ export class CoreWorkflowVersionWriteService {async writeContentAndMirror({workspaceId,coreWorkflowVersionId,+ expectedVersion,trigger,steps,}: {workspaceId: string;coreWorkflowVersionId: string;- trigger?: WorkflowTrigger | null;- steps?: WorkflowAction[] | null;+ expectedVersion: Pick<WorkflowVersionEntity, 'triggers' | 'steps'>;+ trigger: WorkflowTrigger | null;+ steps: WorkflowAction[] | null;}): Promise<void> {- if (trigger === undefined && steps === undefined) {- return;- }-await this.assertContentIsNotMalformed({workspaceId,coreWorkflowVersionId,- ...(await this.mergeWithPersistedContent({- workspaceId,- coreWorkflowVersionId,- trigger,- steps,- })),+ trigger,+ steps,});- const setClauses: string[] = [];- const parameters: (string | null)[] = [coreWorkflowVersionId, workspaceId];-- if (trigger !== undefined) {- parameters.push(isDefined(trigger) ? JSON.stringify([trigger]) : null);- setClauses.push(`"triggers" = $${parameters.length}`);- }-- if (steps !== undefined) {- parameters.push(isDefined(steps) ? JSON.stringify(steps) : null);- setClauses.push(`"steps" = $${parameters.length}`);- }-- const mirrorUpdatePayload: Pick<- Partial<WorkflowVersionWorkspaceEntity>,- 'trigger' | 'steps'- > = {- ...(trigger === undefined ? {} : { trigger }),- ...(steps === undefined ? {} : { steps }),- };-await this.workspaceOrmManager.executeInWorkspaceContext(async () => {await this.workspaceOrmManager.runInWorkspaceTransaction(async (transactionScope) => {- await transactionScope.executeRawQuery(- `UPDATE core."workflowVersion"- SET ${setClauses.join(', ')}, "updatedAt" = now()- WHERE "id" = $1 AND "workspaceId" = $2`,- parameters,- );-const mirrorUpdateResult = await transactionScope.getRepository<WorkflowVersionWorkspaceEntity>('workflowVersion', {shouldBypassPermissionChecks: true,})- .update({ coreWorkflowVersionId }, mirrorUpdatePayload);+ .update({ coreWorkflowVersionId }, { trigger, steps });assertExactlyOneMirrorRowWasWritten({affected: mirrorUpdateResult.affected,coreWorkflowVersionId,});++ const updatedVersions = await transactionScope.executeRawQuery(+ `UPDATE core."workflowVersion"+ SET "triggers" = $3, "steps" = $4, "updatedAt" = now()+ WHERE "id" = $1 AND "workspaceId" = $2 AND "status" = 'DRAFT'+ AND "triggers" IS NOT DISTINCT FROM $5::jsonb+ AND "steps" IS NOT DISTINCT FROM $6::jsonb+ RETURNING "id"`,+ [+ coreWorkflowVersionId,+ workspaceId,+ isDefined(trigger) ? JSON.stringify([trigger]) : null,+ isDefined(steps) ? JSON.stringify(steps) : null,+ isDefined(expectedVersion.triggers)+ ? JSON.stringify(expectedVersion.triggers)+ : null,+ isDefined(expectedVersion.steps)+ ? JSON.stringify(expectedVersion.steps)+ : null,+ ],+ );++ if (updatedVersions.length !== 1) {+ throw new WorkflowQueryValidationException(+ `Core workflow version '${coreWorkflowVersionId}' changed during this edit`,+ WorkflowQueryValidationExceptionCode.FORBIDDEN,+ {+ userFriendlyMessage: msg`Workflow version changed, please reload and retry`,+ },+ );+ }},);}, buildSystemAuthContext(workspaceId));- await this.workflowVersionCoreSyncService.invalidateAutomatedTriggerMaps(- workspaceId,- );+ try {+ await this.workflowVersionCoreSyncService.invalidateAutomatedTriggerMaps(+ workspaceId,+ );+ } catch (error) {+ throw new CoreWorkflowVersionPostCommitError(error);+ }}async createDraftCoreWorkflowVersionAndMirror({@@ -256,42 +266,6 @@ export class CoreWorkflowVersionWriteService {});}- private async mergeWithPersistedContent({- workspaceId,- coreWorkflowVersionId,- trigger,- steps,- }: {- workspaceId: string;- coreWorkflowVersionId: string;- trigger?: WorkflowTrigger | null;- steps?: WorkflowAction[] | null;- }): Promise<{- trigger: WorkflowTrigger | null;- steps: WorkflowAction[] | null;- }> {- if (trigger !== undefined && steps !== undefined) {- return { trigger, steps };- }-- const persistedCoreWorkflowVersion =- await this.coreWorkflowVersionRepository.findOne(workspaceId, {- where: { id: coreWorkflowVersionId },- select: { id: true, triggers: true, steps: true },- });-- return {- trigger:- trigger === undefined- ? (persistedCoreWorkflowVersion?.triggers?.[0] ?? null)- : trigger,- steps:- steps === undefined- ? (persistedCoreWorkflowVersion?.steps ?? null)- : steps,- };- }-private async assertContentIsNotMalformed({workspaceId,coreWorkflowVersionId,diff --git a/packages/twenty-server/src/engine/core-modules/workflow/services/workflow-core-sync.service.ts b/packages/twenty-server/src/engine/core-modules/workflow/services/workflow-core-sync.service.tsindex b4b0235e083..7c0d2ce7e82 100644--- a/packages/twenty-server/src/engine/core-modules/workflow/services/workflow-core-sync.service.ts+++ b/packages/twenty-server/src/engine/core-modules/workflow/services/workflow-core-sync.service.ts@@ -13,6 +13,7 @@ import { WorkspaceOrmManager } from 'src/engine/twenty-orm/workspace-orm.managerimport { InjectWorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/inject-workspace-scoped-repository.decorator';import { WorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/workspace-scoped-repository';import { buildSystemAuthContext } from 'src/engine/twenty-orm/utils/build-system-auth-context.util';+import { getWorkspaceSchemaName } from 'src/engine/workspace-datasource/utils/get-workspace-schema-name.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';@@ -32,11 +33,24 @@ export class WorkflowCoreSyncService {async upsertToCore(workspaceId: string,- workflows: WorkflowWorkspaceEntity[],+ workspaceWorkflowIds: string[],): Promise<void> {- const liveWorkflows = workflows.filter(- (workflow) => !isDefined(workflow.deletedAt),- );+ if (workspaceWorkflowIds.length === 0) {+ return;+ }++ const liveWorkflows =+ await this.workspaceOrmManager.executeInWorkspaceContext(async () => {+ const workflowRepository =+ this.workspaceOrmManager.getRepository<WorkflowWorkspaceEntity>(+ 'workflow',+ { shouldBypassPermissionChecks: true },+ );++ return workflowRepository.find({+ where: { id: In(workspaceWorkflowIds) },+ });+ }, buildSystemAuthContext(workspaceId));if (liveWorkflows.length === 0) {return;@@ -109,6 +123,89 @@ export class WorkflowCoreSyncService {);}+ async reconcileWorkspaceWorkflows(+ workspaceId: string,+ workspaceWorkflowIds: string[],+ ): Promise<void> {+ const schema = getWorkspaceSchemaName(workspaceId);++ await this.workspaceOrmManager.executeInWorkspaceContext(async () => {+ await this.workspaceOrmManager.runInWorkspaceTransaction(+ async (transactionScope) => {+ for (const workspaceWorkflowId of [+ ...new Set(workspaceWorkflowIds),+ ].sort()) {+ const workflows = (await transactionScope.executeRawQuery(+ `SELECT * FROM "${schema}"."workflow" WHERE id = $1 FOR UPDATE`,+ [workspaceWorkflowId],+ )) as Pick<+ WorkflowWorkspaceEntity,+ | 'id'+ | 'name'+ | 'coreWorkflowId'+ | 'lastPublishedVersionId'+ | 'deletedAt'+ >[];+ const workflow = workflows[0];++ if (!isDefined(workflow) || isDefined(workflow.deletedAt)) {+ await transactionScope.executeRawQuery(+ `DELETE FROM core."workflow" WHERE "workspaceId" = $1 AND "workspaceWorkflowId" = $2`,+ [workspaceId, workspaceWorkflowId],+ );+ continue;+ }++ const coreWorkflows = (await transactionScope.executeRawQuery(+ `SELECT id FROM core."workflow" WHERE "workspaceId" = $1 AND "workspaceWorkflowId" = $2 FOR UPDATE`,+ [workspaceId, workspaceWorkflowId],+ )) as { id: string }[];++ if (+ coreWorkflows.length !== 1 ||+ workflow.coreWorkflowId !== coreWorkflows[0].id+ ) {+ throw new Error(+ `Invalid core mapping for workflow ${workspaceWorkflowId} in workspace ${workspaceId}`,+ );+ }++ const coreWorkflowId = coreWorkflows[0].id;+ let coreWorkflowVersionId: string | null = null;++ if (isNonEmptyString(workflow.lastPublishedVersionId)) {+ const versions = (await transactionScope.executeRawQuery(+ `SELECT id FROM core."workflowVersion" WHERE "workspaceId" = $1 AND "workspaceWorkflowVersionId" = $2 AND "coreWorkflowId" = $3`,+ [workspaceId, workflow.lastPublishedVersionId, coreWorkflowId],+ )) as { id: string }[];++ if (versions.length !== 1) {+ throw new Error(+ `Invalid published core version mapping for workflow ${workspaceWorkflowId} in workspace ${workspaceId}`,+ );+ }++ coreWorkflowVersionId = versions[0].id;+ }++ await transactionScope.executeRawQuery(+ `UPDATE core."workflow" SET "name" = $3, "lastPublishedVersionId" = $4, "lastPublishedCoreWorkflowVersionId" = $5, "updatedAt" = now() WHERE id = $1 AND "workspaceId" = $2`,+ [+ coreWorkflowId,+ workspaceId,+ workflow.name ?? null,+ isNonEmptyString(workflow.lastPublishedVersionId)+ ? workflow.lastPublishedVersionId+ : null,+ coreWorkflowVersionId,+ ],+ );+ }+ },+ );+ }, buildSystemAuthContext(workspaceId));+ }+private async resolveCoreVersionIdByWorkspaceVersionId(workspaceId: string,workflows: WorkflowWorkspaceEntity[],@@ -180,6 +277,32 @@ export class WorkflowCoreSyncService {});}+ async findCoreWorkflowById(+ workspaceId: string,+ coreWorkflowId: string,+ ): Promise<WorkflowEntity | null> {+ return this.coreWorkflowRepository.findOne(workspaceId, {+ where: { id: coreWorkflowId },+ });+ }++ async findCoreWorkflowByIdOrWorkspaceWorkflowId(+ workspaceId: string,+ workflowId: string,+ ): Promise<WorkflowEntity | null> {+ const workflows = await this.coreWorkflowRepository.find(workspaceId, {+ where: [{ id: workflowId }, { workspaceWorkflowId: workflowId }],+ });++ if (workflows.length > 1) {+ throw new Error(+ `Ambiguous core workflow mapping for ${workflowId} in workspace ${workspaceId}`,+ );+ }++ return workflows[0] ?? null;+ }+private async writeBackCoreWorkflowIds(workspaceId: string,coreWorkflowIdByWorkspaceRecordId: Map<string, string>,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 bf45472f8c1..982fdf9d979 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@@ -3,7 +3,7 @@ import { InjectRepository } from '@nestjs/typeorm';import { isNonEmptyString } from '@sniptt/guards';import { STANDARD_OBJECTS } from 'twenty-shared/metadata';-import { isDefined, isNonEmptyArray } from 'twenty-shared/utils';+import { isDefined } from 'twenty-shared/utils';import { In, Repository } from 'typeorm';import { v4 as uuidv4 } from 'uuid';@@ -12,6 +12,8 @@ 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 { hasCoreWorkflowWorkspaceVersionIdColumn } from 'src/engine/core-modules/workflow/utils/has-core-workflow-workspace-version-id-column.util';+import { hasCoreWorkflowWorkspaceWorkflowIdColumn } from 'src/engine/core-modules/workflow/utils/has-core-workflow-workspace-workflow-id-column.util';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';@@ -90,6 +92,7 @@ export class WorkflowVersionCoreSyncService {return {id: coreWorkflowVersionId,+ workspaceWorkflowVersionId: workflowVersion.id,workflowId: workflowVersion.workflowId,coreWorkflowId: resolvedCoreWorkflowId,triggers: isDefined(workflowVersion.trigger)@@ -97,7 +100,6 @@ export class WorkflowVersionCoreSyncService {: null,steps: workflowVersion.steps ?? null,status: workflowVersion.status as unknown as WorkflowVersionStatus,- workspaceWorkflowVersionId: workflowVersion.id,universalIdentifier: uuidv4(),applicationId,};@@ -165,6 +167,15 @@ export class WorkflowVersionCoreSyncService {});}+ async findCoreVersionByWorkspaceVersionId(+ workspaceId: string,+ workspaceWorkflowVersionId: string,+ ): Promise<WorkflowVersionEntity | null> {+ return this.coreWorkflowVersionRepository.findOne(workspaceId, {+ where: { workspaceWorkflowVersionId },+ });+ }+async mirrorWorkflowVersionWrite({workspaceId,transactionScope,@@ -187,20 +198,58 @@ export class WorkflowVersionCoreSyncService {const resolvedApplicationId =applicationId ?? (await this.getCustomApplicationIdOrThrow(workspaceId));+ const hasWorkspaceVersionMapping =+ await hasCoreWorkflowWorkspaceVersionIdColumn((query) =>+ transactionScope.executeRawQuery(query),+ );const candidateCoreVersionId = workflowVersion.coreWorkflowVersionId;+ const candidateRows = isNonEmptyString(candidateCoreVersionId)+ ? ((await transactionScope.executeRawQuery(+ `SELECT "id", "workspaceId", "workflowId"${hasWorkspaceVersionMapping ? ', "workspaceWorkflowVersionId"' : ''} FROM core."workflowVersion" WHERE id = $1 FOR UPDATE`,+ [candidateCoreVersionId],+ )) as {+ id: string;+ workspaceId: string;+ workflowId: string | null;+ workspaceWorkflowVersionId?: string | null;+ }[])+ : [];+ const candidate = candidateRows[0];++ if (+ isDefined(candidate) &&+ (candidate.workspaceId !== workspaceId ||+ candidate.workflowId !== workflowVersion.workflowId ||+ (isDefined(candidate.workspaceWorkflowVersionId) &&+ candidate.workspaceWorkflowVersionId !== workflowVersion.id))+ ) {+ throw new Error(+ `Conflicting core mapping for workflow version ${workflowVersion.id} in workspace ${workspaceId}`,+ );+ }- const linkedCoreVersionId =- isNonEmptyString(candidateCoreVersionId) &&- (await this.isCoreVersionOwnedByWorkspace({- coreWorkflowVersionId: candidateCoreVersionId,- workspaceId,- transactionScope,- }))- ? candidateCoreVersionId- : null;+ const reverseRows = hasWorkspaceVersionMapping+ ? ((await transactionScope.executeRawQuery(+ `SELECT id FROM core."workflowVersion" WHERE "workspaceId" = $1 AND "workspaceWorkflowVersionId" = $2 FOR UPDATE`,+ [workspaceId, workflowVersion.id],+ )) as { id: string }[])+ : [];++ if (+ reverseRows.length > 1 ||+ (isDefined(candidate) &&+ isDefined(reverseRows[0]) &&+ reverseRows[0].id !== candidate.id)+ ) {+ throw new Error(+ `Ambiguous core mapping for workflow version ${workflowVersion.id} in workspace ${workspaceId}`,+ );+ }- const isNewLink = !isDefined(linkedCoreVersionId);- const coreWorkflowVersionId = linkedCoreVersionId ?? uuidv4();+ const coreWorkflowVersionId =+ reverseRows[0]?.id ?? candidateCoreVersionId ?? uuidv4();+ const isNewLink =+ workflowVersion.coreWorkflowVersionId !== coreWorkflowVersionId;const coreWorkflowId = await this.resolveCoreWorkflowIdInTransaction({workspaceId,@@ -211,17 +260,17 @@ export class WorkflowVersionCoreSyncService {// 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(+ const mirroredRows = await transactionScope.executeRawQuery(`INSERT INTO core."workflowVersion"- ("id", "workspaceId", "workflowId", "triggers", "steps", "status", "universalIdentifier", "applicationId", "coreWorkflowId", "workspaceWorkflowVersionId")- VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)+ ("id", "workspaceId", "workflowId", "triggers", "steps", "status", "universalIdentifier", "applicationId", "coreWorkflowId"${hasWorkspaceVersionMapping ? ', "workspaceWorkflowVersionId"' : ''})+ VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9${hasWorkspaceVersionMapping ? ', $10' : ''})ON CONFLICT ("id") DO UPDATE SET+ ${hasWorkspaceVersionMapping ? '"workspaceWorkflowVersionId" = EXCLUDED."workspaceWorkflowVersionId",' : ''}"triggers" = EXCLUDED."triggers","steps" = EXCLUDED."steps","status" = EXCLUDED."status",- "coreWorkflowId" = COALESCE(EXCLUDED."coreWorkflowId", core."workflowVersion"."coreWorkflowId"),- "workspaceWorkflowVersionId" = EXCLUDED."workspaceWorkflowVersionId"- WHERE core."workflowVersion"."workspaceId" = EXCLUDED."workspaceId"`,+ "coreWorkflowId" = COALESCE(EXCLUDED."coreWorkflowId", core."workflowVersion"."coreWorkflowId")+ WHERE core."workflowVersion"."workspaceId" = EXCLUDED."workspaceId" RETURNING id`,[coreWorkflowVersionId,workspaceId,@@ -236,10 +285,16 @@ export class WorkflowVersionCoreSyncService {uuidv4(),resolvedApplicationId,coreWorkflowId,- workflowVersion.id,+ ...(hasWorkspaceVersionMapping ? [workflowVersion.id] : []),],);+ if (mirroredRows.length !== 1) {+ throw new Error(+ `Core workflow version ${coreWorkflowVersionId} could not be mirrored in workspace ${workspaceId}`,+ );+ }+if (isNewLink) {await this.writeBackCoreVersionIdInTransaction(workflowVersion.id,@@ -327,10 +382,34 @@ export class WorkflowVersionCoreSyncService {const pointedCoreWorkflowId = workflow?.coreWorkflowId ?? null;- if (isNonEmptyString(pointedCoreWorkflowId)) {+ const isColumnAvailable = await hasCoreWorkflowWorkspaceWorkflowIdColumn(+ (query) => transactionScope.executeRawQuery(query),+ );++ if (!isColumnAvailable) {return pointedCoreWorkflowId;}+ if (isNonEmptyString(pointedCoreWorkflowId)) {+ const pointedRows = (await transactionScope.executeRawQuery(+ `SELECT "workspaceId", "workspaceWorkflowId" FROM core."workflow" WHERE id = $1 FOR UPDATE`,+ [pointedCoreWorkflowId],+ )) as { workspaceId: string; workspaceWorkflowId: string | null }[];+ const pointed = pointedRows[0];++ if (isDefined(pointed)) {+ if (+ pointed.workspaceId !== workspaceId ||+ pointed.workspaceWorkflowId !== workflowId+ ) {+ throw new Error(+ `Conflicting core mapping for workflow ${workflowId} in workspace ${workspaceId}`,+ );+ }+ return pointedCoreWorkflowId;+ }+ }+const coreWorkflowIdByWorkspaceWorkflowId =await resolveCoreWorkflowIdsByWorkspaceWorkflowId({executeQuery: (query, parameters) =>@@ -342,25 +421,6 @@ export class WorkflowVersionCoreSyncService {return coreWorkflowIdByWorkspaceWorkflowId.get(workflowId) ?? null;}- // Must run inside the caller's transaction so the ownership answer cannot go- // stale before the insert below uses it.- private async isCoreVersionOwnedByWorkspace({- coreWorkflowVersionId,- workspaceId,- transactionScope,- }: {- coreWorkflowVersionId: string;- workspaceId: string;- transactionScope: WorkspaceTransactionScope;- }): Promise<boolean> {- const rows = await transactionScope.executeRawQuery(- `SELECT 1 FROM core."workflowVersion" WHERE "id" = $1 AND "workspaceId" = $2`,- [coreWorkflowVersionId, workspaceId],- );-- return isNonEmptyArray(rows);- }-async mirrorWorkflowVersionWrites({workspaceId,transactionScope,@@ -531,18 +591,27 @@ export class WorkflowVersionCoreSyncService {workflowId: string,): Promise<void> {await this.workspaceOrmManager.executeInWorkspaceContext(async () => {- const workflowVersionRepository =- this.workspaceOrmManager.getRepository<WorkflowVersionWorkspaceEntity>(- 'workflowVersion',- { shouldBypassPermissionChecks: true },- );-- const versions = await workflowVersionRepository.find({- where: { workflowId },- });+ await this.workspaceOrmManager.runInWorkspaceTransaction(+ async (transactionScope) => {+ const workflowVersionRepository =+ transactionScope.getRepository<WorkflowVersionWorkspaceEntity>(+ 'workflowVersion',+ { shouldBypassPermissionChecks: true },+ );+ const versions = await workflowVersionRepository.find({+ where: { workflowId },+ });- await this.upsertToCore(workspaceId, versions);+ await this.mirrorWorkflowVersionWrites({+ workspaceId,+ transactionScope,+ workflowVersions: versions,+ });+ },+ );}, buildSystemAuthContext(workspaceId));++ await this.invalidateAutomatedTriggerMaps(workspaceId);}private async writeBackCoreVersionIds(diff --git a/packages/twenty-server/src/engine/core-modules/workflow/services/workspace-workflow-automated-trigger-map-cache.service.ts b/packages/twenty-server/src/engine/core-modules/workflow/services/workspace-workflow-automated-trigger-map-cache.service.tsindex 805c984f93b..3152b08b262 100644--- a/packages/twenty-server/src/engine/core-modules/workflow/services/workspace-workflow-automated-trigger-map-cache.service.ts+++ b/packages/twenty-server/src/engine/core-modules/workflow/services/workspace-workflow-automated-trigger-map-cache.service.ts@@ -1,8 +1,6 @@-import { Injectable, Logger } from '@nestjs/common';+import { Injectable } from '@nestjs/common';-import { STANDARD_OBJECTS } from 'twenty-shared/metadata';import { isDefined } from 'twenty-shared/utils';-import { In } from 'typeorm';import {WorkflowVersionEntity,@@ -10,28 +8,19 @@ import {} from 'src/engine/core-modules/workflow/entities/workflow-version.entity';import { type WorkflowAutomatedTriggerMaps } from 'src/engine/core-modules/workflow/types/workflow-automated-trigger-maps.type';import { computeAutomatedTriggerFromWorkflowVersion } from 'src/engine/core-modules/workflow/utils/compute-automated-trigger-from-workflow-version.util';-import { WorkspaceOrmManager } from 'src/engine/twenty-orm/workspace-orm.manager';-import { buildSystemAuthContext } from 'src/engine/twenty-orm/utils/build-system-auth-context.util';import { InjectWorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/inject-workspace-scoped-repository.decorator';import { WorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/workspace-scoped-repository';+import { UpgradeAwareRepositoryState } from 'src/engine/twenty-orm/upgrade-aware/upgrade-aware-repository-state';import { WorkspaceCache } from 'src/engine/workspace-cache/decorators/workspace-cache.decorator';-import { WorkspaceCacheService } from 'src/engine/workspace-cache/services/workspace-cache.service';import { WorkspaceCacheProvider } from 'src/engine/workspace-cache/interfaces/workspace-cache-provider.service';import { type WorkspaceCacheProviderContext } from 'src/engine/workspace-cache/types/workspace-cache-provider-context.type';-import { type WorkflowVersionWorkspaceEntity } from 'src/modules/workflow/common/standard-objects/workflow-version.workspace-entity';@Injectable()@WorkspaceCache('workflowAutomatedTriggerMaps', { packingPonderation: 1 })export class WorkspaceWorkflowAutomatedTriggerMapCacheService extends WorkspaceCacheProvider<WorkflowAutomatedTriggerMaps> {- private readonly logger = new Logger(- WorkspaceWorkflowAutomatedTriggerMapCacheService.name,- );-constructor(@InjectWorkspaceScopedRepository(WorkflowVersionEntity)private readonly workflowVersionRepository: WorkspaceScopedRepository<WorkflowVersionEntity>,- private readonly workspaceOrmManager: WorkspaceOrmManager,- private readonly workspaceCacheService: WorkspaceCacheService,) {super();}@@ -39,135 +28,45 @@ export class WorkspaceWorkflowAutomatedTriggerMapCacheService extends WorkspaceCasync computeForCache({workspaceId,}: WorkspaceCacheProviderContext): Promise<WorkflowAutomatedTriggerMaps> {+ const hiddenColumns =+ UpgradeAwareRepositoryState.getInstance().getHiddenColumnPropertyNames(+ WorkflowVersionEntity,+ );++ if (hiddenColumns.has('workspaceWorkflowVersionId')) {+ return { byWorkflowId: {} };+ }+const activeWorkflowVersions = await this.workflowVersionRepository.find(workspaceId,{ where: { status: WorkflowVersionStatus.ACTIVE } },);- const workspaceVersionIdByCoreVersionId =- await this.findWorkspaceVersionIdByCoreVersionId({- workspaceId,- activeWorkflowVersions,- });-const byWorkflowId: WorkflowAutomatedTriggerMaps['byWorkflowId'] = {};for (const workflowVersion of activeWorkflowVersions) {+ if (!isDefined(workflowVersion.coreWorkflowId)) {+ throw new Error(+ `Active core workflow version ${workflowVersion.id} has no core workflow id in workspace ${workspaceId}`,+ );+ }+const automatedTrigger = computeAutomatedTriggerFromWorkflowVersion({workflowVersion,- workspaceWorkflowVersionId:- workspaceVersionIdByCoreVersionId[workflowVersion.id] ?? null,+ workspaceWorkflowVersionId: workflowVersion.workspaceWorkflowVersionId,});if (isDefined(automatedTrigger)) {- byWorkflowId[workflowVersion.workflowId] = automatedTrigger;- }- }-- return { byWorkflowId };- }-- private async findWorkspaceVersionIdByCoreVersionId({- workspaceId,- activeWorkflowVersions,- }: {- workspaceId: string;- activeWorkflowVersions: WorkflowVersionEntity[];- }): Promise<Record<string, string>> {- if (activeWorkflowVersions.length === 0) {- return {};- }-- if (!(await this.workspaceHasCoreWorkflowVersionIdField(workspaceId))) {- this.logger.warn(- `workflowVersion.coreWorkflowVersionId field missing for workspace ${workspaceId}, skipping workspace twin resolution`,- );-- return {};- }-- const authContext = buildSystemAuthContext(workspaceId);-- return this.workspaceOrmManager.executeInWorkspaceContext(async () => {- const workspaceWorkflowVersionRepository =- this.workspaceOrmManager.getRepository<WorkflowVersionWorkspaceEntity>(- 'workflowVersion',- { shouldBypassPermissionChecks: true },- );-- const workspaceWorkflowVersions =- await workspaceWorkflowVersionRepository.find({- where: {- coreWorkflowVersionId: In(- activeWorkflowVersions.map(- (workflowVersion) => workflowVersion.id,- ),- ),- },- select: {- id: true,- workflowId: true,- coreWorkflowVersionId: true,- },- });-- const workflowIdByCoreVersionId = Object.fromEntries(- activeWorkflowVersions.map((workflowVersion) => [- workflowVersion.id,- workflowVersion.workflowId,- ]),- );-- const twinIdsByCoreVersionId = new Map<string, string[]>();-- for (const workspaceWorkflowVersion of workspaceWorkflowVersions) {- const { coreWorkflowVersionId } = workspaceWorkflowVersion;-- if (- !isDefined(coreWorkflowVersionId) ||- workflowIdByCoreVersionId[coreWorkflowVersionId] !==- workspaceWorkflowVersion.workflowId- ) {- continue;+ if (isDefined(byWorkflowId[workflowVersion.coreWorkflowId])) {+ throw new Error(+ `Multiple active core versions for workflow ${workflowVersion.coreWorkflowId} in workspace ${workspaceId}`,+ );}- twinIdsByCoreVersionId.set(coreWorkflowVersionId, [- ...(twinIdsByCoreVersionId.get(coreWorkflowVersionId) ?? []),- workspaceWorkflowVersion.id,- ]);+ byWorkflowId[workflowVersion.coreWorkflowId] = automatedTrigger;}+ }- return Object.fromEntries(- [...twinIdsByCoreVersionId.entries()].flatMap(- ([coreWorkflowVersionId, twinIds]) => {- if (twinIds.length > 1) {- this.logger.error(- `Core workflow version ${coreWorkflowVersionId} has ${twinIds.length} workspace twins in workspace ${workspaceId}, skipping core dispatch`,- );-- return [];- }-- return [[coreWorkflowVersionId, twinIds[0]]];- },- ),- );- }, authContext);- }-- private async workspaceHasCoreWorkflowVersionIdField(- workspaceId: string,- ): Promise<boolean> {- const { flatFieldMetadataMaps } =- await this.workspaceCacheService.getOrRecompute(workspaceId, [- 'flatFieldMetadataMaps',- ]);-- return isDefined(- flatFieldMetadataMaps.byUniversalIdentifier[- STANDARD_OBJECTS.workflowVersion.fields.coreWorkflowVersionId- .universalIdentifier- ],- );+ return { byWorkflowId };}}diff --git a/packages/twenty-server/src/engine/core-modules/workflow/types/workflow-automated-trigger-maps.type.ts b/packages/twenty-server/src/engine/core-modules/workflow/types/workflow-automated-trigger-maps.type.tsindex bf457a33f01..45015f3a024 100644--- a/packages/twenty-server/src/engine/core-modules/workflow/types/workflow-automated-trigger-maps.type.ts+++ b/packages/twenty-server/src/engine/core-modules/workflow/types/workflow-automated-trigger-maps.type.ts@@ -2,11 +2,15 @@ import { type AutomatedTriggerType } from 'src/modules/workflow/common/standard-import { type AutomatedTriggerSettings } from 'src/modules/workflow/workflow-trigger/automated-trigger/constants/automated-trigger-settings';export type CoreDispatchIds =- | { coreWorkflowVersionId: string; workspaceWorkflowVersionId: string }- | { coreWorkflowVersionId?: null; workspaceWorkflowVersionId?: null };+ | { coreWorkflowVersionId: string; workspaceWorkflowVersionId?: string }+ | {+ coreWorkflowVersionId?: null;+ workspaceWorkflowVersionId?: string | null;+ };export type CachedWorkflowAutomatedTrigger = {workflowId: string;+ legacyWorkflowId?: string;type: AutomatedTriggerType;settings: AutomatedTriggerSettings;} & CoreDispatchIds;diff --git a/packages/twenty-server/src/engine/core-modules/workflow/utils/__tests__/build-core-dispatch-ids.util.spec.ts b/packages/twenty-server/src/engine/core-modules/workflow/utils/__tests__/build-core-dispatch-ids.util.spec.tsindex a63e8781ee4..12732c4bc7b 100644--- a/packages/twenty-server/src/engine/core-modules/workflow/utils/__tests__/build-core-dispatch-ids.util.spec.ts+++ b/packages/twenty-server/src/engine/core-modules/workflow/utils/__tests__/build-core-dispatch-ids.util.spec.ts@@ -13,20 +13,17 @@ describe('buildCoreDispatchIds', () => {});});- it('should collapse a half resolved pair to the legacy shape', () => {+ it('should build a core-only dispatch envelope', () => {expect(buildCoreDispatchIds({ coreWorkflowVersionId: 'core-version-1' }),- ).toEqual({- coreWorkflowVersionId: null,- workspaceWorkflowVersionId: null,- });+ ).toEqual({ coreWorkflowVersionId: 'core-version-1' });expect(buildCoreDispatchIds({workspaceWorkflowVersionId: 'workspace-version-1',}),).toEqual({coreWorkflowVersionId: null,- workspaceWorkflowVersionId: null,+ workspaceWorkflowVersionId: 'workspace-version-1',});expect(buildCoreDispatchIds({})).toEqual({coreWorkflowVersionId: null,diff --git a/packages/twenty-server/src/engine/core-modules/workflow/utils/__tests__/compute-automated-trigger-from-workflow-version.util.spec.ts b/packages/twenty-server/src/engine/core-modules/workflow/utils/__tests__/compute-automated-trigger-from-workflow-version.util.spec.tsindex 89904c5dd3a..3857d103703 100644--- a/packages/twenty-server/src/engine/core-modules/workflow/utils/__tests__/compute-automated-trigger-from-workflow-version.util.spec.ts+++ b/packages/twenty-server/src/engine/core-modules/workflow/utils/__tests__/compute-automated-trigger-from-workflow-version.util.spec.ts@@ -8,6 +8,7 @@ import {const buildWorkflowVersion = (trigger: WorkflowTrigger | null) => ({id: 'core-version-1',workflowId: 'workspace-workflow-1',+ coreWorkflowId: 'core-workflow-1',triggers: trigger ? [trigger] : [],});@@ -25,7 +26,8 @@ describe('computeAutomatedTriggerFromWorkflowVersion', () => {workspaceWorkflowVersionId: 'workspace-version-1',}),).toEqual({- workflowId: 'workspace-workflow-1',+ workflowId: 'core-workflow-1',+ legacyWorkflowId: 'workspace-workflow-1',coreWorkflowVersionId: 'core-version-1',workspaceWorkflowVersionId: 'workspace-version-1',type: AutomatedTriggerType.DATABASE_EVENT,@@ -33,7 +35,7 @@ describe('computeAutomatedTriggerFromWorkflowVersion', () => {});});- it('should collapse both ids to the legacy shape when the twin is missing', () => {+ it('should build a core-only dispatch when the twin is missing', () => {const workflowVersion = buildWorkflowVersion({type: WorkflowTriggerType.DATABASE_EVENT,name: 'Record created',@@ -45,8 +47,12 @@ describe('computeAutomatedTriggerFromWorkflowVersion', () => {workspaceWorkflowVersionId: null,});- expect(automatedTrigger?.workspaceWorkflowVersionId).toBeNull();- expect(automatedTrigger?.coreWorkflowVersionId).toBeNull();+ expect(automatedTrigger).toMatchObject({+ workflowId: 'core-workflow-1',+ legacyWorkflowId: 'workspace-workflow-1',+ coreWorkflowVersionId: 'core-version-1',+ });+ expect(automatedTrigger).not.toHaveProperty('workspaceWorkflowVersionId');});it('should return null for manual triggers', () => {diff --git a/packages/twenty-server/src/engine/core-modules/workflow/utils/build-core-dispatch-ids.util.ts b/packages/twenty-server/src/engine/core-modules/workflow/utils/build-core-dispatch-ids.util.tsindex 6011b889742..6631a844a1b 100644--- a/packages/twenty-server/src/engine/core-modules/workflow/utils/build-core-dispatch-ids.util.ts+++ b/packages/twenty-server/src/engine/core-modules/workflow/utils/build-core-dispatch-ids.util.ts@@ -9,6 +9,14 @@ export const buildCoreDispatchIds = ({coreWorkflowVersionId?: string | null;workspaceWorkflowVersionId?: string | null;}): CoreDispatchIds =>- isDefined(coreWorkflowVersionId) && isDefined(workspaceWorkflowVersionId)- ? { coreWorkflowVersionId, workspaceWorkflowVersionId }- : { coreWorkflowVersionId: null, workspaceWorkflowVersionId: null };+ isDefined(coreWorkflowVersionId)+ ? {+ coreWorkflowVersionId,+ ...(isDefined(workspaceWorkflowVersionId)+ ? { workspaceWorkflowVersionId }+ : {}),+ }+ : {+ coreWorkflowVersionId: null,+ workspaceWorkflowVersionId: workspaceWorkflowVersionId ?? null,+ };diff --git a/packages/twenty-server/src/engine/core-modules/workflow/utils/compute-automated-trigger-from-workflow-version.util.ts b/packages/twenty-server/src/engine/core-modules/workflow/utils/compute-automated-trigger-from-workflow-version.util.tsindex 50bc8738675..255eb435f05 100644--- a/packages/twenty-server/src/engine/core-modules/workflow/utils/compute-automated-trigger-from-workflow-version.util.ts+++ b/packages/twenty-server/src/engine/core-modules/workflow/utils/compute-automated-trigger-from-workflow-version.util.ts@@ -12,20 +12,21 @@ export const computeAutomatedTriggerFromWorkflowVersion = ({}: {workflowVersion: Pick<WorkflowVersionEntity,- 'id' | 'workflowId' | 'triggers'+ 'id' | 'workflowId' | 'coreWorkflowId' | 'triggers'>;workspaceWorkflowVersionId: string | null;}): CachedWorkflowAutomatedTrigger | null => {const trigger = workflowVersion.triggers?.[0] ?? null;- if (trigger === null) {+ if (trigger === null || workflowVersion.coreWorkflowId === null) {return null;}switch (trigger.type) {case WorkflowTriggerType.DATABASE_EVENT:return {- workflowId: workflowVersion.workflowId,+ workflowId: workflowVersion.coreWorkflowId,+ legacyWorkflowId: workflowVersion.workflowId ?? undefined,...buildCoreDispatchIds({coreWorkflowVersionId: workflowVersion.id,workspaceWorkflowVersionId,@@ -35,7 +36,8 @@ export const computeAutomatedTriggerFromWorkflowVersion = ({};case WorkflowTriggerType.CRON:return {- workflowId: workflowVersion.workflowId,+ workflowId: workflowVersion.coreWorkflowId,+ legacyWorkflowId: workflowVersion.workflowId ?? undefined,...buildCoreDispatchIds({coreWorkflowVersionId: workflowVersion.id,workspaceWorkflowVersionId,diff --git a/packages/twenty-server/src/engine/core-modules/workflow/utils/has-core-workflow-workspace-version-id-column.util.ts b/packages/twenty-server/src/engine/core-modules/workflow/utils/has-core-workflow-workspace-version-id-column.util.tsnew file mode 100644index 00000000000..cce6a4d0a0c--- /dev/null+++ b/packages/twenty-server/src/engine/core-modules/workflow/utils/has-core-workflow-workspace-version-id-column.util.ts@@ -0,0 +1,11 @@+export const hasCoreWorkflowWorkspaceVersionIdColumn = async (+ executeQuery: (query: string) => Promise<unknown[]>,+): Promise<boolean> => {+ const rows = await executeQuery(+ `SELECT 1 FROM information_schema.columns+ WHERE table_schema = 'core' AND table_name = 'workflowVersion'+ AND column_name = 'workspaceWorkflowVersionId'`,+ );++ return rows.length > 0;+};diff --git a/packages/twenty-server/src/engine/workspace-manager/twenty-standard-application/utils/field-metadata/compute-workflow-run-standard-flat-field-metadata.util.ts b/packages/twenty-server/src/engine/workspace-manager/twenty-standard-application/utils/field-metadata/compute-workflow-run-standard-flat-field-metadata.util.tsindex 48739d36c49..77aa217b3ab 100644--- a/packages/twenty-server/src/engine/workspace-manager/twenty-standard-application/utils/field-metadata/compute-workflow-run-standard-flat-field-metadata.util.ts+++ b/packages/twenty-server/src/engine/workspace-manager/twenty-standard-application/utils/field-metadata/compute-workflow-run-standard-flat-field-metadata.util.ts@@ -552,7 +552,7 @@ export const buildWorkflowRunStandardFlatFieldMetadatas = ({}),),icon: 'IconVersions',- isNullable: false,+ isNullable: true,isUIEditable: false,targetObjectName: 'workflowVersion',targetFieldName: 'runs',@@ -584,7 +584,7 @@ export const buildWorkflowRunStandardFlatFieldMetadatas = ({}),),icon: 'IconSettingsAutomation',- isNullable: false,+ isNullable: true,isUIEditable: false,targetObjectName: 'workflow',targetFieldName: 'runs',diff --git a/packages/twenty-server/src/modules/workflow/common/query-hooks/workflow-create-many.post-query.hook.ts b/packages/twenty-server/src/modules/workflow/common/query-hooks/workflow-create-many.post-query.hook.tsindex b4aaa3f7d34..9d36a2eb9db 100644--- a/packages/twenty-server/src/modules/workflow/common/query-hooks/workflow-create-many.post-query.hook.ts+++ b/packages/twenty-server/src/modules/workflow/common/query-hooks/workflow-create-many.post-query.hook.ts@@ -6,6 +6,7 @@ import { WorkspaceQueryHook } from 'src/engine/api/graphql/workspace-query-runneimport { WorkspaceQueryHookType } from 'src/engine/api/graphql/workspace-query-runner/workspace-query-hook/types/workspace-query-hook.type';import { type WorkspaceAuthContext } from 'src/engine/core-modules/auth/types/workspace-auth-context.type';import { RecordPositionService } from 'src/engine/core-modules/record-position/services/record-position.service';+import { WorkflowCoreSyncService } from 'src/engine/core-modules/workflow/services/workflow-core-sync.service';import { WorkflowVersionCoreSyncService } from 'src/engine/core-modules/workflow/services/workflow-version-core-sync.service';import { WorkspaceNotFoundDefaultError } from 'src/engine/core-modules/workspace/workspace.exception';import { WorkspaceOrmManager } from 'src/engine/twenty-orm/workspace-orm.manager';@@ -21,6 +22,7 @@ import { type WorkflowWorkspaceEntity } from 'src/modules/workflow/common/standa})export class WorkflowCreateManyPostQueryHook implements WorkspacePostQueryHookInstance {constructor(+ private readonly workflowCoreSyncService: WorkflowCoreSyncService,private readonly workspaceOrmManager: WorkspaceOrmManager,private readonly recordPositionService: RecordPositionService,private readonly workflowVersionCoreSyncService: WorkflowVersionCoreSyncService,@@ -35,6 +37,11 @@ export class WorkflowCreateManyPostQueryHook implements WorkspacePostQueryHookInassertIsDefinedOrThrow(workspace, WorkspaceNotFoundDefaultError);+ await this.workflowCoreSyncService.upsertToCore(+ workspace.id,+ payload.map((workflow) => workflow.id),+ );+const position = await this.workspaceOrmManager.executeInWorkspaceContext(() =>this.recordPositionService.buildRecordPosition({diff --git a/packages/twenty-server/src/modules/workflow/common/query-hooks/workflow-create-many.pre-query.hook.ts b/packages/twenty-server/src/modules/workflow/common/query-hooks/workflow-create-many.pre-query.hook.tsindex 423704a6ca7..fed9b04f388 100644--- a/packages/twenty-server/src/modules/workflow/common/query-hooks/workflow-create-many.pre-query.hook.ts+++ b/packages/twenty-server/src/modules/workflow/common/query-hooks/workflow-create-many.pre-query.hook.ts@@ -13,7 +13,12 @@ export class WorkflowCreateManyPreQueryHook implements WorkspacePreQueryHookInstpayload: CreateManyResolverArgs<WorkflowWorkspaceEntity>,): Promise<CreateManyResolverArgs<WorkflowWorkspaceEntity>> {const sanitizedData = payload.data.map((workflow) => {- const { statuses: _statuses, ...workflowWithoutStatuses } = workflow; // silent not to break creation from view with filter+ const {+ statuses: _statuses,+ coreWorkflowId: _coreWorkflowId,+ lastPublishedVersionId: _lastPublishedVersionId,+ ...workflowWithoutStatuses+ } = workflow; // silent not to break creation from view with filterreturn workflowWithoutStatuses as WorkflowWorkspaceEntity;});diff --git a/packages/twenty-server/src/modules/workflow/common/query-hooks/workflow-create-one.post-query.hook.ts b/packages/twenty-server/src/modules/workflow/common/query-hooks/workflow-create-one.post-query.hook.tsindex 360d4491ae2..cbaba628e97 100644--- a/packages/twenty-server/src/modules/workflow/common/query-hooks/workflow-create-one.post-query.hook.ts+++ b/packages/twenty-server/src/modules/workflow/common/query-hooks/workflow-create-one.post-query.hook.ts@@ -5,6 +5,7 @@ import { type WorkspacePostQueryHookInstance } from 'src/engine/api/graphql/workimport { WorkspaceQueryHook } from 'src/engine/api/graphql/workspace-query-runner/workspace-query-hook/decorators/workspace-query-hook.decorator';import { WorkspaceQueryHookType } from 'src/engine/api/graphql/workspace-query-runner/workspace-query-hook/types/workspace-query-hook.type';import { type WorkspaceAuthContext } from 'src/engine/core-modules/auth/types/workspace-auth-context.type';+import { WorkflowCoreSyncService } from 'src/engine/core-modules/workflow/services/workflow-core-sync.service';import { WorkflowVersionCoreSyncService } from 'src/engine/core-modules/workflow/services/workflow-version-core-sync.service';import { WorkspaceNotFoundDefaultError } from 'src/engine/core-modules/workspace/workspace.exception';import { type WorkflowWorkspaceEntity } from 'src/modules/workflow/common/standard-objects/workflow.workspace-entity';@@ -15,6 +16,7 @@ import { type WorkflowWorkspaceEntity } from 'src/modules/workflow/common/standa})export class WorkflowCreateOnePostQueryHook implements WorkspacePostQueryHookInstance {constructor(+ private readonly workflowCoreSyncService: WorkflowCoreSyncService,private readonly workflowVersionCoreSyncService: WorkflowVersionCoreSyncService,) {}@@ -27,6 +29,11 @@ export class WorkflowCreateOnePostQueryHook implements WorkspacePostQueryHookInsassertIsDefinedOrThrow(workspace, WorkspaceNotFoundDefaultError);+ await this.workflowCoreSyncService.upsertToCore(+ workspace.id,+ payload.map((workflow) => workflow.id),+ );+const workflow = payload[0];await this.workflowVersionCoreSyncService.createInitialDraftVersionForWorkflow(diff --git a/packages/twenty-server/src/modules/workflow/common/query-hooks/workflow-create-one.pre-query.hook.ts b/packages/twenty-server/src/modules/workflow/common/query-hooks/workflow-create-one.pre-query.hook.tsindex bc0a3df2f54..39270bdc171 100644--- a/packages/twenty-server/src/modules/workflow/common/query-hooks/workflow-create-one.pre-query.hook.ts+++ b/packages/twenty-server/src/modules/workflow/common/query-hooks/workflow-create-one.pre-query.hook.ts@@ -12,7 +12,12 @@ export class WorkflowCreateOnePreQueryHook implements WorkspacePreQueryHookInsta_objectName: string,payload: CreateOneResolverArgs<WorkflowWorkspaceEntity>,): Promise<CreateOneResolverArgs<WorkflowWorkspaceEntity>> {- const { statuses: _statuses, ...dataWithoutStatuses } = payload.data; // silent not to break creation from view with filter+ const {+ statuses: _statuses,+ coreWorkflowId: _coreWorkflowId,+ lastPublishedVersionId: _lastPublishedVersionId,+ ...dataWithoutStatuses+ } = payload.data; // silent not to break creation from view with filterreturn {...payload,diff --git a/packages/twenty-server/src/modules/workflow/common/query-hooks/workflow-destroy-many.post-query.hook.ts b/packages/twenty-server/src/modules/workflow/common/query-hooks/workflow-destroy-many.post-query.hook.tsindex f7e152d7205..21f65e1b721 100644--- a/packages/twenty-server/src/modules/workflow/common/query-hooks/workflow-destroy-many.post-query.hook.ts+++ b/packages/twenty-server/src/modules/workflow/common/query-hooks/workflow-destroy-many.post-query.hook.ts@@ -1,3 +1,4 @@+import { WorkflowCoreSyncService } from 'src/engine/core-modules/workflow/services/workflow-core-sync.service';import { assertIsDefinedOrThrow } from 'twenty-shared/utils';import { type WorkspacePostQueryHookInstance } from 'src/engine/api/graphql/workspace-query-runner/workspace-query-hook/interfaces/workspace-query-hook.interface';@@ -15,6 +16,7 @@ import { type WorkflowWorkspaceEntity } from 'src/modules/workflow/common/standa})export class WorkflowDestroyManyPostQueryHook implements WorkspacePostQueryHookInstance {constructor(+ private readonly workflowCoreSyncService: WorkflowCoreSyncService,private readonly workflowVersionCoreSyncService: WorkflowVersionCoreSyncService,) {}@@ -31,5 +33,9 @@ export class WorkflowDestroyManyPostQueryHook implements WorkspacePostQueryHookIworkspace.id,payload.map((workflow) => workflow.id),);+ await this.workflowCoreSyncService.reconcileWorkspaceWorkflows(+ authContext.workspace.id,+ payload.map((workflow) => workflow.id),+ );}}diff --git a/packages/twenty-server/src/modules/workflow/common/query-hooks/workflow-destroy-one.post-query.hook.ts b/packages/twenty-server/src/modules/workflow/common/query-hooks/workflow-destroy-one.post-query.hook.tsindex 81cf6c796a1..c0a76ab9dbc 100644--- a/packages/twenty-server/src/modules/workflow/common/query-hooks/workflow-destroy-one.post-query.hook.ts+++ b/packages/twenty-server/src/modules/workflow/common/query-hooks/workflow-destroy-one.post-query.hook.ts@@ -1,3 +1,4 @@+import { WorkflowCoreSyncService } from 'src/engine/core-modules/workflow/services/workflow-core-sync.service';import { assertIsDefinedOrThrow } from 'twenty-shared/utils';import { type WorkspacePostQueryHookInstance } from 'src/engine/api/graphql/workspace-query-runner/workspace-query-hook/interfaces/workspace-query-hook.interface';@@ -15,6 +16,7 @@ import { type WorkflowWorkspaceEntity } from 'src/modules/workflow/common/standa})export class WorkflowDestroyOnePostQueryHook implements WorkspacePostQueryHookInstance {constructor(+ private readonly workflowCoreSyncService: WorkflowCoreSyncService,private readonly workflowVersionCoreSyncService: WorkflowVersionCoreSyncService,) {}@@ -31,5 +33,9 @@ export class WorkflowDestroyOnePostQueryHook implements WorkspacePostQueryHookInworkspace.id,payload.map((workflow) => workflow.id),);+ await this.workflowCoreSyncService.reconcileWorkspaceWorkflows(+ authContext.workspace.id,+ payload.map((workflow) => workflow.id),+ );}}diff --git a/packages/twenty-server/src/modules/workflow/common/query-hooks/workflow-query-hook.module.ts b/packages/twenty-server/src/modules/workflow/common/query-hooks/workflow-query-hook.module.tsindex aed743d525f..b096528c085 100644--- a/packages/twenty-server/src/modules/workflow/common/query-hooks/workflow-query-hook.module.ts+++ b/packages/twenty-server/src/modules/workflow/common/query-hooks/workflow-query-hook.module.ts@@ -1,3 +1,4 @@+import { WorkflowCoreModule } from 'src/engine/core-modules/workflow/workflow-core.module';import { Module } from '@nestjs/common';import { CommandMenuItemModule } from 'src/engine/metadata-modules/command-menu-item/command-menu-item.module';@@ -47,6 +48,7 @@ import { WorkflowVersionQueryValidationWorkspaceService } from 'src/modules/work@Module({imports: [+ WorkflowCoreModule,LogicFunctionModule,RecordPositionModule,WorkspaceManyOrAllFlatEntityMapsCacheModule,diff --git a/packages/twenty-server/src/modules/workflow/common/query-hooks/workflow-update-many.post-query.hook.ts b/packages/twenty-server/src/modules/workflow/common/query-hooks/workflow-update-many.post-query.hook.tsindex d892dd3f403..5817cfe2640 100644--- a/packages/twenty-server/src/modules/workflow/common/query-hooks/workflow-update-many.post-query.hook.ts+++ b/packages/twenty-server/src/modules/workflow/common/query-hooks/workflow-update-many.post-query.hook.ts@@ -1,3 +1,4 @@+import { WorkflowCoreSyncService } from 'src/engine/core-modules/workflow/services/workflow-core-sync.service';import { isDefined } from 'twenty-shared/utils';import { type WorkspacePostQueryHookInstance } from 'src/engine/api/graphql/workspace-query-runner/workspace-query-hook/interfaces/workspace-query-hook.interface';@@ -14,6 +15,7 @@ import { type WorkflowWorkspaceEntity } from 'src/modules/workflow/common/standa})export class WorkflowUpdateManyPostQueryHook implements WorkspacePostQueryHookInstance {constructor(+ private readonly workflowCoreSyncService: WorkflowCoreSyncService,private readonly workflowCommonWorkspaceService: WorkflowCommonWorkspaceService,) {}@@ -30,5 +32,9 @@ export class WorkflowUpdateManyPostQueryHook implements WorkspacePostQueryHookInworkflowIds,authContext,);+ await this.workflowCoreSyncService.reconcileWorkspaceWorkflows(+ authContext.workspace.id,+ payload.map((workflow) => workflow.id),+ );}}diff --git a/packages/twenty-server/src/modules/workflow/common/query-hooks/workflow-update-one.post-query.hook.ts b/packages/twenty-server/src/modules/workflow/common/query-hooks/workflow-update-one.post-query.hook.tsindex 81c14cd9433..f8557f23082 100644--- a/packages/twenty-server/src/modules/workflow/common/query-hooks/workflow-update-one.post-query.hook.ts+++ b/packages/twenty-server/src/modules/workflow/common/query-hooks/workflow-update-one.post-query.hook.ts@@ -1,3 +1,4 @@+import { WorkflowCoreSyncService } from 'src/engine/core-modules/workflow/services/workflow-core-sync.service';import { isDefined } from 'twenty-shared/utils';import { type WorkspacePostQueryHookInstance } from 'src/engine/api/graphql/workspace-query-runner/workspace-query-hook/interfaces/workspace-query-hook.interface';@@ -14,6 +15,7 @@ import { type WorkflowWorkspaceEntity } from 'src/modules/workflow/common/standa})export class WorkflowUpdateOnePostQueryHook implements WorkspacePostQueryHookInstance {constructor(+ private readonly workflowCoreSyncService: WorkflowCoreSyncService,private readonly workflowCommonWorkspaceService: WorkflowCommonWorkspaceService,) {}@@ -30,5 +32,9 @@ export class WorkflowUpdateOnePostQueryHook implements WorkspacePostQueryHookInsworkflowIds,authContext,);+ await this.workflowCoreSyncService.reconcileWorkspaceWorkflows(+ authContext.workspace.id,+ payload.map((workflow) => workflow.id),+ );}}diff --git a/packages/twenty-server/src/modules/workflow/common/query-hooks/workflow-update-one.pre-query.hook.ts b/packages/twenty-server/src/modules/workflow/common/query-hooks/workflow-update-one.pre-query.hook.tsindex c3747a84769..7b8cea0d9a4 100644--- a/packages/twenty-server/src/modules/workflow/common/query-hooks/workflow-update-one.pre-query.hook.ts+++ b/packages/twenty-server/src/modules/workflow/common/query-hooks/workflow-update-one.pre-query.hook.ts@@ -4,6 +4,10 @@ import { type UpdateOneResolverArgs } from 'src/engine/api/graphql/workspace-resimport { WorkspaceQueryHook } from 'src/engine/api/graphql/workspace-query-runner/workspace-query-hook/decorators/workspace-query-hook.decorator';import { type WorkspaceAuthContext } from 'src/engine/core-modules/auth/types/workspace-auth-context.type';import { type WorkflowWorkspaceEntity } from 'src/modules/workflow/common/standard-objects/workflow.workspace-entity';+import {+ WorkflowQueryValidationException,+ WorkflowQueryValidationExceptionCode,+} from 'src/modules/workflow/common/exceptions/workflow-query-validation.exception';import { assertWorkflowStatusesNotSet } from 'src/modules/workflow/common/utils/assert-workflow-statuses-not-set';@WorkspaceQueryHook(`workflow.updateOne`)@@ -15,6 +19,16 @@ export class WorkflowUpdateOnePreQueryHook implements WorkspacePreQueryHookInsta): Promise<UpdateOneResolverArgs<WorkflowWorkspaceEntity>> {assertWorkflowStatusesNotSet(payload.data.statuses);+ if (+ 'coreWorkflowId' in payload.data ||+ 'lastPublishedVersionId' in payload.data+ ) {+ throw new WorkflowQueryValidationException(+ 'Workflow execution links can only be changed through dedicated workflow mutations',+ WorkflowQueryValidationExceptionCode.FORBIDDEN,+ );+ }+return payload;}}diff --git a/packages/twenty-server/src/modules/workflow/common/standard-objects/workflow-run.workspace-entity.ts b/packages/twenty-server/src/modules/workflow/common/standard-objects/workflow-run.workspace-entity.tsindex e4cc5521882..aed4b44d99d 100644--- a/packages/twenty-server/src/modules/workflow/common/standard-objects/workflow-run.workspace-entity.ts+++ b/packages/twenty-server/src/modules/workflow/common/standard-objects/workflow-run.workspace-entity.ts@@ -66,9 +66,9 @@ export class WorkflowRunWorkspaceEntity extends BaseWorkspaceEntity {position: number;searchVector: string;workflowVersion: EntityRelation<WorkflowVersionWorkspaceEntity>;- workflowVersionId: string;+ workflowVersionId: string | null;workflow: EntityRelation<WorkflowWorkspaceEntity>;- workflowId: string;+ workflowId: string | null;coreWorkflowId: string | null;coreWorkflowVersionId: string | null;timelineActivities: EntityRelation<TimelineActivityWorkspaceEntity[]>;diff --git a/packages/twenty-server/src/modules/workflow/common/workflow-common.module.ts b/packages/twenty-server/src/modules/workflow/common/workflow-common.module.tsindex ee4da182465..38ee7435802 100644--- a/packages/twenty-server/src/modules/workflow/common/workflow-common.module.ts+++ b/packages/twenty-server/src/modules/workflow/common/workflow-common.module.ts@@ -1,3 +1,4 @@+import { WorkflowCoreModule } from 'src/engine/core-modules/workflow/workflow-core.module';import { Module } from '@nestjs/common';import { CommandMenuItemModule } from 'src/engine/metadata-modules/command-menu-item/command-menu-item.module';@@ -10,6 +11,7 @@ import { WorkflowMetadataReadModule } from 'src/modules/workflow/common/workspac@Module({imports: [+ WorkflowCoreModule,WorkflowQueryHookModule,LogicFunctionModule,CommandMenuItemModule,diff --git a/packages/twenty-server/src/modules/workflow/common/workspace-services/workflow-common.workspace-service.ts b/packages/twenty-server/src/modules/workflow/common/workspace-services/workflow-common.workspace-service.tsindex 5bb2bef27d8..8fa6ec13d21 100644--- a/packages/twenty-server/src/modules/workflow/common/workspace-services/workflow-common.workspace-service.ts+++ b/packages/twenty-server/src/modules/workflow/common/workspace-services/workflow-common.workspace-service.ts@@ -1,3 +1,4 @@+import { WorkflowCoreSyncService } from 'src/engine/core-modules/workflow/services/workflow-core-sync.service';import { Injectable, Logger } from '@nestjs/common';import { isDefined, isValidUuid } from 'twenty-shared/utils';@@ -46,6 +47,7 @@ export class WorkflowCommonWorkspaceService {private readonly logger = new Logger(WorkflowCommonWorkspaceService.name);constructor(+ private readonly workflowCoreSyncService: WorkflowCoreSyncService,private readonly workspaceOrmManager: WorkspaceOrmManager,private readonly logicFunctionFromSourceService: LogicFunctionFromSourceService,private readonly workflowMetadataReadService: WorkflowMetadataReadService,@@ -255,6 +257,12 @@ export class WorkflowCommonWorkspaceService {{ shouldBypassPermissionChecks: true },);+ const workflowRepository =+ this.workspaceOrmManager.getRepository<WorkflowWorkspaceEntity>(+ 'workflow',+ { shouldBypassPermissionChecks: true },+ );+const workflowAutomatedTriggerRepository =this.workspaceOrmManager.getRepository<WorkflowAutomatedTriggerWorkspaceEntity>('workflowAutomatedTrigger',@@ -283,13 +291,9 @@ export class WorkflowCommonWorkspaceService {break;case 'restore':- await workflowAutomatedTriggerRepository.restore({+ await this.workflowCoreSyncService.upsertToCore(workspaceId, [workflowId,- });-- await workflowRunRepository.restore({- workflowId,- });+ ]);await workflowVersionRepository.restore({workflowId,@@ -300,6 +304,58 @@ export class WorkflowCommonWorkspaceService {workflowId,);+ const workflow = await workflowRepository.findOne({+ where: { id: workflowId },+ select: { coreWorkflowId: true },+ });+ const workflowVersions = await workflowVersionRepository.find({+ where: { workflowId },+ select: { id: true, coreWorkflowVersionId: true },+ });++ if (+ !isDefined(workflow?.coreWorkflowId) ||+ workflowVersions.some(+ (workflowVersion) =>+ !isDefined(workflowVersion.coreWorkflowVersionId),+ )+ ) {+ throw new Error(+ `Missing core mapping while restoring workflow ${workflowId}`,+ );+ }++ await this.workspaceOrmManager.runInWorkspaceTransaction(+ async ({ getRepository }) => {+ const transactionalWorkflowRunRepository =+ getRepository<WorkflowRunWorkspaceEntity>('workflowRun', {+ shouldBypassPermissionChecks: true,+ });++ await transactionalWorkflowRunRepository.restore({+ workflowId,+ });+ await transactionalWorkflowRunRepository.update(+ { workflowId },+ { coreWorkflowId: workflow.coreWorkflowId },+ );++ for (const workflowVersion of workflowVersions) {+ await transactionalWorkflowRunRepository.update(+ { workflowId, workflowVersionId: workflowVersion.id },+ {+ coreWorkflowVersionId:+ workflowVersion.coreWorkflowVersionId,+ },+ );+ }+ },+ );++ await workflowAutomatedTriggerRepository.restore({+ workflowId,+ });+break;}@@ -310,6 +366,13 @@ export class WorkflowCommonWorkspaceService {operation,});+ if (operation !== 'destroy') {+ await this.workflowCoreSyncService.reconcileWorkspaceWorkflows(+ workspaceId,+ [workflowId],+ );+ }+await this.handleLogicFunctionSubEntities({workflowVersionRepository,workflowId,diff --git a/packages/twenty-server/src/modules/workflow/workflow-core-consistency/services/workflow-core-consistency.service.ts b/packages/twenty-server/src/modules/workflow/workflow-core-consistency/services/workflow-core-consistency.service.tsindex 6a6c7aab5d6..fd2215fe4d0 100644--- a/packages/twenty-server/src/modules/workflow/workflow-core-consistency/services/workflow-core-consistency.service.ts+++ b/packages/twenty-server/src/modules/workflow/workflow-core-consistency/services/workflow-core-consistency.service.ts@@ -20,9 +20,6 @@ type DriftCounts = Record<string, number>;const CRON_INTERVAL_HOURS = 3;const SHARD_TOTAL = 24 / CRON_INTERVAL_HOURS;-// Detect drift between the workspace source-of-truth records and their core-// mirror. The dual-write is best-effort (async, not transactional), so core can-// silently fall out of sync; this quantifies that per workspace as metrics.@Injectable()export class WorkflowCoreConsistencyService {private readonly logger = new Logger(WorkflowCoreConsistencyService.name);@@ -102,10 +99,10 @@ export class WorkflowCoreConsistencyService {[workspaceId],);- const [{ orphanCore }] = await this.coreDataSource.query(- `SELECT count(*)::int AS "orphanCore"+ const [{ missingProjection }] = await this.coreDataSource.query(+ `SELECT count(*)::int AS "missingProjection"FROM core."workflow" c- WHERE c."workspaceId" = $1+ WHERE c."workspaceId" = $1 AND c."workspaceWorkflowId" IS NOT NULLAND NOT EXISTS (SELECT 1 FROM "${schema}"."workflow" wf WHERE wf."coreWorkflowId" = c.id)`,@@ -119,8 +116,8 @@ export class WorkflowCoreConsistencyService {{unlinked: counts.unlinked,missingCore: counts.missingCore,- fieldMismatch: counts.fieldMismatch,- orphanCore,+ projectionMismatch: counts.fieldMismatch,+ missingProjection,},);}@@ -148,10 +145,10 @@ export class WorkflowCoreConsistencyService {[workspaceId],);- const [{ orphanCore }] = await this.coreDataSource.query(- `SELECT count(*)::int AS "orphanCore"+ const [{ missingProjection }] = await this.coreDataSource.query(+ `SELECT count(*)::int AS "missingProjection"FROM core."workflowVersion" c- WHERE c."workspaceId" = $1+ WHERE c."workspaceId" = $1 AND c."workspaceWorkflowVersionId" IS NOT NULLAND NOT EXISTS (SELECT 1 FROM "${schema}"."workflowVersion" wf WHERE wf."coreWorkflowVersionId" = c.id)`,@@ -165,8 +162,8 @@ export class WorkflowCoreConsistencyService {{unlinked: counts.unlinked,missingCore: counts.missingCore,- fieldMismatch: counts.fieldMismatch,- orphanCore,+ projectionMismatch: counts.fieldMismatch,+ missingProjection,},);}@@ -179,7 +176,11 @@ export class WorkflowCoreConsistencyService {await this.workspaceCacheService.getOrRecompute(workspaceId, ['workflowAutomatedTriggerMaps',]);- const cacheByWorkflowId = workflowAutomatedTriggerMaps.byWorkflowId;+ const cacheByWorkflowId = Object.fromEntries(+ Object.values(workflowAutomatedTriggerMaps.byWorkflowId)+ .filter((trigger) => isDefined(trigger.legacyWorkflowId))+ .map((trigger) => [trigger.legacyWorkflowId, trigger]),+ );const tableRows: Array<{workflowId: string;diff --git a/packages/twenty-server/src/modules/workflow/workflow-core-sync/listeners/workflow-core-dual-write.listener.ts b/packages/twenty-server/src/modules/workflow/workflow-core-sync/listeners/workflow-core-dual-write.listener.tsindex 278677fd4b5..715014e8119 100644--- a/packages/twenty-server/src/modules/workflow/workflow-core-sync/listeners/workflow-core-dual-write.listener.ts+++ b/packages/twenty-server/src/modules/workflow/workflow-core-sync/listeners/workflow-core-dual-write.listener.ts@@ -31,7 +31,7 @@ export class WorkflowCoreDualWriteListener {): Promise<void> {await this.upsertToCore(batchEvent.workspaceId,- batchEvent.events.map((event) => event.properties.after),+ batchEvent.events.map((event) => event.properties.after.id),);}@@ -43,7 +43,7 @@ export class WorkflowCoreDualWriteListener {): Promise<void> {await this.upsertToCore(batchEvent.workspaceId,- batchEvent.events.map((event) => event.properties.after),+ batchEvent.events.map((event) => event.properties.after.id),);}@@ -55,7 +55,7 @@ export class WorkflowCoreDualWriteListener {): Promise<void> {await this.upsertToCore(batchEvent.workspaceId,- batchEvent.events.map((event) => event.properties.after),+ batchEvent.events.map((event) => event.properties.after.id),);}@@ -68,7 +68,7 @@ export class WorkflowCoreDualWriteListener {await this.deleteFromCore(batchEvent.workspaceId,batchEvent.events- .map((event) => event.properties.before.coreWorkflowId)+ .map((event) => event.properties.before.id).filter(isDefined),);}@@ -82,21 +82,24 @@ export class WorkflowCoreDualWriteListener {await this.deleteFromCore(batchEvent.workspaceId,batchEvent.events- .map((event) => event.properties.before.coreWorkflowId)+ .map((event) => event.properties.before.id).filter(isDefined),);}private async upsertToCore(workspaceId: string | undefined,- workflows: WorkflowWorkspaceEntity[],+ workflowIds: string[],): Promise<void> {if (!isDefined(workspaceId)) {return;}try {- await this.workflowCoreSyncService.upsertToCore(workspaceId, workflows);+ await this.workflowCoreSyncService.reconcileWorkspaceWorkflows(+ workspaceId,+ workflowIds,+ );} catch (error) {this.exceptionHandlerService.captureExceptions([error], {workspace: { id: workspaceId },@@ -106,16 +109,16 @@ export class WorkflowCoreDualWriteListener {private async deleteFromCore(workspaceId: string | undefined,- coreWorkflowIds: string[],+ workspaceWorkflowIds: string[],): Promise<void> {if (!isDefined(workspaceId)) {return;}try {- await this.workflowCoreSyncService.deleteFromCore(+ await this.workflowCoreSyncService.reconcileWorkspaceWorkflows(workspaceId,- coreWorkflowIds,+ workspaceWorkflowIds,);} catch (error) {this.exceptionHandlerService.captureExceptions([error], {diff --git a/packages/twenty-server/src/modules/workflow/workflow-executor/workflow-executor.module.ts b/packages/twenty-server/src/modules/workflow/workflow-executor/workflow-executor.module.tsindex a2625bbdda8..058ed8b8e88 100644--- a/packages/twenty-server/src/modules/workflow/workflow-executor/workflow-executor.module.ts+++ b/packages/twenty-server/src/modules/workflow/workflow-executor/workflow-executor.module.ts@@ -1,3 +1,4 @@+import { WorkflowCoreModule } from 'src/engine/core-modules/workflow/workflow-core.module';import { Module } from '@nestjs/common';import { BillingModule } from 'src/engine/core-modules/billing/billing.module';@@ -25,6 +26,7 @@ import { WorkflowRunModule } from 'src/modules/workflow/workflow-runner/workflow@Module({imports: [+ WorkflowCoreModule,WorkflowCommonModule,WorkflowRunModule,CodeActionModule,diff --git a/packages/twenty-server/src/modules/workflow/workflow-executor/workspace-services/workflow-executor.workspace-service.ts b/packages/twenty-server/src/modules/workflow/workflow-executor/workspace-services/workflow-executor.workspace-service.tsindex 814d181c149..0a057a3107b 100644--- a/packages/twenty-server/src/modules/workflow/workflow-executor/workspace-services/workflow-executor.workspace-service.ts+++ b/packages/twenty-server/src/modules/workflow/workflow-executor/workspace-services/workflow-executor.workspace-service.ts@@ -1,3 +1,4 @@+import { WorkflowCoreSyncService } from 'src/engine/core-modules/workflow/services/workflow-core-sync.service';import { Injectable } from '@nestjs/common';import { isDefined } from 'twenty-shared/utils';@@ -54,6 +55,7 @@ const MAX_EXECUTED_STEPS_COUNT = 20;@Injectable()export class WorkflowExecutorWorkspaceService {constructor(+ private readonly workflowCoreSyncService: WorkflowCoreSyncService,private readonly workflowActionFactory: WorkflowActionFactory,private readonly usageRecorderService: UsageRecorderService,private readonly workflowRunWorkspaceService: WorkflowRunWorkspaceService,@@ -120,6 +122,19 @@ export class WorkflowExecutorWorkspaceService {return;}+ const workflow = isDefined(workflowRun.coreWorkflowId)+ ? await this.workflowCoreSyncService.findCoreWorkflowById(+ workspaceId,+ workflowRun.coreWorkflowId,+ )+ : null;++ if (!isDefined(workflow)) {+ throw new Error(+ `Workflow run ${workflowRun.id} has no core workflow identity for billing`,+ );+ }+let actionOutput: WorkflowActionOutput;if (@@ -203,7 +218,9 @@ export class WorkflowExecutorWorkspaceService {!actionOutput.shouldFailSafely &&!actionOutput.shouldSkipStepExecution) {- await this.sendWorkflowNodeRunEvent(workspaceId, workflowRun.workflowId);+ const billingWorkflowId = workflow.workspaceWorkflowId ?? workflow.id;++ await this.sendWorkflowNodeRunEvent(workspaceId, billingWorkflowId);}const { shouldProcessNextSteps } = await this.processStepExecutionResult({diff --git a/packages/twenty-server/src/modules/workflow/workflow-runner/jobs/run-workflow.job.ts b/packages/twenty-server/src/modules/workflow/workflow-runner/jobs/run-workflow.job.tsindex fe8bfca84b4..6419b1e73bf 100644--- a/packages/twenty-server/src/modules/workflow/workflow-runner/jobs/run-workflow.job.ts+++ b/packages/twenty-server/src/modules/workflow/workflow-runner/jobs/run-workflow.job.ts@@ -11,7 +11,7 @@ import { MetricsKeys } from 'src/engine/core-modules/metrics/types/metrics-keys.import { WorkspaceOrmManager } from 'src/engine/twenty-orm/workspace-orm.manager';import { buildSystemAuthContext } from 'src/engine/twenty-orm/utils/build-system-auth-context.util';import { WorkflowRunStatus } from 'src/modules/workflow/common/standard-objects/workflow-run.workspace-entity';-import { WorkflowCommonWorkspaceService } from 'src/modules/workflow/common/workspace-services/workflow-common.workspace-service';+import { WorkflowVersionCoreSyncService } from 'src/engine/core-modules/workflow/services/workflow-version-core-sync.service';import { CodeStepBuildService } from 'src/modules/workflow/workflow-builder/workflow-version-step/code-step/services/code-step-build.service';import { stepIsAwaitingRetry } from 'src/modules/workflow/workflow-executor/utils/step-is-awaiting-retry.util';import { WorkflowExecutorWorkspaceService } from 'src/modules/workflow/workflow-executor/workspace-services/workflow-executor.workspace-service';@@ -29,7 +29,7 @@ export class RunWorkflowJob {private readonly logger = new Logger(RunWorkflowJob.name);constructor(- private readonly workflowCommonWorkspaceService: WorkflowCommonWorkspaceService,+ private readonly workflowVersionCoreSyncService: WorkflowVersionCoreSyncService,private readonly codeStepBuildService: CodeStepBuildService,private readonly workflowExecutorWorkspaceService: WorkflowExecutorWorkspaceService,private readonly workflowRunWorkspaceService: WorkflowRunWorkspaceService,@@ -103,13 +103,33 @@ export class RunWorkflowJob {return;}+ if (!isDefined(workflowRun.coreWorkflowVersionId)) {+ throw new WorkflowRunException(+ 'Workflow run has no core workflow version',+ WorkflowRunExceptionCode.WORKFLOW_RUN_INVALID,+ );+ }+const workflowVersion =- await this.workflowCommonWorkspaceService.getWorkflowVersionOrFail({+ await this.workflowVersionCoreSyncService.findCoreVersionById(workspaceId,- workflowVersionId: workflowRun.workflowVersionId,- });+ workflowRun.coreWorkflowVersionId,+ );++ if (+ !isDefined(workflowVersion) ||+ workflowVersion.coreWorkflowId !== workflowRun.coreWorkflowId+ ) {+ throw new WorkflowRunException(+ 'Core workflow version not found',+ WorkflowRunExceptionCode.WORKFLOW_RUN_INVALID,+ );+ }++ const trigger = workflowRun.state?.flow?.trigger;+ const steps = workflowRun.state?.flow?.steps;- if (!workflowVersion.trigger || !workflowVersion.steps) {+ if (!trigger || !steps) {throw new WorkflowRunException('Workflow version has no trigger or steps',WorkflowRunExceptionCode.WORKFLOW_RUN_INVALID,@@ -118,7 +138,7 @@ export class RunWorkflowJob {await this.codeStepBuildService.buildCodeStepsFromSourceForSteps({workspaceId,- steps: workflowVersion.steps,+ steps,});await this.workflowRunWorkspaceService.startWorkflowRun({@@ -128,10 +148,10 @@ export class RunWorkflowJob {await this.incrementTriggerMetrics({workflowRunId,- triggerType: workflowVersion.trigger.type,+ triggerType: trigger.type,});- const stepIds = workflowVersion.trigger.nextStepIds ?? [];+ const stepIds = trigger.nextStepIds ?? [];await this.workflowExecutorWorkspaceService.executeFromSteps({stepIds,diff --git a/packages/twenty-server/src/modules/workflow/workflow-runner/services/core-workflow-runner.service.ts b/packages/twenty-server/src/modules/workflow/workflow-runner/services/core-workflow-runner.service.tsnew file mode 100644index 00000000000..9d4024fe139--- /dev/null+++ b/packages/twenty-server/src/modules/workflow/workflow-runner/services/core-workflow-runner.service.ts@@ -0,0 +1,166 @@+import { Injectable, Logger } from '@nestjs/common';++import { type ActorMetadata } from 'twenty-shared/types';+import { isDefined } from 'twenty-shared/utils';++import { BillingUsageService } from 'src/engine/core-modules/billing/services/billing-usage.service';+import { InjectMessageQueue } from 'src/engine/core-modules/message-queue/decorators/message-queue.decorator';+import { MessageQueue } from 'src/engine/core-modules/message-queue/message-queue.constants';+import { MessageQueueService } from 'src/engine/core-modules/message-queue/services/message-queue.service';+import { MetricsService } from 'src/engine/core-modules/metrics/metrics.service';+import { MetricsKeys } from 'src/engine/core-modules/metrics/types/metrics-keys.type';+import { WorkflowCoreSyncService } from 'src/engine/core-modules/workflow/services/workflow-core-sync.service';+import { WorkflowVersionCoreSyncService } from 'src/engine/core-modules/workflow/services/workflow-version-core-sync.service';+import { WorkflowRunStatus } from 'src/modules/workflow/common/standard-objects/workflow-run.workspace-entity';+import {+ WorkflowRunException,+ WorkflowRunExceptionCode,+} from 'src/modules/workflow/workflow-runner/exceptions/workflow-run.exception';+import { RunWorkflowJob } from 'src/modules/workflow/workflow-runner/jobs/run-workflow.job';+import { type RunWorkflowJobData } from 'src/modules/workflow/workflow-runner/types/run-workflow-job-data.type';+import { buildRunWorkflowJobOptions } from 'src/modules/workflow/workflow-runner/utils/build-run-workflow-job-options.util';+import {+ WorkflowRunEnqueueJob,+ type WorkflowRunEnqueueJobData,+} from 'src/modules/workflow/workflow-runner/workflow-run-queue/jobs/workflow-run-enqueue.job';+import { WorkflowThrottlingWorkspaceService } from 'src/modules/workflow/workflow-runner/workflow-run-queue/workspace-services/workflow-throttling.workspace-service';+import { WorkflowRunWorkspaceService } from 'src/modules/workflow/workflow-runner/workflow-run/workflow-run.workspace-service';+import { WorkflowTriggerType } from 'src/modules/workflow/workflow-trigger/types/workflow-trigger.type';++@Injectable()+export class CoreWorkflowRunnerService {+ private readonly logger = new Logger(CoreWorkflowRunnerService.name);++ constructor(+ private readonly workflowCoreSyncService: WorkflowCoreSyncService,+ private readonly workflowVersionCoreSyncService: WorkflowVersionCoreSyncService,+ private readonly workflowRunWorkspaceService: WorkflowRunWorkspaceService,+ private readonly billingUsageService: BillingUsageService,+ private readonly workflowThrottlingWorkspaceService: WorkflowThrottlingWorkspaceService,+ private readonly metricsService: MetricsService,+ @InjectMessageQueue(MessageQueue.workflowQueue)+ private readonly messageQueueService: MessageQueueService,+ ) {}++ async run({+ workspaceId,+ coreWorkflowVersionId,+ payload,+ source,+ workflowRunId,+ }: {+ workspaceId: string;+ coreWorkflowVersionId: string;+ payload: object;+ source: ActorMetadata;+ workflowRunId?: string;+ }) {+ const workflowVersion =+ await this.workflowVersionCoreSyncService.findCoreVersionById(+ workspaceId,+ coreWorkflowVersionId,+ );++ if (+ !isDefined(workflowVersion) ||+ !isDefined(workflowVersion.coreWorkflowId) ||+ !isDefined(workflowVersion.triggers?.[0]) ||+ !isDefined(workflowVersion.steps)+ ) {+ throw new WorkflowRunException(+ 'Core workflow version is missing its execution definition',+ WorkflowRunExceptionCode.WORKFLOW_RUN_INVALID,+ );+ }++ const workflow = await this.workflowCoreSyncService.findCoreWorkflowById(+ workspaceId,+ workflowVersion.coreWorkflowId,+ );++ if (+ !isDefined(workflow) ||+ workflowVersion.workflowId !== workflow.workspaceWorkflowId ||+ isDefined(workflow.workspaceWorkflowId) !==+ isDefined(workflowVersion.workspaceWorkflowVersionId)+ ) {+ throw new WorkflowRunException(+ 'Core workflow not found',+ WorkflowRunExceptionCode.WORKFLOW_RUN_INVALID,+ );+ }++ const subscriptionInactiveReason =+ await this.billingUsageService.getSubscriptionInactiveReason(workspaceId);++ if (isDefined(subscriptionInactiveReason)) {+ this.logger.log(+ `Cannot execute billed function for this workspace: ${subscriptionInactiveReason}`,+ );+ }++ const isHardThrottled = await this.checkHardThrottleLimit(workspaceId);+ const isManualTrigger =+ workflowVersion.triggers[0].type === WorkflowTriggerType.MANUAL;+ const status = isHardThrottled+ ? WorkflowRunStatus.FAILED+ : isManualTrigger+ ? WorkflowRunStatus.ENQUEUED+ : WorkflowRunStatus.NOT_STARTED;+ const createdWorkflowRunId =+ await this.workflowRunWorkspaceService.createCoreWorkflowRun({+ coreWorkflowId: workflow.id,+ coreWorkflowVersionId: workflowVersion.id,+ workspaceWorkflowId: workflow.workspaceWorkflowId,+ workspaceWorkflowVersionId: workflowVersion.workspaceWorkflowVersionId,+ workflowName: workflow.name,+ trigger: workflowVersion.triggers[0],+ steps: workflowVersion.steps,+ createdBy: source,+ workflowRunId,+ status,+ triggerPayload: payload,+ error: isHardThrottled ? 'Throttle limit reached' : undefined,+ workspaceId,+ });++ if (isHardThrottled) {+ return { workflowRunId: createdWorkflowRunId };+ }++ if (isManualTrigger) {+ await this.messageQueueService.add<RunWorkflowJobData>(+ RunWorkflowJob.name,+ { workspaceId, workflowRunId: createdWorkflowRunId },+ buildRunWorkflowJobOptions(createdWorkflowRunId),+ );+ } else {+ await this.workflowThrottlingWorkspaceService.increaseWorkflowRunNotStartedCount(+ workspaceId,+ );+ await this.messageQueueService.add<WorkflowRunEnqueueJobData>(+ WorkflowRunEnqueueJob.name,+ { workspaceId, isCacheMode: true },+ );+ }++ return { workflowRunId: createdWorkflowRunId };+ }++ private async checkHardThrottleLimit(workspaceId: string): Promise<boolean> {+ try {+ await this.workflowThrottlingWorkspaceService.throttleOrThrowIfHardLimitReached(+ workspaceId,+ );++ return false;+ } catch {+ void this.metricsService.incrementCounterForEvent({+ key: MetricsKeys.WorkflowRunThrottled,+ eventId: workspaceId,+ });++ return true;+ }+ }+}diff --git a/packages/twenty-server/src/modules/workflow/workflow-runner/workflow-run-queue/jobs/workflow-clean-workflow-runs.job.ts b/packages/twenty-server/src/modules/workflow/workflow-runner/workflow-run-queue/jobs/workflow-clean-workflow-runs.job.tsindex 2a939ebe913..d07b3695fb1 100644--- a/packages/twenty-server/src/modules/workflow/workflow-runner/workflow-run-queue/jobs/workflow-clean-workflow-runs.job.ts+++ b/packages/twenty-server/src/modules/workflow/workflow-runner/workflow-run-queue/jobs/workflow-clean-workflow-runs.job.ts@@ -116,7 +116,7 @@ export class WorkflowCleanWorkflowRunsJob {WITH ranked_runs AS (SELECT id,ROW_NUMBER() OVER (- PARTITION BY "workflowId"+ PARTITION BY COALESCE("coreWorkflowId", "workflowId")ORDER BY "createdAt" DESC) AS rnFROM ${schemaName}."workflowRun"diff --git a/packages/twenty-server/src/modules/workflow/workflow-runner/workflow-run/workflow-run.workspace-service.ts b/packages/twenty-server/src/modules/workflow/workflow-runner/workflow-run/workflow-run.workspace-service.tsindex bf46b058436..ddbc598c808 100644--- a/packages/twenty-server/src/modules/workflow/workflow-runner/workflow-run/workflow-run.workspace-service.ts+++ b/packages/twenty-server/src/modules/workflow/workflow-runner/workflow-run/workflow-run.workspace-service.ts@@ -17,9 +17,8 @@ import {type WorkflowRunWorkspaceEntity,} from 'src/modules/workflow/common/standard-objects/workflow-run.workspace-entity';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';-import { WorkflowCommonWorkspaceService } from 'src/modules/workflow/common/workspace-services/workflow-common.workspace-service';import { type WorkflowAction } from 'src/modules/workflow/workflow-executor/workflow-actions/types/workflow-action.type';+import { type WorkflowTrigger } from 'src/modules/workflow/workflow-trigger/types/workflow-trigger.type';import {WorkflowRunException,WorkflowRunExceptionCode,@@ -29,13 +28,18 @@ import {export class WorkflowRunWorkspaceService {constructor(private readonly workspaceOrmManager: WorkspaceOrmManager,- private readonly workflowCommonWorkspaceService: WorkflowCommonWorkspaceService,private readonly recordPositionService: RecordPositionService,private readonly metricsService: MetricsService,) {}- async createWorkflowRun({- workflowVersionId,+ async createCoreWorkflowRun({+ coreWorkflowId,+ coreWorkflowVersionId,+ workspaceWorkflowId,+ workspaceWorkflowVersionId,+ workflowName,+ trigger,+ steps,createdBy,workflowRunId,status,@@ -43,7 +47,13 @@ export class WorkflowRunWorkspaceService {error,workspaceId,}: {- workflowVersionId: string;+ coreWorkflowId: string;+ coreWorkflowVersionId: string;+ workspaceWorkflowId: string | null;+ workspaceWorkflowVersionId: string | null;+ workflowName: string | null;+ trigger: WorkflowTrigger;+ steps: WorkflowAction[];createdBy: ActorMetadata;status:| WorkflowRunStatus.NOT_STARTED@@ -62,79 +72,36 @@ export class WorkflowRunWorkspaceService {'workflowRun',{ shouldBypassPermissionChecks: true },);-- const workflowVersion =- await this.workflowCommonWorkspaceService.getWorkflowVersionOrFail({- workspaceId,- workflowVersionId,- });-- const workflowRepository =- this.workspaceOrmManager.getRepository<WorkflowWorkspaceEntity>(- 'workflow',- {- shouldBypassPermissionChecks: true,- },- );-- const workflow = await workflowRepository.findOne({- where: {- id: workflowVersion.workflowId,- },- });-- if (!workflow) {- throw new WorkflowRunException(- 'Workflow id is invalid',- WorkflowRunExceptionCode.WORKFLOW_RUN_INVALID,- );- }-const position = await this.recordPositionService.buildRecordPosition({value: 'first',- objectMetadata: {- isCustom: false,- nameSingular: 'workflowRun',- },+ objectMetadata: { isCustom: false, nameSingular: 'workflowRun' },workspaceId,});-- const initState = this.getInitState(- workflowVersion,- triggerPayload,- error,- );-const lastWorkflowRun = await workflowRunRepository.findOne({- where: {- workflowId: workflow.id,- },+ where: { coreWorkflowId },order: { createdAt: 'DESC' },});-const workflowRunCountMatch = lastWorkflowRun?.name?.match(/#(\d+)/);-const workflowRunCount = workflowRunCountMatch? parseInt(workflowRunCountMatch[1], 10): 0;-- const workflowRun = {- id: workflowRunId ?? v4(),- name: `#${workflowRunCount + 1} - ${workflow.name}`,- workflowVersionId,+ const id = workflowRunId ?? v4();++ await workflowRunRepository.insert({+ id,+ name: `#${workflowRunCount + 1} - ${workflowName ?? 'Workflow'}`,+ workflowVersionId: workspaceWorkflowVersionId,+ workflowId: workspaceWorkflowId,+ coreWorkflowId,+ coreWorkflowVersionId,createdBy,- workflowId: workflow.id,- coreWorkflowId: workflow.coreWorkflowId,- coreWorkflowVersionId: workflowVersion.coreWorkflowVersionId,status,position,- state: initState,+ state: this.getInitState({ trigger, steps }, triggerPayload, error),enqueuedAt: status === WorkflowRunStatus.ENQUEUED ? new Date() : null,- };-- await workflowRunRepository.insert(workflowRun);+ });- return workflowRun.id;+ return id;}, authContext);}@@ -433,7 +400,7 @@ export class WorkflowRunWorkspaceService {}private getInitState(- workflowVersion: WorkflowVersionWorkspaceEntity,+ workflowVersion: Pick<WorkflowVersionWorkspaceEntity, 'trigger' | 'steps'>,triggerPayload: object,error?: string,): WorkflowRunState | undefined {diff --git a/packages/twenty-server/src/modules/workflow/workflow-runner/workflow-runner.module.ts b/packages/twenty-server/src/modules/workflow/workflow-runner/workflow-runner.module.tsindex 96ecf92875d..1a80e5b9aa9 100644--- a/packages/twenty-server/src/modules/workflow/workflow-runner/workflow-runner.module.ts+++ b/packages/twenty-server/src/modules/workflow/workflow-runner/workflow-runner.module.ts@@ -10,6 +10,9 @@ import { RunWorkflowJob } from 'src/modules/workflow/workflow-runner/jobs/run-woimport { WorkflowRunQueueModule } from 'src/modules/workflow/workflow-runner/workflow-run-queue/workflow-run-queue.module';import { WorkflowRunModule } from 'src/modules/workflow/workflow-runner/workflow-run/workflow-run.module';import { WorkflowRunnerWorkspaceService } from 'src/modules/workflow/workflow-runner/workspace-services/workflow-runner.workspace-service';+import { CoreWorkflowRunnerService } from 'src/modules/workflow/workflow-runner/services/core-workflow-runner.service';+import { WorkflowCoreModule } from 'src/engine/core-modules/workflow/workflow-core.module';+import { WorkflowVersionCoreModule } from 'src/engine/core-modules/workflow/workflow-version-core.module';@Module({imports: [@@ -21,8 +24,14 @@ import { WorkflowRunnerWorkspaceService } from 'src/modules/workflow/workflow-ruWorkflowRunQueueModule,WorkflowVersionStepModule,CodeStepBuildModule,+ WorkflowCoreModule,+ WorkflowVersionCoreModule,],- providers: [WorkflowRunnerWorkspaceService, RunWorkflowJob],- exports: [WorkflowRunnerWorkspaceService],+ providers: [+ WorkflowRunnerWorkspaceService,+ CoreWorkflowRunnerService,+ RunWorkflowJob,+ ],+ exports: [WorkflowRunnerWorkspaceService, CoreWorkflowRunnerService],})export class WorkflowRunnerModule {}diff --git a/packages/twenty-server/src/modules/workflow/workflow-runner/workspace-services/workflow-runner.workspace-service.ts b/packages/twenty-server/src/modules/workflow/workflow-runner/workspace-services/workflow-runner.workspace-service.tsindex 0971d238bcf..30db8e33e27 100644--- a/packages/twenty-server/src/modules/workflow/workflow-runner/workspace-services/workflow-runner.workspace-service.ts+++ b/packages/twenty-server/src/modules/workflow/workflow-runner/workspace-services/workflow-runner.workspace-service.ts@@ -1,16 +1,13 @@-import { Injectable, Logger } from '@nestjs/common';+import { Injectable } from '@nestjs/common';import { msg } from '@lingui/core/macro';import { type ActorMetadata } from 'twenty-shared/types';import { isDefined } from 'twenty-shared/utils';import { StepStatus } from 'twenty-shared/workflow';-import { BillingUsageService } from 'src/engine/core-modules/billing/services/billing-usage.service';import { InjectMessageQueue } from 'src/engine/core-modules/message-queue/decorators/message-queue.decorator';import { MessageQueue } from 'src/engine/core-modules/message-queue/message-queue.constants';import { MessageQueueService } from 'src/engine/core-modules/message-queue/services/message-queue.service';-import { MetricsService } from 'src/engine/core-modules/metrics/metrics.service';-import { MetricsKeys } from 'src/engine/core-modules/metrics/types/metrics-keys.type';import {WorkflowVersionStepException,WorkflowVersionStepExceptionCode,@@ -18,7 +15,6 @@ import {import { WorkflowRunStatus } from 'src/modules/workflow/common/standard-objects/workflow-run.workspace-entity';import { setAllIteratorsStepInfosAsStopped } from 'src/modules/workflow/common/utils/set-all-iterators-step-infos-as-stopped.util';import { workflowHasRunningSteps } from 'src/modules/workflow/common/utils/workflow-has-running-steps.util';-import { WorkflowCommonWorkspaceService } from 'src/modules/workflow/common/workspace-services/workflow-common.workspace-service';import { WorkflowVersionStepOperationsWorkspaceService } from 'src/modules/workflow/workflow-builder/workflow-version-step/workflow-version-step-operations.workspace-service';import { isWorkflowFormAction } from 'src/modules/workflow/workflow-executor/workflow-actions/form/guards/is-workflow-form-action.guard';import {@@ -30,26 +26,21 @@ import { type RunWorkflowJobData } from 'src/modules/workflow/workflow-runner/tyimport { buildRetryStepInfos } from 'src/modules/workflow/workflow-runner/utils/build-retry-step-infos.util';import { buildRunWorkflowJobOptions } from 'src/modules/workflow/workflow-runner/utils/build-run-workflow-job-options.util';import { getRunnableStepIds } from 'src/modules/workflow/workflow-runner/utils/get-runnable-step-ids.util';-import {- WorkflowRunEnqueueJob,- type WorkflowRunEnqueueJobData,-} from 'src/modules/workflow/workflow-runner/workflow-run-queue/jobs/workflow-run-enqueue.job';import { WorkflowThrottlingWorkspaceService } from 'src/modules/workflow/workflow-runner/workflow-run-queue/workspace-services/workflow-throttling.workspace-service';import { WorkflowRunWorkspaceService } from 'src/modules/workflow/workflow-runner/workflow-run/workflow-run.workspace-service';-import { WorkflowTriggerType } from 'src/modules/workflow/workflow-trigger/types/workflow-trigger.type';+import { CoreWorkflowRunnerService } from 'src/modules/workflow/workflow-runner/services/core-workflow-runner.service';+import { WorkflowVersionCoreSyncService } from 'src/engine/core-modules/workflow/services/workflow-version-core-sync.service';@Injectable()export class WorkflowRunnerWorkspaceService {- private readonly logger = new Logger(WorkflowRunnerWorkspaceService.name);constructor(private readonly workflowRunWorkspaceService: WorkflowRunWorkspaceService,- private readonly workflowCommonWorkspaceService: WorkflowCommonWorkspaceService,@InjectMessageQueue(MessageQueue.workflowQueue)private readonly messageQueueService: MessageQueueService,- private readonly billingUsageService: BillingUsageService,private readonly workflowVersionStepOperationsWorkspaceService: WorkflowVersionStepOperationsWorkspaceService,private readonly workflowThrottlingWorkspaceService: WorkflowThrottlingWorkspaceService,- private readonly metricsService: MetricsService,+ private readonly coreWorkflowRunnerService: CoreWorkflowRunnerService,+ private readonly workflowVersionCoreSyncService: WorkflowVersionCoreSyncService,) {}async run({@@ -65,53 +56,25 @@ export class WorkflowRunnerWorkspaceService {source: ActorMetadata;workflowRunId?: string;}) {- const subscriptionInactiveReason =- await this.billingUsageService.getSubscriptionInactiveReason(workspaceId);-- if (isDefined(subscriptionInactiveReason)) {- this.logger.log(- `Cannot execute billed function for this workspace: ${subscriptionInactiveReason}`,- );- }-- const workflowVersion =- await this.workflowCommonWorkspaceService.getWorkflowVersionOrFail({- workspaceId,- workflowVersionId,- });-- const isManualTrigger =- workflowVersion.trigger?.type === WorkflowTriggerType.MANUAL;-- const isHardThrottled = await this.checkHardThrottleLimit(workspaceId);-- if (isHardThrottled) {- this.logger.log(`Workflow throttled for workspace ${workspaceId}`);- return this.createFailedWorkflowRun({+ const coreWorkflowVersion =+ await this.workflowVersionCoreSyncService.findCoreVersionByWorkspaceVersionId(workspaceId,workflowVersionId,- initialWorkflowRunId,- source,- payload,- });- }+ );- if (isManualTrigger) {- return this.enqueueWorkflowRun({- workspaceId,- workflowVersionId,- initialWorkflowRunId,- source,- payload,- });+ if (!isDefined(coreWorkflowVersion)) {+ throw new WorkflowRunException(+ 'Workspace workflow version has no core execution mapping',+ WorkflowRunExceptionCode.WORKFLOW_RUN_INVALID,+ );}- return this.createNotStartedWorkflowRunAndTriggerEnqueueJob({+ return this.coreWorkflowRunnerService.run({workspaceId,- workflowVersionId,- initialWorkflowRunId,- source,+ coreWorkflowVersionId: coreWorkflowVersion.id,+ workflowRunId: initialWorkflowRunId,payload,+ source,});}@@ -375,121 +338,4 @@ export class WorkflowRunnerWorkspaceService {status: WorkflowRunStatus.RUNNING,};}-- private async checkHardThrottleLimit(workspaceId: string): Promise<boolean> {- try {- await this.workflowThrottlingWorkspaceService.throttleOrThrowIfHardLimitReached(- workspaceId,- );-- return false;- } catch {- void this.metricsService.incrementCounterForEvent({- key: MetricsKeys.WorkflowRunThrottled,- eventId: workspaceId,- });-- return true;- }- }-- private async createFailedWorkflowRun({- workspaceId,- workflowVersionId,- initialWorkflowRunId,- source,- payload,- }: {- workspaceId: string;- workflowVersionId: string;- initialWorkflowRunId?: string;- source: ActorMetadata;- payload: object;- }) {- const workflowRunId =- await this.workflowRunWorkspaceService.createWorkflowRun({- workflowVersionId,- workflowRunId: initialWorkflowRunId,- createdBy: source,- status: WorkflowRunStatus.FAILED,- triggerPayload: payload,- error: 'Throttle limit reached',- workspaceId,- });-- return { workflowRunId };- }-- private async enqueueWorkflowRun({- workspaceId,- workflowVersionId,- initialWorkflowRunId,- source,- payload,- }: {- workspaceId: string;- workflowVersionId: string;- initialWorkflowRunId?: string;- source: ActorMetadata;- payload: object;- }) {- const workflowRunId =- await this.workflowRunWorkspaceService.createWorkflowRun({- workflowVersionId,- workflowRunId: initialWorkflowRunId,- createdBy: source,- status: WorkflowRunStatus.ENQUEUED,- triggerPayload: payload,- workspaceId,- });-- await this.messageQueueService.add<RunWorkflowJobData>(- RunWorkflowJob.name,- {- workspaceId,- workflowRunId,- },- buildRunWorkflowJobOptions(workflowRunId),- );-- return { workflowRunId };- }-- private async createNotStartedWorkflowRunAndTriggerEnqueueJob({- workspaceId,- workflowVersionId,- initialWorkflowRunId,- source,- payload,- }: {- workspaceId: string;- workflowVersionId: string;- initialWorkflowRunId?: string;- source: ActorMetadata;- payload: object;- }) {- const workflowRunId =- await this.workflowRunWorkspaceService.createWorkflowRun({- workflowVersionId,- workflowRunId: initialWorkflowRunId,- createdBy: source,- status: WorkflowRunStatus.NOT_STARTED,- triggerPayload: payload,- workspaceId,- });-- await this.workflowThrottlingWorkspaceService.increaseWorkflowRunNotStartedCount(- workspaceId,- );-- await this.messageQueueService.add<WorkflowRunEnqueueJobData>(- WorkflowRunEnqueueJob.name,- {- workspaceId,- isCacheMode: true,- },- );-- return { workflowRunId };- }}diff --git a/packages/twenty-server/src/modules/workflow/workflow-trigger/automated-trigger/automated-trigger.module.ts b/packages/twenty-server/src/modules/workflow/workflow-trigger/automated-trigger/automated-trigger.module.tsindex b8af5066292..b5bf3520802 100644--- a/packages/twenty-server/src/modules/workflow/workflow-trigger/automated-trigger/automated-trigger.module.ts+++ b/packages/twenty-server/src/modules/workflow/workflow-trigger/automated-trigger/automated-trigger.module.ts@@ -1,4 +1,7 @@+import { WorkflowVersionCoreModule } from 'src/engine/core-modules/workflow/workflow-version-core.module';import { Module } from '@nestjs/common';++import { WorkflowCoreModule } from 'src/engine/core-modules/workflow/workflow-core.module';import { TypeOrmModule } from '@nestjs/typeorm';import { CacheStorageModule } from 'src/engine/core-modules/cache-storage/cache-storage.module';@@ -16,6 +19,8 @@ import { WorkflowDatabaseEventTriggerListener } from 'src/modules/workflow/workf@Module({imports: [+ WorkflowVersionCoreModule,+ WorkflowCoreModule,TypeOrmModule.forFeature([WorkspaceEntity]),CacheStorageModule,CronModule,diff --git a/packages/twenty-server/src/modules/workflow/workflow-trigger/automated-trigger/crons/jobs/__tests__/workflow-cron-trigger-cron.job.spec.ts b/packages/twenty-server/src/modules/workflow/workflow-trigger/automated-trigger/crons/jobs/__tests__/workflow-cron-trigger-cron.job.spec.tsindex f47a63150f4..4241fcb5b59 100644--- a/packages/twenty-server/src/modules/workflow/workflow-trigger/automated-trigger/crons/jobs/__tests__/workflow-cron-trigger-cron.job.spec.ts+++ b/packages/twenty-server/src/modules/workflow/workflow-trigger/automated-trigger/crons/jobs/__tests__/workflow-cron-trigger-cron.job.spec.ts@@ -6,6 +6,8 @@ import { CronTriggerDeduplicationService } from 'src/engine/core-modules/cron/seimport { ExceptionHandlerService } from 'src/engine/core-modules/exception-handler/exception-handler.service';import { WorkspaceEntity } from 'src/engine/core-modules/workspace/workspace.entity';import { WorkspaceCacheService } from 'src/engine/workspace-cache/services/workspace-cache.service';+import { WorkflowCoreSyncService } from 'src/engine/core-modules/workflow/services/workflow-core-sync.service';+import { WorkflowVersionCoreSyncService } from 'src/engine/core-modules/workflow/services/workflow-version-core-sync.service';import { WORKFLOW_CRON_TRIGGER_CACHE_KEY } from 'src/modules/workflow/workflow-trigger/automated-trigger/crons/constants/workflow-cron-trigger-cache-key.constant';import { WORKFLOW_CRON_TRIGGER_CACHE_TTL_MS } from 'src/modules/workflow/workflow-trigger/automated-trigger/crons/constants/workflow-cron-trigger-cache-ttl.constant';import { WorkflowCronTriggerCronJob } from 'src/modules/workflow/workflow-trigger/automated-trigger/crons/jobs/workflow-cron-trigger-cron.job';@@ -41,6 +43,14 @@ const mockWorkspaceCacheService = {getOrRecompute: jest.fn(),};+const mockWorkflowCoreSyncService = {+ findCoreWorkflowByIdOrWorkspaceWorkflowId: jest.fn(),+};++const mockWorkflowVersionCoreSyncService = {+ findCoreVersionById: jest.fn(),+};+describe('WorkflowCronTriggerCronJob', () => {let job: WorkflowCronTriggerCronJob;@@ -49,6 +59,33 @@ describe('WorkflowCronTriggerCronJob', () => {jest.useFakeTimers();jest.setSystemTime(new Date('2026-04-02T15:00:30.000Z'));mockCronTriggerDeduplicationService.shouldDispatch.mockResolvedValue(true);+ mockWorkflowCoreSyncService.findCoreWorkflowByIdOrWorkspaceWorkflowId.mockImplementation(+ async (_workspaceId: string, workflowId: string) => ({+ id: workflowId,+ workspaceWorkflowId: workflowId,+ lastPublishedCoreWorkflowVersionId: workflowId.replace(+ 'workflow-',+ 'core-version-',+ ),+ }),+ );+ mockWorkflowVersionCoreSyncService.findCoreVersionById.mockImplementation(+ async (_workspaceId: string, versionId: string) => ({+ id: versionId,+ coreWorkflowId: versionId.replace('core-version-', 'workflow-'),+ workspaceWorkflowVersionId: versionId.replace(+ 'core-version-',+ 'workspace-version-',+ ),+ status: 'ACTIVE',+ triggers: [+ {+ type: 'CRON',+ settings: { type: 'CUSTOM', pattern: '* * * * *' },+ },+ ],+ }),+ );const module: TestingModule = await Test.createTestingModule({providers: [@@ -77,6 +114,14 @@ describe('WorkflowCronTriggerCronJob', () => {provide: WorkspaceCacheService,useValue: mockWorkspaceCacheService,},+ {+ provide: WorkflowCoreSyncService,+ useValue: mockWorkflowCoreSyncService,+ },+ {+ provide: WorkflowVersionCoreSyncService,+ useValue: mockWorkflowVersionCoreSyncService,+ },],}).compile();@@ -121,8 +166,8 @@ describe('WorkflowCronTriggerCronJob', () => {{workspaceId: WORKSPACE_1,workflowId: 'workflow-1',- coreWorkflowVersionId: undefined,- workspaceWorkflowVersionId: undefined,+ coreWorkflowVersionId: 'core-version-1',+ workspaceWorkflowVersionId: 'workspace-version-1',payload: {},},{ retryLimit: 3 },@@ -172,7 +217,7 @@ describe('WorkflowCronTriggerCronJob', () => {expect(mockMessageQueueService.add).not.toHaveBeenCalled();});- it('should skip triggers with undefined pattern', async () => {+ it('should restore missing cached patterns from the core definition', async () => {mockCacheStorageService.hashGetValues.mockResolvedValue([JSON.stringify({workspaceId: WORKSPACE_1,@@ -182,7 +227,13 @@ describe('WorkflowCronTriggerCronJob', () => {await job.handle();- expect(mockMessageQueueService.add).not.toHaveBeenCalled();+ expect(+ mockCronTriggerDeduplicationService.shouldDispatch,+ ).toHaveBeenCalledWith(+ `workflow-cron:${WORKSPACE_1}:workflow-1`,+ '* * * * *',+ expect.any(Date),+ );});it('should not rebuild cache on cache hit', async () => {@@ -276,6 +327,7 @@ describe('WorkflowCronTriggerCronJob', () => {value: JSON.stringify({workspaceId: WORKSPACE_1,workflowId: 'workflow-1',+ legacyWorkflowId: 'workflow-1',coreWorkflowVersionId: 'core-version-1',workspaceWorkflowVersionId: 'workspace-version-1',pattern: '* * * * *',@@ -291,6 +343,7 @@ describe('WorkflowCronTriggerCronJob', () => {value: JSON.stringify({workspaceId: WORKSPACE_3,workflowId: 'workflow-2',+ legacyWorkflowId: 'workflow-2',coreWorkflowVersionId: 'core-version-2',workspaceWorkflowVersionId: 'workspace-version-2',pattern: '* * * * *',@@ -335,8 +388,8 @@ describe('WorkflowCronTriggerCronJob', () => {{workspaceId: WORKSPACE_2,workflowId: 'workflow-1',- coreWorkflowVersionId: undefined,- workspaceWorkflowVersionId: undefined,+ coreWorkflowVersionId: 'core-version-1',+ workspaceWorkflowVersionId: 'workspace-version-1',payload: {},},{ retryLimit: 3 },diff --git a/packages/twenty-server/src/modules/workflow/workflow-trigger/automated-trigger/crons/jobs/workflow-cron-trigger-cron.job.ts b/packages/twenty-server/src/modules/workflow/workflow-trigger/automated-trigger/crons/jobs/workflow-cron-trigger-cron.job.tsindex 1785abe5beb..2a64cedbb37 100644--- a/packages/twenty-server/src/modules/workflow/workflow-trigger/automated-trigger/crons/jobs/workflow-cron-trigger-cron.job.ts+++ b/packages/twenty-server/src/modules/workflow/workflow-trigger/automated-trigger/crons/jobs/workflow-cron-trigger-cron.job.ts@@ -1,3 +1,7 @@+import { WorkflowVersionCoreSyncService } from 'src/engine/core-modules/workflow/services/workflow-version-core-sync.service';+import { WorkflowVersionStatus } from 'src/engine/core-modules/workflow/entities/workflow-version.entity';+import { WorkflowTriggerType } from 'src/modules/workflow/workflow-trigger/types/workflow-trigger.type';+import { computeCronPatternFromSchedule } from 'src/modules/workflow/workflow-trigger/utils/compute-cron-pattern-from-schedule';import { Logger } from '@nestjs/common';import { InjectRepository } from '@nestjs/typeorm';@@ -18,6 +22,7 @@ import { MessageQueue } from 'src/engine/core-modules/message-queue/message-queuimport { MessageQueueService } from 'src/engine/core-modules/message-queue/services/message-queue.service';import { WorkspaceEntity } from 'src/engine/core-modules/workspace/workspace.entity';import { isCachedCronTrigger } from 'src/engine/core-modules/workflow/utils/cached-workflow-automated-trigger.util';+import { WorkflowCoreSyncService } from 'src/engine/core-modules/workflow/services/workflow-core-sync.service';import { WorkspaceCacheService } from 'src/engine/workspace-cache/services/workspace-cache.service';import { buildCoreDispatchIds } from 'src/engine/core-modules/workflow/utils/build-core-dispatch-ids.util';import { type QueuedWorkflowTriggerDispatchIds } from 'src/modules/workflow/workflow-trigger/utils/resolve-workflow-trigger-dispatch-mode.util';@@ -44,6 +49,8 @@ export class WorkflowCronTriggerCronJob {@InjectCacheStorage(CacheStorageNamespace.ModuleWorkflow)private readonly cacheStorageService: CacheStorageService,private readonly cronTriggerDeduplicationService: CronTriggerDeduplicationService,+ private readonly workflowVersionCoreSyncService: WorkflowVersionCoreSyncService,+ private readonly workflowCoreSyncService: WorkflowCoreSyncService,private readonly workspaceCacheService: WorkspaceCacheService,) {}@@ -77,18 +84,15 @@ export class WorkflowCronTriggerCronJob {private async getAndRunTriggersFromCache(cachedValues: string[], now: Date) {for (const serialized of cachedValues) {try {- const trigger = JSON.parse(serialized) as CachedCronTrigger;+ const trigger = await this.normalizeCachedTrigger(+ JSON.parse(serialized) as CachedCronTrigger,+ );- if (!isDefined(trigger.pattern)) {+ if (!isDefined(trigger)) {continue;}- const shouldDispatch =- await this.cronTriggerDeduplicationService.shouldDispatch(- `workflow-cron:${trigger.workspaceId}:${trigger.workflowId}`,- trigger.pattern,- now,- );+ const shouldDispatch = await this.shouldDispatch({ trigger, now });if (!shouldDispatch) {continue;@@ -102,9 +106,8 @@ export class WorkflowCronTriggerCronJob {WorkflowTriggerJob.name,{workspaceId: trigger.workspaceId,- workflowId: trigger.workflowId,- coreWorkflowVersionId: trigger.coreWorkflowVersionId,- workspaceWorkflowVersionId: trigger.workspaceWorkflowVersionId,+ workflowId: trigger.legacyWorkflowId ?? trigger.workflowId,+ ...buildCoreDispatchIds(trigger),payload: {},},{ retryLimit: 3 },@@ -176,21 +179,24 @@ export class WorkflowCronTriggerCronJob {continue;}- const cachedTrigger: CachedCronTrigger = {+ const cachedTrigger = await this.normalizeCachedTrigger({workspaceId,workflowId,+ legacyWorkflowId: cronTrigger.legacyWorkflowId,...buildCoreDispatchIds(cronTrigger),pattern,- };+ });++ if (!isDefined(cachedTrigger)) {+ continue;+ }triggersToCache.push(cachedTrigger);- const shouldDispatch =- await this.cronTriggerDeduplicationService.shouldDispatch(- `workflow-cron:${workspaceId}:${workflowId}`,- pattern,- now,- );+ const shouldDispatch = await this.shouldDispatch({+ trigger: cachedTrigger,+ now,+ });if (shouldDispatch) {this.logger.log(@@ -201,10 +207,9 @@ export class WorkflowCronTriggerCronJob {WorkflowTriggerJob.name,{workspaceId,- workflowId,- coreWorkflowVersionId: cronTrigger.coreWorkflowVersionId,- workspaceWorkflowVersionId:- cronTrigger.workspaceWorkflowVersionId,+ workflowId:+ cachedTrigger.legacyWorkflowId ?? cachedTrigger.workflowId,+ ...buildCoreDispatchIds(cachedTrigger),payload: {},},{ retryLimit: 3 },@@ -227,6 +232,7 @@ export class WorkflowCronTriggerCronJob {Array<{workflowId: string;+ legacyWorkflowId?: string;pattern?: string;} & QueuedWorkflowTriggerDispatchIds>@@ -240,9 +246,64 @@ export class WorkflowCronTriggerCronJob {.filter(isCachedCronTrigger).map((trigger) => ({workflowId: trigger.workflowId,- coreWorkflowVersionId: trigger.coreWorkflowVersionId,- workspaceWorkflowVersionId: trigger.workspaceWorkflowVersionId,+ legacyWorkflowId: trigger.legacyWorkflowId,+ ...buildCoreDispatchIds(trigger),pattern: trigger.settings.pattern,}));}++ private async normalizeCachedTrigger(+ trigger: CachedCronTrigger,+ ): Promise<CachedCronTrigger | null> {+ const workflow =+ await this.workflowCoreSyncService.findCoreWorkflowByIdOrWorkspaceWorkflowId(+ trigger.workspaceId,+ trigger.workflowId,+ );++ if (!isDefined(workflow?.lastPublishedCoreWorkflowVersionId)) {+ return null;+ }++ const version =+ await this.workflowVersionCoreSyncService.findCoreVersionById(+ trigger.workspaceId,+ workflow.lastPublishedCoreWorkflowVersionId,+ );+ const definition = version?.triggers?.[0];++ if (+ !isDefined(version) ||+ version.coreWorkflowId !== workflow.id ||+ version.status !== WorkflowVersionStatus.ACTIVE ||+ definition?.type !== WorkflowTriggerType.CRON+ ) {+ return null;+ }++ return {+ workspaceId: trigger.workspaceId,+ workflowId: workflow.id,+ legacyWorkflowId: workflow.workspaceWorkflowId ?? undefined,+ ...buildCoreDispatchIds({+ coreWorkflowVersionId: version.id,+ workspaceWorkflowVersionId: version.workspaceWorkflowVersionId,+ }),+ pattern: computeCronPatternFromSchedule(definition),+ };+ }++ private async shouldDispatch({+ trigger,+ now,+ }: {+ trigger: CachedCronTrigger;+ now: Date;+ }): Promise<boolean> {+ return this.cronTriggerDeduplicationService.shouldDispatch(+ `workflow-cron:${trigger.workspaceId}:${trigger.legacyWorkflowId ?? trigger.workflowId}`,+ trigger.pattern,+ now,+ );+ }}diff --git a/packages/twenty-server/src/modules/workflow/workflow-trigger/automated-trigger/crons/types/cached-cron-trigger.type.ts b/packages/twenty-server/src/modules/workflow/workflow-trigger/automated-trigger/crons/types/cached-cron-trigger.type.tsindex 9c495ab2718..107e81f3bda 100644--- a/packages/twenty-server/src/modules/workflow/workflow-trigger/automated-trigger/crons/types/cached-cron-trigger.type.ts+++ b/packages/twenty-server/src/modules/workflow/workflow-trigger/automated-trigger/crons/types/cached-cron-trigger.type.ts@@ -3,5 +3,6 @@ import { type CoreDispatchIds } from 'src/engine/core-modules/workflow/types/worexport type CachedCronTrigger = {workspaceId: string;workflowId: string;+ legacyWorkflowId?: string;pattern: string;} & CoreDispatchIds;diff --git a/packages/twenty-server/src/modules/workflow/workflow-trigger/automated-trigger/listeners/workflow-database-event-trigger.listener.ts b/packages/twenty-server/src/modules/workflow/workflow-trigger/automated-trigger/listeners/workflow-database-event-trigger.listener.tsindex b0ff511d3d4..2f6e87f6b6c 100644--- a/packages/twenty-server/src/modules/workflow/workflow-trigger/automated-trigger/listeners/workflow-database-event-trigger.listener.ts+++ b/packages/twenty-server/src/modules/workflow/workflow-trigger/automated-trigger/listeners/workflow-database-event-trigger.listener.ts@@ -1,3 +1,4 @@+import { buildCoreDispatchIds } from 'src/engine/core-modules/workflow/utils/build-core-dispatch-ids.util';import { Injectable, Logger } from '@nestjs/common';import { TWENTY_STANDARD_APPLICATION_UNIVERSAL_IDENTIFIER } from 'twenty-shared/application';@@ -51,6 +52,7 @@ import {type DatabaseEventTriggerListener = {workflowId: string;+ legacyWorkflowId?: string;settings: AutomatedTriggerSettings;} & CoreDispatchIds;@@ -381,10 +383,9 @@ export class WorkflowDatabaseEventTriggerListener {WorkflowTriggerJob.name,{workspaceId,- workflowId: eventListener.workflowId,- coreWorkflowVersionId: eventListener.coreWorkflowVersionId,- workspaceWorkflowVersionId:- eventListener.workspaceWorkflowVersionId,+ workflowId:+ eventListener.legacyWorkflowId ?? eventListener.workflowId,+ ...buildCoreDispatchIds(eventListener),payload: omitInheritedReadabilityChildRecords(eventPayload),},{ retryLimit: 3 },diff --git a/packages/twenty-server/src/modules/workflow/workflow-trigger/jobs/workflow-trigger.job.ts b/packages/twenty-server/src/modules/workflow/workflow-trigger/jobs/workflow-trigger.job.tsindex dfde2ba3393..af53a446641 100644--- a/packages/twenty-server/src/modules/workflow/workflow-trigger/jobs/workflow-trigger.job.ts+++ b/packages/twenty-server/src/modules/workflow/workflow-trigger/jobs/workflow-trigger.job.ts@@ -7,14 +7,9 @@ import { Process } from 'src/engine/core-modules/message-queue/decorators/procesimport { Processor } from 'src/engine/core-modules/message-queue/decorators/processor.decorator';import { MessageQueue } from 'src/engine/core-modules/message-queue/message-queue.constants';import { WorkflowVersionStatus as CoreWorkflowVersionStatus } from 'src/engine/core-modules/workflow/entities/workflow-version.entity';+import { WorkflowCoreSyncService } from 'src/engine/core-modules/workflow/services/workflow-core-sync.service';import { WorkflowVersionCoreSyncService } from 'src/engine/core-modules/workflow/services/workflow-version-core-sync.service';-import { WorkspaceOrmManager } from 'src/engine/twenty-orm/workspace-orm.manager';-import { buildSystemAuthContext } from 'src/engine/twenty-orm/utils/build-system-auth-context.util';-import { WorkflowVersionStatus } from 'src/modules/workflow/common/standard-objects/workflow-version.workspace-entity';-import { type WorkflowWorkspaceEntity } from 'src/modules/workflow/common/standard-objects/workflow.workspace-entity';-import { WorkflowCommonWorkspaceService } from 'src/modules/workflow/common/workspace-services/workflow-common.workspace-service';-import { WorkflowRunnerWorkspaceService } from 'src/modules/workflow/workflow-runner/workspace-services/workflow-runner.workspace-service';-import { WorkflowTriggerExceptionCode } from 'src/modules/workflow/workflow-trigger/exceptions/workflow-trigger.exception';+import { CoreWorkflowRunnerService } from 'src/modules/workflow/workflow-runner/services/core-workflow-runner.service';import { buildWorkflowRunSource } from 'src/modules/workflow/workflow-trigger/utils/build-workflow-run-source.util';import {type QueuedWorkflowTriggerDispatchIds,@@ -31,9 +26,8 @@ export type WorkflowTriggerJobData = {export class WorkflowTriggerJob {private readonly logger = new Logger(WorkflowTriggerJob.name);constructor(- private readonly workspaceOrmManager: WorkspaceOrmManager,- private readonly workflowCommonWorkspaceService: WorkflowCommonWorkspaceService,- private readonly workflowRunnerWorkspaceService: WorkflowRunnerWorkspaceService,+ private readonly coreWorkflowRunnerService: CoreWorkflowRunnerService,+ private readonly workflowCoreSyncService: WorkflowCoreSyncService,private readonly workflowVersionCoreSyncService: WorkflowVersionCoreSyncService,private readonly exceptionHandlerService: ExceptionHandlerService,) {}@@ -42,21 +36,9 @@ export class WorkflowTriggerJob {async handle(data: WorkflowTriggerJobData): Promise<void> {const dispatchMode = resolveWorkflowTriggerDispatchMode(data);- if (dispatchMode.mode === 'INCOMPLETE') {- this.logger.error(- `Dispatch ids are half resolved for workflow ${data.workflowId} in workspace ${data.workspaceId}`,- );- this.exceptionHandlerService.captureExceptions([- new Error(- `Dropped workflow trigger with half resolved dispatch ids for workflow ${data.workflowId} in workspace ${data.workspaceId}`,- ),- ]);-- return;- }-if (dispatchMode.mode === 'CORE') {return this.handleFromCore({+ workflowId: data.workflowId,workspaceId: data.workspaceId,coreWorkflowVersionId: dispatchMode.coreWorkflowVersionId,workspaceWorkflowVersionId: dispatchMode.workspaceWorkflowVersionId,@@ -64,18 +46,20 @@ export class WorkflowTriggerJob {});}- return this.handleFromWorkspace(data);+ return this.handleLegacyDispatch(data);}private async handleFromCore({+ workflowId,workspaceId,coreWorkflowVersionId,workspaceWorkflowVersionId,payload,}: {+ workflowId: string;workspaceId: string;coreWorkflowVersionId: string;- workspaceWorkflowVersionId: string;+ workspaceWorkflowVersionId?: string;payload: object;}): Promise<void> {const coreWorkflowVersion =@@ -85,127 +69,89 @@ export class WorkflowTriggerJob {);if (!isDefined(coreWorkflowVersion)) {- this.logger.error(+ this.captureDroppedDispatch(`Core workflow version ${coreWorkflowVersionId} not found in workspace ${workspaceId}`,);- this.exceptionHandlerService.captureExceptions([- new Error(- `Dispatched core workflow version ${coreWorkflowVersionId} not found in workspace ${workspaceId}`,- ),- ]);+ return;+ }++ const coreWorkflow =+ await this.workflowCoreSyncService.findCoreWorkflowByIdOrWorkspaceWorkflowId(+ workspaceId,+ workflowId,+ );+ if (+ !isDefined(coreWorkflow) ||+ coreWorkflowVersion.coreWorkflowId !== coreWorkflow.id+ ) {+ this.captureDroppedDispatch(+ `Core workflow version ${coreWorkflowVersionId} does not belong to workflow ${workflowId} in workspace ${workspaceId}`,+ );return;}if (coreWorkflowVersion.status !== CoreWorkflowVersionStatus.ACTIVE) {- this.logger.error(+ this.captureDroppedDispatch(`Core workflow version ${coreWorkflowVersionId} is not active in workspace ${workspaceId}`,);- this.exceptionHandlerService.captureExceptions([- new Error(- `Dropped event enqueued against core version ${coreWorkflowVersionId}, no longer active in workspace ${workspaceId}`,- ),- ]);-return;}- const workspaceWorkflowVersion =- await this.workflowCommonWorkspaceService.getWorkflowVersionOrFail({- workspaceId,- workflowVersionId: workspaceWorkflowVersionId,- });-if (- workspaceWorkflowVersion.coreWorkflowVersionId !== coreWorkflowVersionId+ isDefined(workspaceWorkflowVersionId) &&+ coreWorkflowVersion.workspaceWorkflowVersionId !==+ workspaceWorkflowVersionId) {- this.logger.error(- `Workspace version ${workspaceWorkflowVersionId} is linked to core version ${workspaceWorkflowVersion.coreWorkflowVersionId} instead of dispatched ${coreWorkflowVersionId} in workspace ${workspaceId}`,+ this.captureDroppedDispatch(+ `Workspace version ${workspaceWorkflowVersionId} conflicts with core version ${coreWorkflowVersionId} in workspace ${workspaceId}`,);- this.exceptionHandlerService.captureExceptions([- new Error(- `Dispatched core version ${coreWorkflowVersionId} no longer matches the twin link of workspace version ${workspaceWorkflowVersionId} in workspace ${workspaceId}`,- ),- ]);-return;}- const authContext = buildSystemAuthContext(workspaceId);- const workspaceWorkflow =- await this.workspaceOrmManager.executeInWorkspaceContext(- async () =>- this.workspaceOrmManager- .getRepository<WorkflowWorkspaceEntity>('workflow', {- shouldBypassPermissionChecks: true,- })- .findOneBy({ id: coreWorkflowVersion.workflowId }),- authContext,- );-- await this.workflowRunnerWorkspaceService.run({+ await this.coreWorkflowRunnerService.run({workspaceId,- workflowVersionId: workspaceWorkflowVersionId,+ coreWorkflowVersionId,payload,- source: buildWorkflowRunSource(workspaceWorkflow?.name),+ source: buildWorkflowRunSource(coreWorkflow.name),});}- private async handleFromWorkspace(+ private async handleLegacyDispatch(data: WorkflowTriggerJobData,): Promise<void> {- const authContext = buildSystemAuthContext(data.workspaceId);-- await this.workspaceOrmManager.executeInWorkspaceContext(async () => {- const workflowRepository =- this.workspaceOrmManager.getRepository<WorkflowWorkspaceEntity>(- 'workflow',- { shouldBypassPermissionChecks: true },- );-- const workflow = await workflowRepository.findOneBy({- id: data.workflowId,- });-- if (!workflow) {- this.logger.error(- `Workflow ${data.workflowId} not found in workspace ${data.workspaceId}`,- WorkflowTriggerExceptionCode.NOT_FOUND,- );-- return;- }-- if (!workflow.lastPublishedVersionId) {- this.logger.error(- `Workflow ${data.workflowId} has no published version in workspace ${data.workspaceId}`,- WorkflowTriggerExceptionCode.INTERNAL_ERROR,- );-- return;- }-- const workflowVersion =- await this.workflowCommonWorkspaceService.getWorkflowVersionOrFail({- workspaceId: data.workspaceId,- workflowVersionId: workflow.lastPublishedVersionId,- });-- if (workflowVersion.status !== WorkflowVersionStatus.ACTIVE) {- this.logger.error(- `Workflow version ${workflowVersion?.id} is not active in workspace ${data.workspaceId}`,- WorkflowTriggerExceptionCode.INTERNAL_ERROR,- );+ const coreWorkflow =+ await this.workflowCoreSyncService.findCoreWorkflowByIdOrWorkspaceWorkflowId(+ data.workspaceId,+ data.workflowId,+ );+ const coreWorkflowVersionId = isDefined(data.workspaceWorkflowVersionId)+ ? (+ await this.workflowVersionCoreSyncService.findCoreVersionByWorkspaceVersionId(+ data.workspaceId,+ data.workspaceWorkflowVersionId,+ )+ )?.id+ : coreWorkflow?.lastPublishedCoreWorkflowVersionId;++ if (!isDefined(coreWorkflowVersionId)) {+ this.captureDroppedDispatch(+ `Legacy workflow trigger for ${data.workflowId} has no core version mapping in workspace ${data.workspaceId}`,+ );+ return;+ }- return;- }+ await this.handleFromCore({+ workflowId: data.workflowId,+ workspaceId: data.workspaceId,+ coreWorkflowVersionId,+ workspaceWorkflowVersionId: data.workspaceWorkflowVersionId ?? undefined,+ payload: data.payload,+ });+ }- await this.workflowRunnerWorkspaceService.run({- workspaceId: data.workspaceId,- workflowVersionId: workflow.lastPublishedVersionId,- payload: data.payload,- source: buildWorkflowRunSource(workflow.name),- });- }, authContext);+ private captureDroppedDispatch(message: string): void {+ this.logger.error(message);+ this.exceptionHandlerService.captureExceptions([new Error(message)]);}}diff --git a/packages/twenty-server/src/modules/workflow/workflow-trigger/utils/__tests__/resolve-workflow-trigger-dispatch-mode.util.spec.ts b/packages/twenty-server/src/modules/workflow/workflow-trigger/utils/__tests__/resolve-workflow-trigger-dispatch-mode.util.spec.tsindex 02b245605e7..8abef2f0e3e 100644--- a/packages/twenty-server/src/modules/workflow/workflow-trigger/utils/__tests__/resolve-workflow-trigger-dispatch-mode.util.spec.ts+++ b/packages/twenty-server/src/modules/workflow/workflow-trigger/utils/__tests__/resolve-workflow-trigger-dispatch-mode.util.spec.ts@@ -24,16 +24,19 @@ describe('resolveWorkflowTriggerDispatchMode', () => {).toEqual({ mode: 'LEGACY' });});- it('should report a half resolved pair instead of downgrading it', () => {+ it('should accept both core-only and legacy workspace-only envelopes', () => {expect(resolveWorkflowTriggerDispatchMode({coreWorkflowVersionId: 'core-version-1',}),- ).toEqual({ mode: 'INCOMPLETE' });+ ).toEqual({+ mode: 'CORE',+ coreWorkflowVersionId: 'core-version-1',+ });expect(resolveWorkflowTriggerDispatchMode({workspaceWorkflowVersionId: 'workspace-version-1',}),- ).toEqual({ mode: 'INCOMPLETE' });+ ).toEqual({ mode: 'LEGACY' });});});diff --git a/packages/twenty-server/src/modules/workflow/workflow-trigger/utils/resolve-workflow-trigger-dispatch-mode.util.ts b/packages/twenty-server/src/modules/workflow/workflow-trigger/utils/resolve-workflow-trigger-dispatch-mode.util.tsindex c0f4ff4c963..4192e0da4a3 100644--- a/packages/twenty-server/src/modules/workflow/workflow-trigger/utils/resolve-workflow-trigger-dispatch-mode.util.ts+++ b/packages/twenty-server/src/modules/workflow/workflow-trigger/utils/resolve-workflow-trigger-dispatch-mode.util.ts@@ -8,27 +8,22 @@ export type WorkflowTriggerDispatchMode =| {mode: 'CORE';coreWorkflowVersionId: string;- workspaceWorkflowVersionId: string;+ workspaceWorkflowVersionId?: string;}- | { mode: 'LEGACY' }- | { mode: 'INCOMPLETE' };+ | { mode: 'LEGACY' };export const resolveWorkflowTriggerDispatchMode = ({coreWorkflowVersionId,workspaceWorkflowVersionId,}: QueuedWorkflowTriggerDispatchIds): WorkflowTriggerDispatchMode => {- if (- isDefined(coreWorkflowVersionId) &&- isDefined(workspaceWorkflowVersionId)- ) {- return { mode: 'CORE', coreWorkflowVersionId, workspaceWorkflowVersionId };- }-- if (- isDefined(coreWorkflowVersionId) ||- isDefined(workspaceWorkflowVersionId)- ) {- return { mode: 'INCOMPLETE' };+ if (isDefined(coreWorkflowVersionId)) {+ return {+ mode: 'CORE',+ coreWorkflowVersionId,+ ...(isDefined(workspaceWorkflowVersionId)+ ? { workspaceWorkflowVersionId }+ : {}),+ };}return { mode: 'LEGACY' };diff --git a/packages/twenty-server/src/modules/workflow/workflow-trigger/workflow-trigger.module.ts b/packages/twenty-server/src/modules/workflow/workflow-trigger/workflow-trigger.module.tsindex 4de5f6fa66f..d476bd6a47b 100644--- a/packages/twenty-server/src/modules/workflow/workflow-trigger/workflow-trigger.module.ts+++ b/packages/twenty-server/src/modules/workflow/workflow-trigger/workflow-trigger.module.ts@@ -1,5 +1,7 @@import { Module } from '@nestjs/common';+import { WorkflowCoreModule } from 'src/engine/core-modules/workflow/workflow-core.module';+import { WorkflowVersionValidationModule } from 'src/modules/workflow/workflow-builder/workflow-validation/workflow-version-validation.module';import { CacheStorageModule } from 'src/engine/core-modules/cache-storage/cache-storage.module';@@ -17,6 +19,7 @@ import { WorkflowTriggerWorkspaceService } from 'src/modules/workflow/workflow-t@Module({imports: [+ WorkflowCoreModule,WorkflowCommonModule,CodeStepBuildModule,WorkflowRunnerModule,diff --git a/packages/twenty-server/src/modules/workflow/workflow-trigger/workspace-services/workflow-trigger.workspace-service.ts b/packages/twenty-server/src/modules/workflow/workflow-trigger/workspace-services/workflow-trigger.workspace-service.tsindex 23e2744f6ef..7d3c21a832a 100644--- a/packages/twenty-server/src/modules/workflow/workflow-trigger/workspace-services/workflow-trigger.workspace-service.ts+++ b/packages/twenty-server/src/modules/workflow/workflow-trigger/workspace-services/workflow-trigger.workspace-service.ts@@ -18,6 +18,7 @@ import { type WorkspaceTransactionScope } from 'src/engine/twenty-orm/types/workimport { WorkspaceOrmManager } from 'src/engine/twenty-orm/workspace-orm.manager';import { type WorkspaceRepository } from 'src/engine/twenty-orm/repository/workspace-repository';import { buildSystemAuthContext } from 'src/engine/twenty-orm/utils/build-system-auth-context.util';+import { getWorkspaceSchemaName } from 'src/engine/workspace-datasource/utils/get-workspace-schema-name.util';import { WorkspaceEventEmitter } from 'src/engine/workspace-event-emitter/workspace-event-emitter';import { AutomatedTriggerType } from 'src/modules/workflow/common/standard-objects/workflow-automated-trigger.workspace-entity';import {@@ -85,11 +86,6 @@ export class WorkflowTriggerWorkspaceService {workflowRunId?: string;workspaceId: string;}) {- await this.workflowCommonWorkspaceService.getWorkflowVersionOrFail({- workflowVersionId,- workspaceId,- });-return this.workflowRunnerWorkspaceService.run({workspaceId,workflowRunId,@@ -163,12 +159,7 @@ export class WorkflowTriggerWorkspaceService {steps: workflowVersion.steps ?? [],});- await this.performActivationSteps(- workflow,- workflowVersion,- workflowVersionRepository,- workspaceId,- );+ await this.performActivationSteps(workflow, workflowVersion, workspaceId);return true;}, authContext);@@ -278,26 +269,44 @@ export class WorkflowTriggerWorkspaceService {private async performActivationSteps(workflow: WorkflowWorkspaceEntity,workflowVersion: WorkflowVersionWorkspaceEntity,- workflowVersionRepository: WorkspaceRepository<WorkflowVersionWorkspaceEntity>,workspaceId: string,) {- const previousPublishedVersionId = workflow.lastPublishedVersionId;-- if (- previousPublishedVersionId &&- workflowVersion.id !== previousPublishedVersionId- ) {- await this.performDeactivationSteps(- previousPublishedVersionId,- workflowVersionRepository,- workspaceId,- );- }+ let previousVersion: WorkflowVersionWorkspaceEntity | null = null;let mirroredCoreWorkflowVersionIdForCommandMenuItem: string | null = null;await this.workspaceOrmManager.runInWorkspaceTransaction(async (transactionScope) => {+ await transactionScope.executeRawQuery(+ `SELECT id FROM "${getWorkspaceSchemaName(workspaceId)}".workflow WHERE id = $1 FOR NO KEY UPDATE`,+ [workflow.id],+ );+ await transactionScope.executeRawQuery(+ `SELECT id FROM "${getWorkspaceSchemaName(workspaceId)}"."workflowVersion" WHERE "workflowId" = $1 ORDER BY id FOR NO KEY UPDATE`,+ [workflow.id],+ );++ const unchangedVersion = await transactionScope.executeRawQuery(+ `SELECT id FROM "${getWorkspaceSchemaName(workspaceId)}"."workflowVersion" WHERE id = $1+ AND status = $2 AND trigger IS NOT DISTINCT FROM $3::jsonb AND steps IS NOT DISTINCT FROM $4::jsonb`,+ [+ workflowVersion.id,+ workflowVersion.status,+ JSON.stringify(workflowVersion.trigger),+ JSON.stringify(workflowVersion.steps),+ ],+ );++ if (unchangedVersion.length !== 1) {+ throw new WorkflowTriggerException(+ 'Workflow version changed during activation',+ WorkflowTriggerExceptionCode.INVALID_INPUT,+ {+ userFriendlyMessage: msg`Workflow version changed, please reload and retry`,+ },+ );+ }+const transactionalWorkflowRepository =transactionScope.getRepository<WorkflowWorkspaceEntity>('workflow', {shouldBypassPermissionChecks: true,@@ -308,15 +317,31 @@ export class WorkflowTriggerWorkspaceService {{ shouldBypassPermissionChecks: true },);- if (workflow.lastPublishedVersionId !== workflowVersion.id) {- if (workflow.lastPublishedVersionId) {+ const currentWorkflow =+ await transactionalWorkflowRepository.findOneOrFail({+ where: { id: workflow.id },+ });++ if (currentWorkflow.lastPublishedVersionId !== workflowVersion.id) {+ if (currentWorkflow.lastPublishedVersionId) {+ previousVersion =+ await transactionalWorkflowVersionRepository.findOne({+ where: { id: currentWorkflow.lastPublishedVersionId },+ });++ if (previousVersion?.status === WorkflowVersionStatus.ACTIVE) {+ await this.disableAutomatedTrigger(previousVersion, workspaceId, {+ transactionScope,+ });+ }+await transactionalWorkflowVersionRepository.update(- { id: workflow.lastPublishedVersionId },+ { id: currentWorkflow.lastPublishedVersionId },{ status: WorkflowVersionStatus.ARCHIVED },);await this.mirrorVersionStatusChangeInTransaction(- workflow.lastPublishedVersionId,+ currentWorkflow.lastPublishedVersionId,workspaceId,transactionScope,);@@ -358,6 +383,23 @@ export class WorkflowTriggerWorkspaceService {transactionScope,);+ if (!isDefined(mirroredCoreWorkflowVersionId)) {+ throw new WorkflowTriggerException(+ 'Activated workflow version has no core mapping',+ WorkflowTriggerExceptionCode.INVALID_WORKFLOW_VERSION,+ );+ }++ await transactionScope.executeRawQuery(+ `UPDATE core."workflow" SET "lastPublishedVersionId" = $3, "lastPublishedCoreWorkflowVersionId" = $4, "updatedAt" = now() WHERE "workspaceId" = $1 AND "workspaceWorkflowId" = $2`,+ [+ workspaceId,+ workflow.id,+ workflowVersion.id,+ mirroredCoreWorkflowVersionId,+ ],+ );+mirroredCoreWorkflowVersionIdForCommandMenuItem =mirroredCoreWorkflowVersionId;@@ -368,6 +410,15 @@ export class WorkflowTriggerWorkspaceService {},);+ if (isDefined(previousVersion)) {+ await this.deleteCommandMenuItem(previousVersion, workspaceId);+ await this.emitStatusUpdateEvents(+ previousVersion,+ WorkflowVersionStatus.ARCHIVED,+ workspaceId,+ );+ }+await this.createOrUpdateCommandMenuItem(workflow,workflowVersion,@@ -404,8 +455,6 @@ export class WorkflowTriggerWorkspaceService {return;}- await this.deleteCommandMenuItem(workflowVersion, workspaceId);-await this.workspaceOrmManager.runInWorkspaceTransaction(async (transactionScope) => {await transactionScope@@ -429,6 +478,8 @@ export class WorkflowTriggerWorkspaceService {},);+ await this.deleteCommandMenuItem(workflowVersion, workspaceId);+await this.workflowVersionCoreSyncService.invalidateAutomatedTriggerMaps(workspaceId,);@@ -619,11 +670,34 @@ export class WorkflowTriggerWorkspaceService {}),};- await this.cacheStorageService.hashSetIfExists({- key: WORKFLOW_CRON_TRIGGER_CACHE_KEY,- field: workflowVersion.workflowId,- value: JSON.stringify(cachedTrigger),- });+ const publishCronCache = async () => {+ try {+ await this.cacheStorageService.hashSetIfExists({+ key: WORKFLOW_CRON_TRIGGER_CACHE_KEY,+ field: workflowVersion.workflowId,+ value: JSON.stringify(cachedTrigger),+ });+ } catch (error) {+ this.logger.error(+ `Cron trigger cache entry not published for workflow ${workflowVersion.workflowId}, dropping the cron cache so the next tick rebuilds it from the database`,+ error,+ );++ try {+ await this.cacheStorageService.del(+ WORKFLOW_CRON_TRIGGER_CACHE_KEY,+ );+ } catch (invalidationError) {+ this.logger.error(invalidationError);+ }+ }+ };++ if (isDefined(transactionContext)) {+ transactionContext.transactionScope.afterCommit(publishCronCache);+ } else {+ await publishCronCache();+ }return;}@@ -657,10 +731,18 @@ export class WorkflowTriggerWorkspaceService {transactionScope: transactionContext?.transactionScope,});- await this.cacheStorageService.hashDelete({- key: WORKFLOW_CRON_TRIGGER_CACHE_KEY,- field: workflowVersion.workflowId,- });+ const removeCronCache = async () => {+ await this.cacheStorageService.hashDelete({+ key: WORKFLOW_CRON_TRIGGER_CACHE_KEY,+ field: workflowVersion.workflowId,+ });+ };++ if (isDefined(transactionContext)) {+ transactionContext.transactionScope.afterCommit(removeCronCache);+ } else {+ await removeCronCache();+ }return;case WorkflowTriggerType.MANUAL:diff --git a/packages/twenty-server/test/integration/graphql/suites/workflow/core-workflow-execution.integration-spec.ts b/packages/twenty-server/test/integration/graphql/suites/workflow/core-workflow-execution.integration-spec.tsnew file mode 100644index 00000000000..d8d6960c02e--- /dev/null+++ b/packages/twenty-server/test/integration/graphql/suites/workflow/core-workflow-execution.integration-spec.ts@@ -0,0 +1,1730 @@+import { CronTriggerDeduplicationService } from 'src/engine/core-modules/cron/services/cron-trigger-deduplication.service';+import { randomUUID } from 'node:crypto';+import { USER_DATA_SEED_IDS } from 'src/engine/workspace-manager/dev-seeder/core/utils/seed-users.util';++import request from 'supertest';+import { FeatureFlagKey, FieldMetadataType } from 'twenty-shared/types';+import { WorkspaceActivationStatus } from 'twenty-shared/workspace';+import { type UserEntity } from 'src/engine/core-modules/user/user.entity';+import { type WorkspaceEntity } from 'src/engine/core-modules/workspace/workspace.entity';+import { WorkflowActionType } from 'twenty-shared/workflow';++import {+ type WorkflowAction,+ type WorkflowEmptyAction,+} from 'src/modules/workflow/workflow-executor/workflow-actions/types/workflow-action.type';+import { MessageQueue } from 'src/engine/core-modules/message-queue/message-queue.constants';+import { type MessageQueueService } from 'src/engine/core-modules/message-queue/services/message-queue.service';+import { getQueueToken } from 'src/engine/core-modules/message-queue/utils/get-queue-token.util';++import { type CacheStorageService } from 'src/engine/core-modules/cache-storage/services/cache-storage.service';+import { CacheStorageNamespace } from 'src/engine/core-modules/cache-storage/types/cache-storage-namespace.enum';+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';+import { workflowGraphqlRequest } from 'test/integration/graphql/suites/workflow/utils/workflow-graphql-request.util';+import { getAppProviderByClassName } from 'test/integration/utils/get-app-provider-by-class-name.util';+import { type ProvisionedWorkspaceCommandRunner } from 'src/database/commands/command-runners/provisioned-workspace.command-runner';++import { type AutomatedTriggerWorkspaceService } from 'src/modules/workflow/workflow-trigger/automated-trigger/automated-trigger.workspace-service';+import { type CoreWorkflowVersionWriteService } from 'src/engine/core-modules/workflow/services/core-workflow-version-write.service';+import { WORKFLOW_CRON_TRIGGER_CACHE_KEY } from 'src/modules/workflow/workflow-trigger/automated-trigger/crons/constants/workflow-cron-trigger-cache-key.constant';++import { type CodeStepBuildService } from 'src/modules/workflow/workflow-builder/workflow-version-step/code-step/services/code-step-build.service';+import { type WorkflowActionFactory } from 'src/modules/workflow/workflow-executor/factories/workflow-action.factory';++const workspaceId = SEED_APPLE_WORKSPACE_ID;+const schema = getWorkspaceSchemaName(workspaceId);+const settings = {+ input: {},+ outputSchema: {},+ errorHandlingOptions: {+ retryOnFailure: { value: 0 },+ continueOnFailure: { value: false },+ },+};+const emptyStep = (): WorkflowEmptyAction => ({+ id: randomUUID(),+ name: 'Core execution marker',+ type: WorkflowActionType.EMPTY,+ valid: true,+ settings,+ nextStepIds: [],+});++type Fixture = {+ coreWorkflowId: string;+ coreWorkflowVersionId: string;+ workflowId: string | null;+ workflowVersionId: string | null;+ trigger: object;+ steps: WorkflowAction[];+};++describe('core workflow execution and queue compatibility (e2e)', () => {+ const fixtures: Fixture[] = [];++ const createFixture = async ({+ mirrorless = false,+ triggerType = 'MANUAL',+ triggerSettings = {},+ steps = [emptyStep()],+ }: {+ mirrorless?: boolean;+ triggerType?: string;+ triggerSettings?: object;+ steps?: WorkflowAction[];+ } = {}): Promise<Fixture> => {+ let coreWorkflowId = randomUUID();+ let coreWorkflowVersionId = randomUUID();+ let workflowId: string | null = null;+ let workflowVersionId: string | null = null;+ const trigger = {+ name: 'B-Async trigger',+ type: triggerType,+ settings: { outputSchema: {}, ...triggerSettings },+ nextStepIds: steps.length > 0 ? [steps[0].id] : [],+ };++ if (mirrorless) {+ const [workspace] = await global.testDataSource.query(+ `SELECT "workspaceCustomApplicationId" FROM core.workspace WHERE id = $1`,+ [workspaceId],+ );++ await global.testDataSource.query(+ `INSERT INTO core.workflow (id, "workspaceId", "applicationId", "universalIdentifier", name)+ VALUES ($1, $2, $3, $4, 'B-Async mirrorless')`,+ [+ coreWorkflowId,+ workspaceId,+ workspace.workspaceCustomApplicationId,+ randomUUID(),+ ],+ );+ await global.testDataSource.query(+ `INSERT INTO core."workflowVersion" (id, "workspaceId", "applicationId", "universalIdentifier", "coreWorkflowId", "workflowId", status, triggers, steps)+ VALUES ($1, $2, $3, $4, $5, NULL, 'ACTIVE', $6, $7)`,+ [+ coreWorkflowVersionId,+ workspaceId,+ workspace.workspaceCustomApplicationId,+ randomUUID(),+ coreWorkflowId,+ JSON.stringify([trigger]),+ JSON.stringify(steps),+ ],+ );+ } else {+ const response = await workflowGraphqlRequest(+ 'mutation { createWorkflow(data: { name: "B-Async execution" }) { id coreWorkflowId } }',+ );++ expect(response.body.errors).toBeUndefined();+ workflowId = response.body.data.createWorkflow.id;+ const [version] = await global.testDataSource.query(+ `SELECT id, "coreWorkflowVersionId" FROM "${schema}"."workflowVersion" WHERE "workflowId" = $1`,+ [workflowId],+ );+ const [workflow] = await global.testDataSource.query(+ `SELECT "coreWorkflowId" FROM "${schema}".workflow WHERE id = $1`,+ [workflowId],+ );++ workflowVersionId = version.id;+ coreWorkflowId = workflow.coreWorkflowId;+ coreWorkflowVersionId = version.coreWorkflowVersionId;+ await global.testDataSource.query(+ `UPDATE core."workflowVersion" SET triggers = $2, steps = $3, status = 'ACTIVE' WHERE id = $1`,+ [+ coreWorkflowVersionId,+ JSON.stringify([trigger]),+ JSON.stringify(steps),+ ],+ );+ await global.testDataSource.query(+ `UPDATE "${schema}"."workflowVersion" SET trigger = $2, steps = $3, status = 'ACTIVE' WHERE id = $1`,+ [workflowVersionId, JSON.stringify(trigger), JSON.stringify(steps)],+ );+ await global.testDataSource.query(+ `UPDATE "${schema}".workflow SET "lastPublishedVersionId" = $2 WHERE id = $1`,+ [workflowId, workflowVersionId],+ );+ }++ await global.testDataSource.query(+ `UPDATE core.workflow SET "lastPublishedCoreWorkflowVersionId" = $2, "lastPublishedVersionId" = $3 WHERE id = $1`,+ [coreWorkflowId, coreWorkflowVersionId, workflowVersionId],+ );+ const fixture = {+ coreWorkflowId,+ coreWorkflowVersionId,+ workflowId,+ workflowVersionId,+ trigger,+ steps,+ };++ fixtures.push(fixture);+ await global.workflowTestServices.workspaceCache.invalidateAndRecompute(+ workspaceId,+ ['workflowAutomatedTriggerMaps'],+ );++ return fixture;+ };++ const getRun = async (runId: string) => {+ const [run] = await global.testDataSource.query(+ `SELECT * FROM "${schema}"."workflowRun" WHERE id = $1`,+ [runId],+ );++ return run;+ };++ const waitForRun = async (runId: string, status: string) => {+ for (let attempt = 0; attempt < 150; attempt++) {+ const run = await getRun(runId);++ if (run?.status === status) {+ return run;+ }+ await new Promise((resolve) => setTimeout(resolve, 100));+ }++ expect((await getRun(runId))?.status).toBe(status);+ };++ const runFixture = async (fixture: Fixture, legacy = false) => {+ const workflowRunId = randomUUID();+ const response = await workflowGraphqlRequest(+ legacy+ ? 'mutation Run($input: RunWorkflowVersionInput!) { runWorkflowVersion(input: $input) { workflowRunId } }'+ : 'mutation Run($input: RunCoreWorkflowVersionInput!) { runCoreWorkflowVersion(input: $input) { workflowRunId } }',+ {+ input: {+ ...(legacy+ ? { workflowVersionId: fixture.workflowVersionId }+ : { coreWorkflowVersionId: fixture.coreWorkflowVersionId }),+ workflowRunId,+ payload: { marker: 'B-Async payload' },+ },+ },+ );++ expect(response.body.errors).toBeUndefined();+ expect(Object.values(response.body.data)[0]).toEqual({ workflowRunId });++ return workflowRunId;+ };++ afterEach(() => jest.restoreAllMocks());++ afterAll(async () => {+ for (const fixture of fixtures.reverse()) {+ await global.testDataSource.query(+ `DELETE FROM "${schema}"."workflowRun" WHERE "coreWorkflowId" = $1`,+ [fixture.coreWorkflowId],+ );+ if (fixture.workflowId) {+ const response = await workflowGraphqlRequest(+ 'mutation Destroy($id: UUID!) { destroyWorkflow(id: $id) { id } }',+ { id: fixture.workflowId },+ );+ expect(response.body.errors).toBeUndefined();+ }+ await global.testDataSource.query(+ 'DELETE FROM core."workflowVersion" WHERE "coreWorkflowId" = $1',+ [fixture.coreWorkflowId],+ );+ await global.testDataSource.query(+ 'DELETE FROM core.workflow WHERE id = $1',+ [fixture.coreWorkflowId],+ );+ }+ await global.workflowTestServices.workspaceCache.invalidateAndRecompute(+ workspaceId,+ ['workflowAutomatedTriggerMaps'],+ );+ });++ it('completes a mirrorless run with core ids, a supplied run id, actor, and payload', async () => {+ const fixture = await createFixture({ mirrorless: true });+ const run = await waitForRun(await runFixture(fixture), 'COMPLETED');++ expect(run).toMatchObject({+ coreWorkflowId: fixture.coreWorkflowId,+ coreWorkflowVersionId: fixture.coreWorkflowVersionId,+ workflowId: null,+ workflowVersionId: null,+ state: {+ flow: { steps: fixture.steps },+ stepInfos: { trigger: { result: { marker: 'B-Async payload' } } },+ },+ });+ expect(run.createdByWorkspaceMemberId).toBeTruthy();+ });++ it('executes the same core definition from both APIs despite divergent workspace content', async () => {+ const fixture = await createFixture();++ await global.testDataSource.query(+ `UPDATE "${schema}"."workflowVersion" SET trigger = NULL, steps = NULL WHERE id = $1`,+ [fixture.workflowVersionId],+ );++ for (const legacy of [false, true]) {+ const run = await waitForRun(+ await runFixture(fixture, legacy),+ 'COMPLETED',+ );++ expect(run.coreWorkflowVersionId).toBe(fixture.coreWorkflowVersionId);+ expect(run.state.flow.steps).toEqual(fixture.steps);+ }+ });++ it.each(+ Object.values(WorkflowActionType).flatMap((actionType) =>+ [false, true].map((isCoreEnabled) => ({ actionType, isCoreEnabled })),+ ),+ )(+ 'dispatches $actionType from the API selected with the core flag set to $isCoreEnabled',+ async ({ actionType, isCoreEnabled }) => {+ const flags = global.workflowTestServices.flags;+ const featureFlag = FeatureFlagKey.IS_WORKFLOW_CORE_INDEX_PAGE_ENABLED;+ const original = await flags.isFeatureEnabled(featureFlag, workspaceId);+ const step = {+ id: randomUUID(),+ name: `${actionType} dispatch marker`,+ type: actionType,+ valid: true,+ settings: {+ ...settings,+ input:+ actionType === WorkflowActionType.IF_ELSE+ ? { branches: [] }+ : actionType === WorkflowActionType.ITERATOR+ ? { initialLoopStepIds: [] }+ : actionType === WorkflowActionType.CODE+ ? { logicFunctionId: randomUUID() }+ : {},+ },+ nextStepIds: [],+ } as WorkflowAction;+ const execute = jest.fn().mockResolvedValue({+ result:+ actionType === WorkflowActionType.ITERATOR+ ? { hasProcessedAllItems: true }+ : { actionType },+ });+ const actionFactory = getAppProviderByClassName<WorkflowActionFactory>(+ 'WorkflowActionFactory',+ );++ jest.spyOn(actionFactory, 'get').mockReturnValue({ execute });++ try {+ await flags.upsertWorkspaceFeatureFlag({+ workspaceId,+ featureFlag,+ value: isCoreEnabled,+ });+ const fixture = await createFixture({ steps: [step] });+ const run = await waitForRun(+ await runFixture(fixture, !isCoreEnabled),+ 'COMPLETED',+ );++ expect(actionFactory.get).toHaveBeenCalledWith(actionType);+ expect(execute).toHaveBeenCalledTimes(1);+ expect(run.state.flow.steps[0].type).toBe(actionType);+ expect(run.state.stepInfos[step.id].status).toBe('SUCCESS');+ } finally {+ await flags.upsertWorkspaceFeatureFlag({+ workspaceId,+ featureFlag,+ value: original,+ });+ }+ },+ );++ it.each([false, true])(+ 'bills the core-owned spender mapping (mirrorless=%s)',+ async (mirrorless) => {+ const fixture = await createFixture({ mirrorless });+ const consume = jest.spyOn(+ global.workflowTestServices.billing,+ 'consumeUsageQuota',+ );++ await waitForRun(await runFixture(fixture), 'COMPLETED');++ expect(consume).toHaveBeenCalledWith(+ expect.objectContaining({+ workspaceId,+ spenders: {+ workflowId: fixture.workflowId ?? fixture.coreWorkflowId,+ },+ }),+ );+ },+ );++ it.each([+ 'unversioned',+ 'workspace-version',+ 'core-version',+ 'backfilled-paired',+ ] as const)('accepts the %s legacy queue envelope', async (envelope) => {+ const fixture = await createFixture();++ if (envelope === 'backfilled-paired') {+ await global.testDataSource.query(+ 'UPDATE core."workflowVersion" SET "workspaceWorkflowVersionId" = NULL WHERE id = $1',+ [fixture.coreWorkflowVersionId],+ );+ await expect(backfill()).rejects.toThrow(+ 'Missing or conflicting workflow version mapping',+ );+ await global.workflowTestServices.versionAliasBackfill.runOnWorkspace({+ workspaceId,+ dataSource: global.testDataSource,+ options: {},+ index: 0,+ total: 1,+ });+ await global.workflowTestServices.backfill.runOnWorkspace({+ workspaceId,+ dataSource: global.testDataSource,+ options: {},+ index: 0,+ total: 1,+ });+ }++ const queue = global.app.get<MessageQueueService>(+ getQueueToken(MessageQueue.workflowQueue),+ );++ await queue.add('WorkflowTriggerJob', {+ workspaceId,+ workflowId: fixture.workflowId as string,+ payload: { marker: envelope },+ ...(envelope === 'workspace-version' || envelope === 'backfilled-paired'+ ? { workspaceWorkflowVersionId: fixture.workflowVersionId }+ : {}),+ ...(envelope === 'core-version' || envelope === 'backfilled-paired'+ ? { coreWorkflowVersionId: fixture.coreWorkflowVersionId }+ : {}),+ });+ for (let attempt = 0; attempt < 100; attempt++) {+ const [run] = await global.testDataSource.query(+ `SELECT id FROM "${schema}"."workflowRun" WHERE "coreWorkflowId" = $1`,+ [fixture.coreWorkflowId],+ );+ if (run) {+ const completedRun = await waitForRun(run.id, 'COMPLETED');++ expect(completedRun.createdByName).toBe('B-Async execution');+ expect(completedRun.createdBySource).toBe('WORKFLOW');+ return;+ }+ await new Promise((resolve) => setTimeout(resolve, 100));+ }+ throw new Error('Legacy queue envelope did not dispatch');+ });++ it('rejects a queued version belonging to another workflow or tenant', async () => {+ const first = await createFixture();+ const second = await createFixture();+ const job = await global.workflowTestServices.triggerJob();++ await job.handle({+ workspaceId,+ workflowId: first.coreWorkflowId,+ coreWorkflowVersionId: second.coreWorkflowVersionId,+ payload: {},+ });+ await job.handle({+ workspaceId: randomUUID(),+ workflowId: first.coreWorkflowId,+ coreWorkflowVersionId: first.coreWorkflowVersionId,+ payload: {},+ });+ const runs = await global.testDataSource.query(+ `SELECT id FROM "${schema}"."workflowRun" WHERE "coreWorkflowId" = ANY($1::uuid[])`,+ [[first.coreWorkflowId, second.coreWorkflowId]],+ );++ expect(runs).toHaveLength(0);+ });++ it('keeps the old webhook URL working without workspace definition reads', async () => {+ const fixture = await createFixture({+ triggerType: 'WEBHOOK',+ triggerSettings: {+ httpMethod: 'POST',+ authentication: null,+ expectedBody: {},+ },+ });++ await global.testDataSource.query(+ `UPDATE "${schema}"."workflowVersion" SET trigger = NULL, steps = NULL WHERE id = $1`,+ [fixture.workflowVersionId],+ );+ const response = await request(`http://localhost:${APP_PORT}`)+ .post(`/webhooks/workflows/${workspaceId}/${fixture.workflowId}`)+ .send({ marker: 'old-url' });++ expect(response.status).toBe(201);+ expect(response.body.success).toBe(true);+ await waitForRun(response.body.workflowRunId, 'COMPLETED');+ });++ it('backfills a queued legacy run and starts its persisted snapshot after a core edit', async () => {+ const fixture = await createFixture();+ const workflowRunId = randomUUID();+ const state = {+ flow: { trigger: fixture.trigger, steps: fixture.steps },+ stepInfos: {+ trigger: { status: 'NOT_STARTED', result: {} },+ ...Object.fromEntries(+ fixture.steps.map((step) => [+ (step as { id: string }).id,+ { status: 'NOT_STARTED' },+ ]),+ ),+ },+ };++ await global.testDataSource.query(+ `INSERT INTO "${schema}"."workflowRun" (id, name, "workflowId", "workflowVersionId", status, state, position) VALUES ($1, 'B-Async old queued run', $2, $3, 'ENQUEUED', $4, 0)`,+ [+ workflowRunId,+ fixture.workflowId,+ fixture.workflowVersionId,+ JSON.stringify(state),+ ],+ );+ await global.workflowTestServices.backfill.runOnWorkspace({+ workspaceId,+ dataSource: global.testDataSource,+ options: {},+ index: 0,+ total: 1,+ });+ await global.testDataSource.query(+ 'UPDATE core."workflowVersion" SET triggers = NULL, steps = NULL WHERE id = $1',+ [fixture.coreWorkflowVersionId],+ );+ await (+ await global.workflowTestServices.runJob()+ ).handle({ workspaceId, workflowRunId });+ const run = await waitForRun(workflowRunId, 'COMPLETED');++ expect(run.coreWorkflowVersionId).toBe(fixture.coreWorkflowVersionId);+ expect(run.state.flow).toEqual(state.flow);+ });++ it('defers the core trigger cache during historical upgrades and rebuilds it after backfill', async () => {+ const fixture = await createFixture({+ triggerType: 'CRON',+ triggerSettings: { type: 'CUSTOM', pattern: '* * * * *' },+ });+ const { workspaceCache, upgradeState, backfill } =+ global.workflowTestServices;+ const hiddenColumns = jest+ .spyOn(upgradeState, 'getHiddenColumnPropertyNames')+ .mockReturnValueOnce(new Set(['workspaceWorkflowVersionId']));++ await workspaceCache.invalidateAndRecompute(workspaceId, [+ 'workflowAutomatedTriggerMaps',+ ]);+ const duringUpgrade = await workspaceCache.getOrRecompute(workspaceId, [+ 'workflowAutomatedTriggerMaps',+ ]);++ expect(duringUpgrade.workflowAutomatedTriggerMaps.byWorkflowId).toEqual({});+ hiddenColumns.mockRestore();+ await backfill.runOnWorkspace({+ workspaceId,+ dataSource: global.testDataSource,+ options: {},+ index: 0,+ total: 1,+ });+ const afterUpgrade = await workspaceCache.getOrRecompute(workspaceId, [+ 'workflowAutomatedTriggerMaps',+ ]);++ expect(+ afterUpgrade.workflowAutomatedTriggerMaps.byWorkflowId[+ fixture.coreWorkflowId+ ],+ ).toMatchObject({ coreWorkflowVersionId: fixture.coreWorkflowVersionId });+ });++ it('normalizes overlapping old and core cron caches without duplicate runs', async () => {+ const fixture = await createFixture({+ triggerType: 'CRON',+ triggerSettings: { type: 'CUSTOM', pattern: '* * * * *' },+ });+ const cache = global.app.get<CacheStorageService>(+ CacheStorageNamespace.ModuleWorkflow,+ );+ const cron = global.workflowTestServices.cron;+ const oldEntry = {+ workspaceId,+ workflowId: fixture.workflowId,+ pattern: '* * * * *',+ };+ const newEntry = {+ workspaceId,+ workflowId: fixture.coreWorkflowId,+ coreWorkflowVersionId: fixture.coreWorkflowVersionId,+ pattern: '* * * * *',+ };++ jest+ .spyOn(cache, 'hashGetValues')+ .mockResolvedValue([JSON.stringify(oldEntry), JSON.stringify(newEntry)]);+ const dispatchTime = new Date();+ const shouldDispatch =+ CronTriggerDeduplicationService.prototype.shouldDispatch;++ jest+ .spyOn(CronTriggerDeduplicationService.prototype, 'shouldDispatch')+ .mockImplementation(function (key, pattern) {+ return shouldDispatch.call(this, key, pattern, dispatchTime);+ });+ await cron.handle();+ await cron.handle();++ for (let attempt = 0; attempt < 100; attempt++) {+ const runs = await global.testDataSource.query(+ `SELECT id FROM "${schema}"."workflowRun" WHERE "coreWorkflowId" = $1`,+ [fixture.coreWorkflowId],+ );++ if (runs.length > 0) {+ expect(runs).toHaveLength(1);+ await waitForRun(runs[0].id, 'COMPLETED');+ return;+ }+ await new Promise((resolve) => setTimeout(resolve, 100));+ }+ throw new Error('Cron failed to dispatch');+ });+ const waitForStep = async (runId: string, stepId: string, status: string) => {+ for (let attempt = 0; attempt < 150; attempt++) {+ const run = await getRun(runId);++ if (run?.state?.stepInfos[stepId]?.status === status) {+ return run;+ }+ await new Promise((resolve) => setTimeout(resolve, 100));+ }+ expect((await getRun(runId))?.state?.stepInfos[stepId]?.status).toBe(+ status,+ );+ };++ const backfill = async (dryRun = false) =>+ global.workflowTestServices.backfill.runOnWorkspace({+ workspaceId,+ dataSource: global.testDataSource,+ options: { dryRun },+ index: 0,+ total: 1,+ });++ const migratePendingRun = async (fixture: Fixture, runId: string) => {+ if (fixture.workflowVersionId) {+ await global.testDataSource.query(+ `UPDATE "${schema}"."workflowRun" SET "coreWorkflowId" = NULL, "coreWorkflowVersionId" = NULL WHERE id = $1`,+ [runId],+ );+ await backfill();+ expect((await getRun(runId)).coreWorkflowVersionId).toBe(+ fixture.coreWorkflowVersionId,+ );+ }+ };++ const clearDefinitions = async (fixture: Fixture) => {+ await global.testDataSource.query(+ 'UPDATE core."workflowVersion" SET triggers = NULL, steps = NULL WHERE id = $1',+ [fixture.coreWorkflowVersionId],+ );+ if (fixture.workflowVersionId) {+ await global.testDataSource.query(+ `UPDATE "${schema}"."workflowVersion" SET trigger = NULL, steps = NULL WHERE id = $1`,+ [fixture.workflowVersionId],+ );+ }+ };++ it.each([false, true])(+ 'resumes a delayed run after backfill and definition changes (mirrorless=%s)',+ async (mirrorless) => {+ const finalStep = emptyStep();+ const delay: WorkflowAction = {+ ...emptyStep(),+ type: WorkflowActionType.DELAY,+ nextStepIds: [finalStep.id],+ settings: {+ ...settings,+ input: { delayType: 'DURATION', duration: { seconds: 2 } },+ },+ };+ const fixture = await createFixture({+ mirrorless,+ steps: [delay, finalStep],+ });+ const runId = await runFixture(fixture);+ await waitForStep(runId, delay.id, 'PENDING');+ await migratePendingRun(fixture, runId);+ await clearDefinitions(fixture);+ const run = await waitForRun(runId, 'COMPLETED');++ expect(run.state.flow.steps).toEqual(fixture.steps);+ expect(run.state.stepInfos[finalStep.id].status).toBe('SUCCESS');+ },+ );++ it.each([false, true])(+ 'resumes a pending form after backfill and definition changes (mirrorless=%s)',+ async (mirrorless) => {+ const finalStep = emptyStep();+ const form: WorkflowAction = {+ ...emptyStep(),+ type: WorkflowActionType.FORM,+ nextStepIds: [finalStep.id],+ settings: {+ ...settings,+ input: [+ {+ id: randomUUID(),+ name: 'answer',+ label: 'Answer',+ type: FieldMetadataType.TEXT,+ },+ ],+ },+ };+ const fixture = await createFixture({+ mirrorless,+ steps: [form, finalStep],+ });+ const runId = await runFixture(fixture);+ await waitForStep(runId, form.id, 'PENDING');+ await migratePendingRun(fixture, runId);+ await clearDefinitions(fixture);+ const response = await workflowGraphqlRequest(+ 'mutation Submit($input: SubmitFormStepInput!) { submitFormStep(input: $input) }',+ {+ input: {+ workflowRunId: runId,+ stepId: form.id,+ response: { answer: 'From the stored form' },+ },+ },+ );++ expect(response.body.errors).toBeUndefined();+ const run = await waitForRun(runId, 'COMPLETED');+ expect(run.state.stepInfos[form.id].result).toEqual({+ answer: 'From the stored form',+ });+ expect(run.state.stepInfos[finalStep.id].status).toBe('SUCCESS');+ },+ );++ it('stops a pending delay and ignores its later resume job', async () => {+ const finalStep = emptyStep();+ const delay: WorkflowAction = {+ ...emptyStep(),+ type: WorkflowActionType.DELAY,+ nextStepIds: [finalStep.id],+ settings: {+ ...settings,+ input: { delayType: 'DURATION', duration: { seconds: 2 } },+ },+ };+ const fixture = await createFixture({+ mirrorless: true,+ steps: [delay, finalStep],+ });+ const runId = await runFixture(fixture);+ await waitForStep(runId, delay.id, 'PENDING');+ const response = await workflowGraphqlRequest(+ 'mutation Stop($id: UUID!) { stopWorkflowRun(workflowRunId: $id) { id status } }',+ { id: runId },+ );++ expect(response.body.errors).toBeUndefined();+ await waitForRun(runId, 'STOPPED');+ await new Promise((resolve) => setTimeout(resolve, 2500));+ const run = await getRun(runId);+ expect(run.status).toBe('STOPPED');+ expect(run.state.stepInfos[finalStep.id].status).toBe('NOT_STARTED');+ });++ it('retries the failed snapshot instead of the newly edited core version', async () => {+ const failedStep: WorkflowAction = {+ ...emptyStep(),+ type: WorkflowActionType.DELAY,+ settings: {+ ...settings,+ input: {+ delayType: 'SCHEDULED_DATE',+ scheduledDateTime: '2000-01-01T00:00:00.000Z',+ },+ },+ };+ const fixture = await createFixture({+ mirrorless: true,+ steps: [failedStep],+ });+ const runId = await runFixture(fixture);+ const original = await waitForRun(runId, 'FAILED');+ await global.testDataSource.query(+ 'UPDATE core."workflowVersion" SET steps = $2 WHERE id = $1',+ [fixture.coreWorkflowVersionId, JSON.stringify([emptyStep()])],+ );+ const response = await workflowGraphqlRequest(+ 'mutation Retry($id: UUID!) { retryWorkflowRun(workflowRunId: $id) { id status } }',+ { id: runId },+ );++ expect(response.body.errors).toBeUndefined();+ expect(response.body.data.retryWorkflowRun.status).toBe('RUNNING');+ const retried = await waitForRun(runId, 'FAILED');+ expect(retried.state.flow).toEqual(original.state.flow);+ expect(retried.state.stepInfos[failedStep.id].status).toBe('FAILED');+ });++ it('relinks restored runs before retrying their captured snapshots', async () => {+ const failedStep: WorkflowAction = {+ ...emptyStep(),+ type: WorkflowActionType.DELAY,+ settings: {+ ...settings,+ input: {+ delayType: 'SCHEDULED_DATE',+ scheduledDateTime: '2000-01-01T00:00:00.000Z',+ },+ },+ };+ const fixture = await createFixture({ steps: [failedStep] });+ const originalCoreWorkflowId = fixture.coreWorkflowId;+ const runId = await runFixture(fixture);++ await waitForRun(runId, 'FAILED');++ const deleteResponse = await workflowGraphqlRequest(+ 'mutation Delete($id: UUID!) { deleteWorkflow(id: $id) { id } }',+ { id: fixture.workflowId },+ );++ expect(deleteResponse.body.errors).toBeUndefined();++ await global.testDataSource.query(+ 'DELETE FROM core.workflow WHERE id = $1',+ [originalCoreWorkflowId],+ );++ const restoreResponse = await workflowGraphqlRequest(+ 'mutation Restore($id: UUID!) { restoreWorkflow(id: $id) { id } }',+ { id: fixture.workflowId },+ );++ expect(restoreResponse.body.errors).toBeUndefined();++ const [restoredMapping] = await global.testDataSource.query(+ `SELECT w."coreWorkflowId", wv."coreWorkflowVersionId"+ FROM "${schema}".workflow w+ JOIN "${schema}"."workflowVersion" wv ON wv.id = $2+ WHERE w.id = $1`,+ [fixture.workflowId, fixture.workflowVersionId],+ );+ const restoredRun = await getRun(runId);++ expect(restoredMapping.coreWorkflowId).not.toBe(originalCoreWorkflowId);+ expect(restoredRun.coreWorkflowId).toBe(restoredMapping.coreWorkflowId);+ expect(restoredRun.coreWorkflowVersionId).toBe(+ restoredMapping.coreWorkflowVersionId,+ );++ fixture.coreWorkflowId = restoredMapping.coreWorkflowId;+ fixture.coreWorkflowVersionId = restoredMapping.coreWorkflowVersionId;++ const retryResponse = await workflowGraphqlRequest(+ 'mutation Retry($id: UUID!) { retryWorkflowRun(workflowRunId: $id) { id status } }',+ { id: runId },+ );++ expect(retryResponse.body.errors).toBeUndefined();+ await waitForRun(runId, 'FAILED');+ });++ it('restores historical versions that no longer validate against current metadata', async () => {+ const historicalStep: WorkflowAction = {+ ...emptyStep(),+ type: WorkflowActionType.CREATE_RECORD,+ settings: {+ ...settings,+ input: { objectName: 'unavailableObject', objectRecord: {} },+ },+ };+ const fixture = await createFixture({ steps: [historicalStep] });+ const deleteResponse = await workflowGraphqlRequest(+ 'mutation Delete($id: UUID!) { deleteWorkflow(id: $id) { id } }',+ { id: fixture.workflowId },+ );++ expect(deleteResponse.body.errors).toBeUndefined();++ const restoreResponse = await workflowGraphqlRequest(+ 'mutation Restore($id: UUID!) { restoreWorkflow(id: $id) { id } }',+ { id: fixture.workflowId },+ );++ expect(restoreResponse.body.errors).toBeUndefined();++ const [restoredVersion] = await global.testDataSource.query(+ 'SELECT steps FROM core."workflowVersion" WHERE id = $1',+ [fixture.coreWorkflowVersionId],+ );++ expect(restoredVersion.steps).toEqual([historicalStep]);+ });++ it('records hard-throttled runs with their requested id and snapshot', async () => {+ const fixture = await createFixture({ mirrorless: true });+ jest+ .spyOn(+ global.workflowTestServices.throttling,+ 'throttleOrThrowIfHardLimitReached',+ )+ .mockRejectedValue(new Error('Throttle limit reached'));+ const run = await waitForRun(await runFixture(fixture), 'FAILED');++ expect(run.coreWorkflowVersionId).toBe(fixture.coreWorkflowVersionId);+ expect(run.state.flow.steps).toEqual(fixture.steps);+ expect(run.state.workflowRunError).toBe('Throttle limit reached');+ });++ it('leaves automated runs queued under the soft limit and drains them when capacity returns', async () => {+ const fixture = await createFixture({+ mirrorless: true,+ triggerType: 'WEBHOOK',+ triggerSettings: {+ httpMethod: 'POST',+ authentication: null,+ expectedBody: {},+ },+ });+ const capacity = jest+ .spyOn(+ global.workflowTestServices.throttling,+ 'getRemainingRunsToEnqueueCount',+ )+ .mockResolvedValue(0);+ const runId = await runFixture(fixture);+ await waitForRun(runId, 'NOT_STARTED');+ await new Promise((resolve) => setTimeout(resolve, 250));+ expect((await getRun(runId)).status).toBe('NOT_STARTED');+ capacity.mockRestore();+ await global.app+ .get<MessageQueueService>(getQueueToken(MessageQueue.workflowQueue))+ .add('WorkflowRunEnqueueJob', { workspaceId, isCacheMode: false });+ await waitForRun(runId, 'COMPLETED');+ });++ it('preserves the subscription check and execution when billing enforcement is disabled', async () => {+ const fixture = await createFixture({ mirrorless: true });+ const subscriptionCheck = jest+ .spyOn(+ global.workflowTestServices.billing,+ 'getSubscriptionInactiveReason',+ )+ .mockResolvedValue('WORKSPACE_SUSPENDED');+ const runId = await runFixture(fixture);+ const run = await waitForRun(runId, 'COMPLETED');+ expect(subscriptionCheck).toHaveBeenCalledWith(workspaceId);+ expect(run.coreWorkflowVersionId).toBe(fixture.coreWorkflowVersionId);+ expect(run.state.flow.steps).toEqual(fixture.steps);+ });++ it('edits, activates and executes through both APIs across flag ON / OFF / ON', async () => {+ const flags = global.workflowTestServices.flags;+ const featureFlag = FeatureFlagKey.IS_WORKFLOW_CORE_INDEX_PAGE_ENABLED;+ const original = await flags.isFeatureEnabled(featureFlag, workspaceId);+ const fixture = await createFixture();+ try {+ for (const value of [true, false, true]) {+ await flags.upsertWorkspaceFeatureFlag({+ workspaceId,+ featureFlag,+ value,+ });+ const draftResponse = await workflowGraphqlRequest(+ value+ ? 'mutation Draft($input: CreateDraftFromCoreWorkflowVersionInput!) { createDraftFromCoreWorkflowVersion(input: $input) { id } }'+ : 'mutation Draft($input: CreateDraftFromWorkflowVersionInput!) { createDraftFromWorkflowVersion(input: $input) { id } }',+ {+ input: value+ ? {+ coreWorkflowId: fixture.coreWorkflowId,+ coreWorkflowVersionIdToCopy: fixture.coreWorkflowVersionId,+ }+ : {+ workflowId: fixture.workflowId,+ workflowVersionIdToCopy: fixture.workflowVersionId,+ },+ },+ );+ expect(draftResponse.body.errors).toBeUndefined();+ const [draft] = await global.testDataSource.query(+ `SELECT id, "workspaceWorkflowVersionId" FROM core."workflowVersion" WHERE "coreWorkflowId" = $1 AND status = 'DRAFT'`,+ [fixture.coreWorkflowId],+ );+ fixture.coreWorkflowVersionId = draft.id;+ fixture.workflowVersionId = draft.workspaceWorkflowVersionId;+ const editedTrigger = {+ ...fixture.trigger,+ name: `B-Async flag ${value}`,+ };+ const editResponse = await workflowGraphqlRequest(+ value+ ? 'mutation Edit($input: UpdateCoreWorkflowVersionTriggerInput!) { updateCoreWorkflowVersionTrigger(input: $input) { trigger } }'+ : 'mutation Edit($input: UpdateWorkflowVersionTriggerInput!) { updateWorkflowVersionTrigger(input: $input) { trigger } }',+ {+ input: {+ ...(value+ ? { coreWorkflowVersionId: draft.id }+ : { workflowVersionId: draft.workspaceWorkflowVersionId }),+ trigger: editedTrigger,+ },+ },+ );+ expect(editResponse.body.errors).toBeUndefined();+ const activateResponse = await workflowGraphqlRequest(+ value+ ? 'mutation Activate($id: UUID!) { activateCoreWorkflowVersion(coreWorkflowVersionId: $id) }'+ : 'mutation Activate($id: UUID!) { activateWorkflowVersion(workflowVersionId: $id) }',+ { id: value ? draft.id : draft.workspaceWorkflowVersionId },+ );+ expect(activateResponse.body.errors).toBeUndefined();+ for (const legacy of [false, true]) {+ const run = await waitForRun(+ await runFixture(fixture, legacy),+ 'COMPLETED',+ );+ expect(run.coreWorkflowVersionId).toBe(fixture.coreWorkflowVersionId);+ }+ }+ } finally {+ await flags.upsertWorkspaceFeatureFlag({+ workspaceId,+ featureFlag,+ value: original,+ });+ }+ });++ it.each(['core', 'legacy'] as const)(+ 'keeps the published version executable when replacement activation fails through the %s API',+ async (api) => {+ const fixture = await createFixture({+ triggerType: 'CRON',+ triggerSettings: { type: 'CUSTOM', pattern: '* * * * *' },+ });+ const triggerService =+ getAppProviderByClassName<AutomatedTriggerWorkspaceService>(+ 'AutomatedTriggerWorkspaceService',+ );+ await global.testDataSource.query(+ `UPDATE core."workflowVersion" SET status = 'DRAFT' WHERE id = $1`,+ [fixture.coreWorkflowVersionId],+ );+ await global.testDataSource.query(+ `UPDATE "${schema}"."workflowVersion" SET status = 'DRAFT' WHERE id = $1`,+ [fixture.workflowVersionId],+ );+ const activateQuery =+ api === 'core'+ ? 'mutation Activate($id: UUID!) { activateCoreWorkflowVersion(coreWorkflowVersionId: $id) }'+ : 'mutation Activate($id: UUID!) { activateWorkflowVersion(workflowVersionId: $id) }';+ const firstActivation = await workflowGraphqlRequest(activateQuery, {+ id:+ api === 'core'+ ? fixture.coreWorkflowVersionId+ : fixture.workflowVersionId,+ });+ expect(firstActivation.body.errors).toBeUndefined();+ const cache = global.app.get<CacheStorageService>(+ CacheStorageNamespace.ModuleWorkflow,+ );+ const cronCacheKey = WORKFLOW_CRON_TRIGGER_CACHE_KEY;+ const originalCache = await cache.hashGetValues(cronCacheKey);+ const draftResponse = await workflowGraphqlRequest(+ 'mutation Draft($input: CreateDraftFromCoreWorkflowVersionInput!) { createDraftFromCoreWorkflowVersion(input: $input) { id workspaceWorkflowVersionId } }',+ {+ input: {+ coreWorkflowId: fixture.coreWorkflowId,+ coreWorkflowVersionIdToCopy: fixture.coreWorkflowVersionId,+ },+ },+ );+ expect(draftResponse.body.errors).toBeUndefined();+ const draft = draftResponse.body.data.createDraftFromCoreWorkflowVersion;+ const failure = jest+ .spyOn(triggerService, 'addAutomatedTrigger')+ .mockRejectedValueOnce(new Error('Replacement trigger failure'));+ const response = await workflowGraphqlRequest(activateQuery, {+ id: api === 'core' ? draft.id : draft.workspaceWorkflowVersionId,+ });+ expect(response.body.errors).toBeDefined();+ expect(failure).toHaveBeenCalledTimes(1);+ failure.mockRestore();+ const [oldVersion] = await global.testDataSource.query(+ 'SELECT status FROM core."workflowVersion" WHERE id = $1',+ [fixture.coreWorkflowVersionId],+ );+ const [newVersion] = await global.testDataSource.query(+ 'SELECT status FROM core."workflowVersion" WHERE id = $1',+ [draft.id],+ );+ const [workflow] = await global.testDataSource.query(+ 'SELECT "lastPublishedCoreWorkflowVersionId" FROM core.workflow WHERE id = $1',+ [fixture.coreWorkflowId],+ );+ const [oldMirror] = await global.testDataSource.query(+ `SELECT status FROM "${schema}"."workflowVersion" WHERE id = $1`,+ [fixture.workflowVersionId],+ );+ const triggers = await global.testDataSource.query(+ `SELECT id FROM "${schema}"."workflowAutomatedTrigger" WHERE "workflowId" = $1`,+ [fixture.workflowId],+ );+ expect(oldVersion.status).toBe('ACTIVE');+ expect(oldMirror.status).toBe('ACTIVE');+ expect(newVersion.status).toBe('DRAFT');+ expect(workflow.lastPublishedCoreWorkflowVersionId).toBe(+ fixture.coreWorkflowVersionId,+ );+ expect(triggers).toHaveLength(1);+ expect(await cache.hashGetValues(cronCacheKey)).toEqual(originalCache);+ await waitForRun(await runFixture(fixture), 'COMPLETED');+ const retry = await workflowGraphqlRequest(activateQuery, {+ id: api === 'core' ? draft.id : draft.workspaceWorkflowVersionId,+ });+ expect(retry.body.errors).toBeUndefined();+ const versions = await global.testDataSource.query(+ 'SELECT id, status FROM core."workflowVersion" WHERE "coreWorkflowId" = $1',+ [fixture.coreWorkflowId],+ );+ expect(versions).toEqual(+ expect.arrayContaining([+ { id: fixture.coreWorkflowVersionId, status: 'ARCHIVED' },+ { id: draft.id, status: 'ACTIVE' },+ ]),+ );+ },+ );++ it.each(['core', 'legacy'] as const)(+ 'rejects a draft edited while the %s API prepares activation',+ async (api) => {+ const fixture = await createFixture();+ await global.testDataSource.query(+ `UPDATE core."workflowVersion" SET status = 'DRAFT' WHERE id = $1`,+ [fixture.coreWorkflowVersionId],+ );+ await global.testDataSource.query(+ `UPDATE "${schema}"."workflowVersion" SET status = 'DRAFT' WHERE id = $1`,+ [fixture.workflowVersionId],+ );+ const codeBuild = getAppProviderByClassName<CodeStepBuildService>(+ 'CodeStepBuildService',+ );+ let notifyPreparing: () => void = () => {};+ let releasePreparation: () => void = () => {};+ const preparing = new Promise<void>((resolve) => {+ notifyPreparing = resolve;+ });+ const prepared = new Promise<void>((resolve) => {+ releasePreparation = resolve;+ });+ const buildSpy = jest+ .spyOn(codeBuild, 'switchCodeStepLogicFunctionsToPrebuilt')+ .mockImplementationOnce(async () => {+ notifyPreparing();+ await prepared;+ });+ const activation = workflowGraphqlRequest(+ api === 'core'+ ? 'mutation Activate($id: UUID!) { activateCoreWorkflowVersion(coreWorkflowVersionId: $id) }'+ : 'mutation Activate($id: UUID!) { activateWorkflowVersion(workflowVersionId: $id) }',+ {+ id:+ api === 'core'+ ? fixture.coreWorkflowVersionId+ : fixture.workflowVersionId,+ },+ ).then((response) => response);+ try {+ await preparing;+ const edit = await workflowGraphqlRequest(+ 'mutation Edit($input: UpdateCoreWorkflowVersionTriggerInput!) { updateCoreWorkflowVersionTrigger(input: $input) { trigger } }',+ {+ input: {+ coreWorkflowVersionId: fixture.coreWorkflowVersionId,+ trigger: { ...fixture.trigger, name: 'Edited during activation' },+ },+ },+ );+ expect(edit.body.errors).toBeUndefined();+ } finally {+ releasePreparation();+ buildSpy.mockRestore();+ }+ expect(JSON.stringify((await activation).body.errors)).toContain(+ 'changed',+ );+ const [core] = await global.testDataSource.query(+ 'SELECT status, triggers FROM core."workflowVersion" WHERE id = $1',+ [fixture.coreWorkflowVersionId],+ );+ expect(core.status).toBe('DRAFT');+ expect(core.triggers[0].name).toBe('Edited during activation');+ },+ );++ it.each(['core', 'legacy'] as const)(+ 'rebuilds cron dispatch after a cache publication failure through the %s API',+ async (api) => {+ const fixture = await createFixture({+ triggerType: 'CRON',+ triggerSettings: { type: 'CUSTOM', pattern: '* * * * *' },+ });+ await global.testDataSource.query(+ `UPDATE core."workflowVersion" SET status = 'DRAFT' WHERE id = $1`,+ [fixture.coreWorkflowVersionId],+ );+ await global.testDataSource.query(+ `UPDATE "${schema}"."workflowVersion" SET status = 'DRAFT' WHERE id = $1`,+ [fixture.workflowVersionId],+ );+ const cache = global.app.get<CacheStorageService>(+ CacheStorageNamespace.ModuleWorkflow,+ );+ await cache.hashSet({+ key: WORKFLOW_CRON_TRIGGER_CACHE_KEY,+ field: 'b-async-rebuild-test',+ value: '{}',+ });+ const publication = jest+ .spyOn(cache, 'hashSetIfExists')+ .mockRejectedValueOnce(new Error('Cron cache publication failure'));+ const response = await workflowGraphqlRequest(+ api === 'core'+ ? 'mutation Activate($id: UUID!) { activateCoreWorkflowVersion(coreWorkflowVersionId: $id) }'+ : 'mutation Activate($id: UUID!) { activateWorkflowVersion(workflowVersionId: $id) }',+ {+ id:+ api === 'core'+ ? fixture.coreWorkflowVersionId+ : fixture.workflowVersionId,+ },+ );+ expect(response.body.errors).toBeUndefined();+ expect(publication).toHaveBeenCalledTimes(1);+ publication.mockRestore();+ expect(+ await cache.hashGetValues(WORKFLOW_CRON_TRIGGER_CACHE_KEY),+ ).toEqual([]);+ await global.workflowTestServices.cron.handle();+ const entries = await cache.hashGetValues(+ WORKFLOW_CRON_TRIGGER_CACHE_KEY,+ );+ expect(entries.map((entry) => JSON.parse(entry))).toEqual(+ expect.arrayContaining([+ expect.objectContaining({+ coreWorkflowVersionId: fixture.coreWorkflowVersionId,+ }),+ ]),+ );+ for (let attempt = 0; attempt < 100; attempt++) {+ const runs = await global.testDataSource.query(+ `SELECT id FROM "${schema}"."workflowRun" WHERE "coreWorkflowId" = $1`,+ [fixture.coreWorkflowId],+ );+ if (runs.length > 0) {+ await waitForRun(runs[0].id, 'COMPLETED');+ return;+ }+ await new Promise((resolve) => setTimeout(resolve, 100));+ }+ throw new Error(+ 'Rebuilt cron cache did not dispatch the activated workflow',+ );+ },+ );++ it('rejects an overlapping builder edit without losing the successful edit and accepts a fresh retry', async () => {+ const fixture = await createFixture();+ await global.testDataSource.query(+ `UPDATE core."workflowVersion" SET status = 'DRAFT' WHERE id = $1`,+ [fixture.coreWorkflowVersionId],+ );+ await global.testDataSource.query(+ `UPDATE "${schema}"."workflowVersion" SET status = 'DRAFT' WHERE id = $1`,+ [fixture.workflowVersionId],+ );+ const writer = getAppProviderByClassName<CoreWorkflowVersionWriteService>(+ 'CoreWorkflowVersionWriteService',+ );+ const readDraft = writer.getValidatedDraftCoreWorkflowVersion.bind(writer);+ let releaseReads: () => void = () => {};+ const bothRead = new Promise<void>((resolve) => {+ releaseReads = resolve;+ });+ let readCount = 0;+ const readSpy = jest+ .spyOn(writer, 'getValidatedDraftCoreWorkflowVersion')+ .mockImplementation(async (input) => {+ const result = await readDraft(input);+ if (input.coreWorkflowVersionId === fixture.coreWorkflowVersionId) {+ readCount++;+ if (readCount === 2) {+ releaseReads();+ }+ await bothRead;+ }+ return result;+ });+ const edits = [+ () =>+ workflowGraphqlRequest(+ 'mutation Edit($input: UpdateCoreWorkflowVersionTriggerInput!) { updateCoreWorkflowVersionTrigger(input: $input) { trigger } }',+ {+ input: {+ coreWorkflowVersionId: fixture.coreWorkflowVersionId,+ trigger: { ...fixture.trigger, name: 'Concurrent trigger edit' },+ },+ },+ ),+ () =>+ workflowGraphqlRequest(+ 'mutation Edit($input: UpdateCoreWorkflowVersionPositionsInput!) { updateCoreWorkflowVersionPositions(input: $input) }',+ {+ input: {+ coreWorkflowVersionId: fixture.coreWorkflowVersionId,+ positions: [+ { id: fixture.steps[0].id, position: { x: 321, y: 654 } },+ ],+ },+ },+ ),+ ];+ const results = await Promise.all(edits.map((edit) => edit()));+ readSpy.mockRestore();+ expect(results.filter((response) => !response.body.errors)).toHaveLength(1);+ const failedIndex = results.findIndex((response) => response.body.errors);+ expect(JSON.stringify(results[failedIndex].body.errors)).toContain(+ 'changed',+ );+ expect((await edits[failedIndex]()).body.errors).toBeUndefined();+ const [core] = await global.testDataSource.query(+ 'SELECT triggers, steps FROM core."workflowVersion" WHERE id = $1',+ [fixture.coreWorkflowVersionId],+ );+ const [mirror] = await global.testDataSource.query(+ `SELECT trigger, steps FROM "${schema}"."workflowVersion" WHERE id = $1`,+ [fixture.workflowVersionId],+ );+ expect(core.triggers[0].name).toBe('Concurrent trigger edit');+ expect(core.steps[0].position).toEqual({ x: 321, y: 654 });+ expect(mirror).toEqual({ trigger: core.triggers[0], steps: core.steps });+ });++ it.each(['rename', 'activate', 'activate-version'] as const)(+ 'allows reconciliation to acquire core locks during a blocked %s',+ async (operation) => {+ const fixture = await createFixture();++ if (operation !== 'rename') {+ await global.testDataSource.query(+ `UPDATE core."workflowVersion" SET status = 'DRAFT' WHERE id = $1`,+ [fixture.coreWorkflowVersionId],+ );+ await global.testDataSource.query(+ `UPDATE "${schema}"."workflowVersion" SET status = 'DRAFT' WHERE id = $1`,+ [fixture.workflowVersionId],+ );+ await global.testDataSource.query(+ `UPDATE core.workflow SET "lastPublishedCoreWorkflowVersionId" = NULL, "lastPublishedVersionId" = NULL WHERE id = $1`,+ [fixture.coreWorkflowId],+ );+ await global.testDataSource.query(+ `UPDATE "${schema}".workflow SET "lastPublishedVersionId" = NULL WHERE id = $1`,+ [fixture.workflowId],+ );+ }++ const transaction = global.testDataSource.createQueryRunner();++ await transaction.connect();+ await transaction.startTransaction();+ await transaction.query(+ `SELECT id FROM "${schema}"."${operation === 'activate-version' ? 'workflowVersion' : 'workflow'}" WHERE id = $1 FOR UPDATE`,+ [+ operation === 'activate-version'+ ? fixture.workflowVersionId+ : fixture.workflowId,+ ],+ );+ const [{ pid }] = await transaction.query(+ 'SELECT pg_backend_pid() AS pid',+ );+ const mutation = workflowGraphqlRequest(+ operation === 'rename'+ ? 'mutation Update($input: UpdateCoreWorkflowInput!) { updateCoreWorkflow(input: $input) { id name } }'+ : 'mutation Activate($id: UUID!) { activateCoreWorkflowVersion(coreWorkflowVersionId: $id) }',+ operation === 'rename'+ ? {+ input: {+ coreWorkflowId: fixture.coreWorkflowId,+ name: 'Concurrent rename',+ },+ }+ : { id: fixture.coreWorkflowVersionId },+ ).then((response) => response);++ try {+ let blocked = false;++ for (let attempt = 0; attempt < 100; attempt++) {+ const [activity] = await global.testDataSource.query(+ `SELECT EXISTS(SELECT 1 FROM pg_stat_activity WHERE $1 = ANY(pg_blocking_pids(pid))) AS blocked`,+ [pid],+ );++ if (activity.blocked) {+ blocked = true;+ break;+ }++ await new Promise((resolve) => setTimeout(resolve, 20));+ }++ expect(blocked).toBe(true);+ await transaction.query(+ 'SELECT id FROM core.workflow WHERE id = $1 FOR UPDATE NOWAIT',+ [fixture.coreWorkflowId],+ );+ await transaction.commitTransaction();+ expect((await mutation).body.errors).toBeUndefined();+ } finally {+ if (transaction.isTransactionActive) {+ await transaction.rollbackTransaction();+ }++ await transaction.release();+ await mutation;+ }+ },+ );++ it('fires a mirrorless database-event workflow from a real record creation', async () => {+ const fixture = await createFixture({+ mirrorless: true,+ triggerType: 'DATABASE_EVENT',+ triggerSettings: { eventName: 'company.created' },+ });+ const response = await workflowGraphqlRequest(+ 'mutation { createCompany(data: { name: "B-Async event" }) { id } }',+ );+ expect(response.body.errors).toBeUndefined();+ const companyId = response.body.data.createCompany.id;+ try {+ for (let attempt = 0; attempt < 100; attempt++) {+ const [run] = await global.testDataSource.query(+ `SELECT id FROM "${schema}"."workflowRun" WHERE "coreWorkflowId" = $1`,+ [fixture.coreWorkflowId],+ );+ if (run) {+ await waitForRun(run.id, 'COMPLETED');+ return;+ }+ await new Promise((resolve) => setTimeout(resolve, 100));+ }+ throw new Error('Database event did not start the core workflow');+ } finally {+ const cleanup = await workflowGraphqlRequest(+ 'mutation Destroy($id: UUID!) { destroyCompany(id: $id) { id } }',+ { id: companyId },+ );+ expect(cleanup.body.errors).toBeUndefined();+ }+ });++ it('dry-runs and idempotently backfills every legacy run status', async () => {+ const fixture = await createFixture();+ const runIds: string[] = [];+ try {+ for (const status of [+ 'NOT_STARTED',+ 'ENQUEUED',+ 'RUNNING',+ 'FAILED',+ 'STOPPING',+ 'STOPPED',+ 'COMPLETED',+ ]) {+ const id = randomUUID();+ runIds.push(id);+ await global.testDataSource.query(+ `INSERT INTO "${schema}"."workflowRun" (id, name, "workflowId", "workflowVersionId", status, position, state) VALUES ($1, 'B-Async migration', $2, $3, $4, 0, '{}')`,+ [id, fixture.workflowId, fixture.workflowVersionId, status],+ );+ }+ await backfill(true);+ for (const id of runIds) {+ expect((await getRun(id)).coreWorkflowVersionId).toBeNull();+ }+ await backfill();+ await backfill();+ for (const id of runIds) {+ expect(await getRun(id)).toMatchObject({+ coreWorkflowId: fixture.coreWorkflowId,+ coreWorkflowVersionId: fixture.coreWorkflowVersionId,+ });+ }+ } finally {+ await global.testDataSource.query(+ `DELETE FROM "${schema}"."workflowRun" WHERE id = ANY($1::uuid[])`,+ [runIds],+ );+ }+ });++ it('rolls back mapping writes when a run has conflicting core ids', async () => {+ const fixture = await createFixture();+ const other = await createFixture({ mirrorless: true });+ const id = randomUUID();+ try {+ await global.testDataSource.query(+ `INSERT INTO "${schema}"."workflowRun" (id, name, "workflowId", "workflowVersionId", "coreWorkflowId", status, position, state) VALUES ($1, 'B-Async conflict', $2, $3, $4, 'ENQUEUED', 0, '{}')`,+ [+ id,+ fixture.workflowId,+ fixture.workflowVersionId,+ other.coreWorkflowId,+ ],+ );+ await expect(backfill()).rejects.toThrow(+ 'Conflicting workflow run core ids',+ );+ const [version] = await global.testDataSource.query(+ 'SELECT "workspaceWorkflowVersionId" FROM core."workflowVersion" WHERE id = $1',+ [fixture.coreWorkflowVersionId],+ );+ expect(version.workspaceWorkflowVersionId).toBe(+ fixture.workflowVersionId,+ );+ expect((await getRun(id)).coreWorkflowVersionId).toBeNull();+ } finally {+ await global.testDataSource.query(+ `DELETE FROM "${schema}"."workflowRun" WHERE id = $1`,+ [id],+ );+ await global.testDataSource.query(+ 'UPDATE core."workflowVersion" SET "workspaceWorkflowVersionId" = $2 WHERE id = $1',+ [fixture.coreWorkflowVersionId, fixture.workflowVersionId],+ );+ }+ });++ it('rejects an unmapped pending run without partially updating its ids', async () => {+ const id = randomUUID();+ try {+ await global.testDataSource.query(+ `INSERT INTO "${schema}"."workflowRun" (id, name, status, position, state) VALUES ($1, 'B-Async unmapped', 'RUNNING', 0, '{}')`,+ [id],+ );+ await expect(backfill()).rejects.toThrow(+ 'Pending workflow runs have no valid core mapping',+ );+ expect((await getRun(id)).coreWorkflowId).toBeNull();+ } finally {+ await global.testDataSource.query(+ `DELETE FROM "${schema}"."workflowRun" WHERE id = $1`,+ [id],+ );+ }+ });++ it.each(['ARCHIVED', 'DRAFT'])(+ 'drops queued versions that are %s',+ async (status) => {+ const fixture = await createFixture({ mirrorless: true });+ await global.testDataSource.query(+ 'UPDATE core."workflowVersion" SET status = $2 WHERE id = $1',+ [fixture.coreWorkflowVersionId, status],+ );+ await (+ await global.workflowTestServices.triggerJob()+ ).handle({+ workspaceId,+ workflowId: fixture.coreWorkflowId,+ coreWorkflowVersionId: fixture.coreWorkflowVersionId,+ payload: {},+ });+ const runs = await global.testDataSource.query(+ `SELECT id FROM "${schema}"."workflowRun" WHERE "coreWorkflowId" = $1`,+ [fixture.coreWorkflowId],+ );+ expect(runs).toHaveLength(0);+ },+ );++ it('uses the queued core version even when the latest published pointer changes', async () => {+ const fixture = await createFixture({ mirrorless: true });+ const latestVersionId = randomUUID();+ await global.testDataSource.query(+ `INSERT INTO core."workflowVersion" (id, "workspaceId", "applicationId", "universalIdentifier", "coreWorkflowId", "workflowId", status, triggers, steps)+ SELECT $2, "workspaceId", "applicationId", $2, "coreWorkflowId", NULL, 'ACTIVE', triggers, '[]'::jsonb FROM core."workflowVersion" WHERE id = $1`,+ [fixture.coreWorkflowVersionId, latestVersionId],+ );+ await global.testDataSource.query(+ 'UPDATE core.workflow SET "lastPublishedCoreWorkflowVersionId" = $2 WHERE id = $1',+ [fixture.coreWorkflowId, latestVersionId],+ );+ await (+ await global.workflowTestServices.triggerJob()+ ).handle({+ workspaceId,+ workflowId: fixture.coreWorkflowId,+ coreWorkflowVersionId: fixture.coreWorkflowVersionId,+ payload: {},+ });+ const [created] = await global.testDataSource.query(+ `SELECT id FROM "${schema}"."workflowRun" WHERE "coreWorkflowId" = $1`,+ [fixture.coreWorkflowId],+ );+ const run = await waitForRun(created.id, 'COMPLETED');+ expect(run.coreWorkflowVersionId).toBe(fixture.coreWorkflowVersionId);+ expect(run.state.flow.steps).toEqual(fixture.steps);+ });++ it('skips unprovisioned workflow tables during upgrades', async () => {+ for (const name of [+ 'RelinkWorkflowVersionsToCoreWorkflowsCommand',+ 'BackfillWorkflowExecutionCoreIdsCommand',+ 'MakeWorkflowRunProjectionRelationsNullableCommand',+ ]) {+ const command =+ getAppProviderByClassName<ProvisionedWorkspaceCommandRunner>(name);++ await expect(+ command.runOnWorkspace({+ workspaceId: randomUUID(),+ options: {},+ dataSource: global.testDataSource,+ index: 0,+ total: 1,+ }),+ ).resolves.toBeUndefined();+ }+ });++ it('provisions a fresh workspace with synchronous parent and version mappings', async () => {+ const services = global.workflowTestServices;+ const freshWorkspaceId = randomUUID();+ const applicationId = randomUUID();+ const freshSchema = getWorkspaceSchemaName(freshWorkspaceId);+ const users =+ services.coreDataSource.getRepository<UserEntity>('UserEntity');+ const user = await users.findOneByOrFail({ id: USER_DATA_SEED_IDS.JANE });+ const workspaces =+ services.coreDataSource.getRepository<WorkspaceEntity>('WorkspaceEntity');+ try {+ const workspace = await services.coreDataSource.transaction(+ async (manager) => {+ const workspace = await manager+ .getRepository<WorkspaceEntity>('WorkspaceEntity')+ .save({+ id: freshWorkspaceId,+ displayName: 'B-Async fresh workspace',+ subdomain: `b-async-${freshWorkspaceId.slice(0, 8)}`,+ inviteHash: randomUUID(),+ activationStatus: WorkspaceActivationStatus.PENDING_CREATION,+ workspaceCustomApplicationId: applicationId,+ });+ const application =+ await services.application.createWorkspaceCustomApplication(+ { workspaceId: freshWorkspaceId, applicationId },+ manager.queryRunner,+ );+ await services.userWorkspace.create(+ {+ userId: user.id,+ workspaceId: freshWorkspaceId,+ isExistingUser: true,+ applicationUniversalIdentifier: application.universalIdentifier,+ locale: user.locale,+ },+ manager.queryRunner,+ );+ return workspace;+ },+ );+ await services.workspace.activateWorkspace(+ {+ ...user,+ createdAt: user.createdAt.toISOString(),+ updatedAt: user.updatedAt.toISOString(),+ deletedAt: user.deletedAt?.toISOString() ?? null,+ },+ workspace,+ );+ const versions = await global.testDataSource.query(+ `SELECT wv.id, wv."coreWorkflowVersionId", cv."workspaceWorkflowVersionId", cv."coreWorkflowId", cw."workspaceWorkflowId", cw."lastPublishedCoreWorkflowVersionId", wv."workflowId"+ FROM "${freshSchema}"."workflowVersion" wv+ LEFT JOIN core."workflowVersion" cv ON cv.id = wv."coreWorkflowVersionId" AND cv."workspaceId" = $1+ LEFT JOIN core.workflow cw ON cw.id = cv."coreWorkflowId" AND cw."workspaceId" = $1`,+ [freshWorkspaceId],+ );+ expect(versions).toHaveLength(2);+ for (const version of versions) {+ expect(version.workspaceWorkflowVersionId).toBe(version.id);+ expect(version.workspaceWorkflowId).toBe(version.workflowId);+ expect(version.lastPublishedCoreWorkflowVersionId).toBe(+ version.coreWorkflowVersionId,+ );+ expect(version.coreWorkflowId).toBeTruthy();+ }+ const relationFields = await global.testDataSource.query(+ `SELECT f.name, f."isNullable" FROM core."fieldMetadata" f JOIN core."objectMetadata" o ON o.id = f."objectMetadataId" WHERE o."workspaceId" = $1 AND o."nameSingular" = 'workflowRun' AND f.name IN ('workflow', 'workflowVersion')`,+ [freshWorkspaceId],+ );+ expect(relationFields).toHaveLength(2);+ expect(+ relationFields.every(+ (field: { isNullable: boolean }) => field.isNullable,+ ),+ ).toBe(true);+ } finally {+ if (await workspaces.existsBy({ id: freshWorkspaceId })) {+ await services.workspace.deleteWorkspace(freshWorkspaceId);+ }+ }+ }, 180_000);+});diff --git a/packages/twenty-server/test/integration/graphql/suites/workflow/workflow-synchronous-parent-creation.integration-spec.ts b/packages/twenty-server/test/integration/graphql/suites/workflow/workflow-synchronous-parent-creation.integration-spec.tsnew file mode 100644index 00000000000..517da9410e6--- /dev/null+++ b/packages/twenty-server/test/integration/graphql/suites/workflow/workflow-synchronous-parent-creation.integration-spec.ts@@ -0,0 +1,66 @@+import { randomUUID } from 'node:crypto';++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';+import { workflowGraphqlRequest } from 'test/integration/graphql/suites/workflow/utils/workflow-graphql-request.util';++const schema = getWorkspaceSchemaName(SEED_APPLE_WORKSPACE_ID);++describe('synchronous workflow parent creation (e2e)', () => {+ it.each(['one', 'many'] as const)(+ 'creates the parent before the initial draft through create %s',+ async (operation) => {+ const name = `Synchronous parent ${randomUUID()}`;+ const response = await workflowGraphqlRequest(+ operation === 'one'+ ? 'mutation Create($name: String!) { createWorkflow(data: { name: $name }) { id } }'+ : 'mutation Create($name: String!) { createWorkflows(data: [{ name: $name }, { name: $name }]) { id } }',+ { name },+ );++ const workflows: { id: string }[] = await global.testDataSource.query(+ `SELECT id FROM "${schema}".workflow WHERE name = $1`,+ [name],+ );++ try {+ expect(response.body.errors).toBeUndefined();+ expect(workflows).toHaveLength(operation === 'one' ? 1 : 2);++ for (const workflow of workflows) {+ const rows = await global.testDataSource.query(+ `SELECT w."coreWorkflowId", v.id AS "workspaceVersionId",+ v."coreWorkflowVersionId", c."workspaceWorkflowId",+ cv."coreWorkflowId" AS "versionParentId",+ cv."workspaceWorkflowVersionId", cv.status+ FROM "${schema}".workflow w+ JOIN "${schema}"."workflowVersion" v ON v."workflowId" = w.id+ LEFT JOIN core.workflow c ON c.id = w."coreWorkflowId"+ LEFT JOIN core."workflowVersion" cv ON cv.id = v."coreWorkflowVersionId"+ WHERE w.id = $1`,+ [workflow.id],+ );++ expect(rows).toHaveLength(1);+ expect(rows[0].coreWorkflowId).toBeTruthy();+ expect(rows[0].coreWorkflowVersionId).toBeTruthy();+ expect(rows[0]).toMatchObject({+ workspaceWorkflowId: workflow.id,+ versionParentId: rows[0].coreWorkflowId,+ workspaceWorkflowVersionId: rows[0].workspaceVersionId,+ status: 'DRAFT',+ });+ }+ } finally {+ for (const workflow of workflows) {+ const destroyed = await workflowGraphqlRequest(+ 'mutation Destroy($id: UUID!) { destroyWorkflow(id: $id) { id } }',+ { id: workflow.id },+ );++ expect(destroyed.body.errors).toBeUndefined();+ }+ }+ },+ );+});diff --git a/packages/twenty-server/test/integration/utils/create-workflow-test-services.ts b/packages/twenty-server/test/integration/utils/create-workflow-test-services.tsnew file mode 100644index 00000000000..b1e39d9fd6c--- /dev/null+++ b/packages/twenty-server/test/integration/utils/create-workflow-test-services.ts@@ -0,0 +1,34 @@+import { getDataSourceToken } from '@nestjs/typeorm';+import { BackfillWorkspaceWorkflowVersionIdCommand } from 'src/database/commands/upgrade-version-command/2-42/2-42-workspace-command-1789652804001-backfill-workspace-workflow-version-id.command';+import { type DataSource } from 'typeorm';+import { WorkspaceService } from 'src/engine/core-modules/workspace/services/workspace.service';+import { ApplicationService } from 'src/engine/core-modules/application/application.service';+import { UserWorkspaceService } from 'src/engine/core-modules/user-workspace/user-workspace.service';+import { FeatureFlagService } from 'src/engine/core-modules/feature-flag/services/feature-flag.service';+import { type INestApplication } from '@nestjs/common';++import { BillingUsageService } from 'src/engine/core-modules/billing/services/billing-usage.service';+import { WorkspaceCacheService } from 'src/engine/workspace-cache/services/workspace-cache.service';+import { BackfillWorkflowExecutionCoreIdsCommand } from 'src/database/commands/upgrade-version-command/2-42/2-42-workspace-command-1789719131001-backfill-workflow-execution-core-ids.command';+import { WorkflowTriggerJob } from 'src/modules/workflow/workflow-trigger/jobs/workflow-trigger.job';+import { RunWorkflowJob } from 'src/modules/workflow/workflow-runner/jobs/run-workflow.job';+import { WorkflowCronTriggerCronJob } from 'src/modules/workflow/workflow-trigger/automated-trigger/crons/jobs/workflow-cron-trigger-cron.job';+import { WorkflowThrottlingWorkspaceService } from 'src/modules/workflow/workflow-runner/workflow-run-queue/workspace-services/workflow-throttling.workspace-service';+import { UpgradeAwareRepositoryState } from 'src/engine/twenty-orm/upgrade-aware/upgrade-aware-repository-state';++export const createWorkflowTestServices = (app: INestApplication) => ({+ billing: app.get(BillingUsageService),+ coreDataSource: app.get<DataSource>(getDataSourceToken()),+ workspace: app.get(WorkspaceService),+ application: app.get(ApplicationService),+ userWorkspace: app.get(UserWorkspaceService),+ flags: app.get(FeatureFlagService),+ workspaceCache: app.get(WorkspaceCacheService),+ upgradeState: UpgradeAwareRepositoryState.getInstance(),+ backfill: app.get(BackfillWorkflowExecutionCoreIdsCommand),+ versionAliasBackfill: app.get(BackfillWorkspaceWorkflowVersionIdCommand),+ triggerJob: () => app.resolve(WorkflowTriggerJob),+ runJob: () => app.resolve(RunWorkflowJob),+ cron: app.get(WorkflowCronTriggerCronJob),+ throttling: app.get(WorkflowThrottlingWorkspaceService),+});diff --git a/packages/twenty-server/test/integration/utils/setup-test.ts b/packages/twenty-server/test/integration/utils/setup-test.tsindex 11b7cb64607..114c517824d 100644--- a/packages/twenty-server/test/integration/utils/setup-test.ts+++ b/packages/twenty-server/test/integration/utils/setup-test.ts@@ -5,6 +5,7 @@ import 'tsconfig-paths/register';import { rawDataSource } from 'src/database/typeorm/raw/raw.datasource';import { createApp } from './create-app';+import { createWorkflowTestServices } from './create-workflow-test-services';export default async (_: unknown, projectConfig: JestConfigWithTsJest) => {// node-fetch rides node:http, which msw patches; native undici fetch@@ -22,5 +23,6 @@ export default async (_: unknown, projectConfig: JestConfigWithTsJest) => {await app.listen(projectConfig.globals.APP_PORT as number);global.app = app;+ global.workflowTestServices = createWorkflowTestServices(app);global.testDataSource = rawDataSource;};