Skip to content

The open alternative to Salesforce, designed for AI.

feat(workflow): core-id native workflow API — reads and writes (#26068)

Thomas Trompettea64ade722092
diff --git a/packages/twenty-front/src/generated/graphql.ts b/packages/twenty-front/src/generated/graphql.ts
index ee1cf2a8b81..34751aac565 100644
--- a/packages/twenty-front/src/generated/graphql.ts
+++ b/packages/twenty-front/src/generated/graphql.ts
@@ -35,6 +35,8 @@ export enum CallRecordingStatus {
}
export type ComputeStepOutputSchemaInput = {
+ /** Core workflow version ID */
+ coreWorkflowVersionId?: InputMaybe<Scalars['UUID']['input']>;
/** Step JSON format */
step: Scalars['JSON']['input'];
/** Workflow version ID */
@@ -143,7 +145,7 @@ export type CoreWorkflowVersionDto = {
steps?: Maybe<Scalars['JSON']['output']>;
trigger?: Maybe<Scalars['JSON']['output']>;
updatedAt: Scalars['String']['output'];
- workspaceWorkflowId: Scalars['UUID']['output'];
+ workspaceWorkflowId?: Maybe<Scalars['UUID']['output']>;
workspaceWorkflowVersionId?: Maybe<Scalars['UUID']['output']>;
};
@@ -158,6 +160,43 @@ export type CreateCoreWorkflowInput = {
name?: InputMaybe<Scalars['String']['input']>;
};
+export type CreateCoreWorkflowVersionEdgeInput = {
+ /** Core workflow version ID */
+ coreWorkflowVersionId: Scalars['UUID']['input'];
+ /** Workflow version source step ID */
+ source: Scalars['String']['input'];
+ /** Workflow version source step connection options */
+ sourceConnectionOptions?: InputMaybe<Scalars['JSON']['input']>;
+ /** Workflow version target step ID */
+ target: Scalars['String']['input'];
+};
+
+export type CreateCoreWorkflowVersionStepInput = {
+ /** Core workflow version ID */
+ coreWorkflowVersionId: Scalars['UUID']['input'];
+ /** Default settings for the step */
+ defaultSettings?: InputMaybe<Scalars['JSON']['input']>;
+ /** Step ID */
+ id?: InputMaybe<Scalars['String']['input']>;
+ /** Next step ID */
+ nextStepId?: InputMaybe<Scalars['UUID']['input']>;
+ /** Parent step connection options */
+ parentStepConnectionOptions?: InputMaybe<Scalars['JSON']['input']>;
+ /** Parent step ID */
+ parentStepId?: InputMaybe<Scalars['String']['input']>;
+ /** Step position */
+ position?: InputMaybe<WorkflowStepPositionInput>;
+ /** New step type */
+ stepType: Scalars['String']['input'];
+};
+
+export type CreateDraftFromCoreWorkflowVersionInput = {
+ /** Core workflow ID */
+ coreWorkflowId: Scalars['UUID']['input'];
+ /** Core workflow version ID to copy */
+ coreWorkflowVersionIdToCopy: Scalars['UUID']['input'];
+};
+
export type CreateDraftFromWorkflowVersionInput = {
/** Workflow ID */
workflowId: Scalars['UUID']['input'];
@@ -206,6 +245,24 @@ export type DateTimeFilter = {
neq?: InputMaybe<Scalars['DateTime']['input']>;
};
+export type DeleteCoreWorkflowVersionEdgeInput = {
+ /** Core workflow version ID */
+ coreWorkflowVersionId: Scalars['UUID']['input'];
+ /** Workflow version source step ID */
+ source: Scalars['String']['input'];
+ /** Workflow version source step connection options */
+ sourceConnectionOptions?: InputMaybe<Scalars['JSON']['input']>;
+ /** Workflow version target step ID */
+ target: Scalars['String']['input'];
+};
+
+export type DeleteCoreWorkflowVersionStepInput = {
+ /** Core workflow version ID */
+ coreWorkflowVersionId: Scalars['UUID']['input'];
+ /** Step to delete ID */
+ stepId: Scalars['String']['input'];
+};
+
export type DeleteCoreWorkflowsInput = {
coreWorkflowIds: Array<Scalars['UUID']['input']>;
};
@@ -224,7 +281,8 @@ export type DeletedCoreWorkflowDto = {
};
export type DiscardCoreWorkflowDraftInput = {
- workspaceWorkflowVersionId: Scalars['UUID']['input'];
+ coreWorkflowVersionId?: InputMaybe<Scalars['UUID']['input']>;
+ workspaceWorkflowVersionId?: InputMaybe<Scalars['UUID']['input']>;
};
export type DpaAgreement = {
@@ -281,6 +339,19 @@ export enum DpaRegion {
US = 'US'
}
+export type DuplicateCoreWorkflowInput = {
+ /** Core workflow ID to duplicate */
+ coreWorkflowIdToDuplicate: Scalars['UUID']['input'];
+ /** Core workflow version ID to copy */
+ coreWorkflowVersionIdToCopy: Scalars['UUID']['input'];
+};
+
+export type DuplicateCoreWorkflowVersionStepInput = {
+ /** Core workflow version ID */
+ coreWorkflowVersionId: Scalars['UUID']['input'];
+ stepId: Scalars['String']['input'];
+};
+
export type DuplicateWorkflowInput = {
/** Workflow ID to duplicate */
workflowIdToDuplicate: Scalars['UUID']['input'];
@@ -331,35 +402,55 @@ export enum MessageChannelVisibility {
export type Mutation = {
__typename?: 'Mutation';
+ activateCoreWorkflowVersion: Scalars['Boolean']['output'];
activateWorkflowVersion: Scalars['Boolean']['output'];
computeStepOutputSchema: Scalars['JSON']['output'];
createCoreWorkflow: CoreWorkflowDto;
+ createCoreWorkflowVersionEdge: WorkflowVersionStepChanges;
+ createCoreWorkflowVersionStep: WorkflowVersionStepChanges;
+ createDraftFromCoreWorkflowVersion: CoreWorkflowVersionDto;
createDraftFromWorkflowVersion: WorkflowVersionDto;
createWorkflowVersionEdge: WorkflowVersionStepChanges;
createWorkflowVersionStep: WorkflowVersionStepChanges;
+ deactivateCoreWorkflowVersion: Scalars['Boolean']['output'];
deactivateWorkflowVersion: Scalars['Boolean']['output'];
+ deleteCoreWorkflowVersionEdge: WorkflowVersionStepChanges;
+ deleteCoreWorkflowVersionStep: WorkflowVersionStepChanges;
deleteCoreWorkflows: Array<DeletedCoreWorkflowDto>;
deleteWorkflowVersionEdge: WorkflowVersionStepChanges;
deleteWorkflowVersionStep: WorkflowVersionStepChanges;
discardCoreWorkflowDraft?: Maybe<CoreWorkflowDto>;
dismissMaintenanceModeBanner: Scalars['Boolean']['output'];
dismissReconnectAccountBanner: Scalars['Boolean']['output'];
+ duplicateCoreWorkflow: CoreWorkflowDto;
+ duplicateCoreWorkflowVersionStep: WorkflowVersionStepChanges;
duplicateWorkflow: WorkflowVersionDto;
duplicateWorkflowVersionStep: WorkflowVersionStepChanges;
generateSignedDpa: GenerateSignedDpaResult;
retryWorkflowRun: WorkflowRun;
+ runCoreWorkflowVersion: RunWorkflowVersion;
runWorkflowVersion: RunWorkflowVersion;
stopWorkflowRun: WorkflowRun;
submitFormStep: Scalars['Boolean']['output'];
testHttpRequest: TestHttpRequest;
+ updateCoreWorkflow?: Maybe<CoreWorkflowDto>;
+ updateCoreWorkflowVersionPositions: Scalars['Boolean']['output'];
+ updateCoreWorkflowVersionStep: WorkflowAction;
+ updateCoreWorkflowVersionTrigger: WorkflowVersionTrigger;
updateWorkflowRunStep: WorkflowAction;
updateWorkflowVersionPositions: Scalars['Boolean']['output'];
updateWorkflowVersionStep: WorkflowAction;
updateWorkflowVersionTrigger: WorkflowVersionTrigger;
+ validateCoreWorkflowVersion: Scalars['Boolean']['output'];
validateWorkflowVersion: Scalars['Boolean']['output'];
};
+export type MutationActivateCoreWorkflowVersionArgs = {
+ coreWorkflowVersionId: Scalars['UUID']['input'];
+};
+
+
export type MutationActivateWorkflowVersionArgs = {
workflowVersionId: Scalars['UUID']['input'];
};
@@ -375,6 +466,21 @@ export type MutationCreateCoreWorkflowArgs = {
};
+export type MutationCreateCoreWorkflowVersionEdgeArgs = {
+ input: CreateCoreWorkflowVersionEdgeInput;
+};
+
+
+export type MutationCreateCoreWorkflowVersionStepArgs = {
+ input: CreateCoreWorkflowVersionStepInput;
+};
+
+
+export type MutationCreateDraftFromCoreWorkflowVersionArgs = {
+ input: CreateDraftFromCoreWorkflowVersionInput;
+};
+
+
export type MutationCreateDraftFromWorkflowVersionArgs = {
input: CreateDraftFromWorkflowVersionInput;
};
@@ -390,11 +496,26 @@ export type MutationCreateWorkflowVersionStepArgs = {
};
+export type MutationDeactivateCoreWorkflowVersionArgs = {
+ coreWorkflowVersionId: Scalars['UUID']['input'];
+};
+
+
export type MutationDeactivateWorkflowVersionArgs = {
workflowVersionId: Scalars['UUID']['input'];
};
+export type MutationDeleteCoreWorkflowVersionEdgeArgs = {
+ input: DeleteCoreWorkflowVersionEdgeInput;
+};
+
+
+export type MutationDeleteCoreWorkflowVersionStepArgs = {
+ input: DeleteCoreWorkflowVersionStepInput;
+};
+
+
export type MutationDeleteCoreWorkflowsArgs = {
input: DeleteCoreWorkflowsInput;
};
@@ -420,6 +541,16 @@ export type MutationDismissReconnectAccountBannerArgs = {
};
+export type MutationDuplicateCoreWorkflowArgs = {
+ input: DuplicateCoreWorkflowInput;
+};
+
+
+export type MutationDuplicateCoreWorkflowVersionStepArgs = {
+ input: DuplicateCoreWorkflowVersionStepInput;
+};
+
+
export type MutationDuplicateWorkflowArgs = {
input: DuplicateWorkflowInput;
};
@@ -440,6 +571,11 @@ export type MutationRetryWorkflowRunArgs = {
};
+export type MutationRunCoreWorkflowVersionArgs = {
+ input: RunCoreWorkflowVersionInput;
+};
+
+
export type MutationRunWorkflowVersionArgs = {
input: RunWorkflowVersionInput;
};
@@ -460,6 +596,26 @@ export type MutationTestHttpRequestArgs = {
};
+export type MutationUpdateCoreWorkflowArgs = {
+ input: UpdateCoreWorkflowInput;
+};
+
+
+export type MutationUpdateCoreWorkflowVersionPositionsArgs = {
+ input: UpdateCoreWorkflowVersionPositionsInput;
+};
+
+
+export type MutationUpdateCoreWorkflowVersionStepArgs = {
+ input: UpdateCoreWorkflowVersionStepInput;
+};
+
+
+export type MutationUpdateCoreWorkflowVersionTriggerArgs = {
+ input: UpdateCoreWorkflowVersionTriggerInput;
+};
+
+
export type MutationUpdateWorkflowRunStepArgs = {
input: UpdateWorkflowRunStepInput;
};
@@ -480,6 +636,11 @@ export type MutationUpdateWorkflowVersionTriggerArgs = {
};
+export type MutationValidateCoreWorkflowVersionArgs = {
+ coreWorkflowVersionId: Scalars['UUID']['input'];
+};
+
+
export type MutationValidateWorkflowVersionArgs = {
workflowVersionId: Scalars['UUID']['input'];
};
@@ -497,8 +658,11 @@ export type ObjectRecordFilterInput = {
export type Query = {
__typename?: 'Query';
coreWorkflow?: Maybe<CoreWorkflowDto>;
+ coreWorkflowById?: Maybe<CoreWorkflowDto>;
coreWorkflowVersion?: Maybe<CoreWorkflowVersionDto>;
+ coreWorkflowVersionById?: Maybe<CoreWorkflowVersionDto>;
coreWorkflowVersions: Array<CoreWorkflowVersionDto>;
+ coreWorkflowVersionsByCoreWorkflowId: Array<CoreWorkflowVersionDto>;
coreWorkflows: CoreWorkflowConnection;
dpaAgreements: Array<DpaAgreement>;
dpaPreview: DpaDocument;
@@ -528,16 +692,31 @@ export type QueryCoreWorkflowArgs = {
};
+export type QueryCoreWorkflowByIdArgs = {
+ coreWorkflowId: Scalars['UUID']['input'];
+};
+
+
export type QueryCoreWorkflowVersionArgs = {
workspaceWorkflowVersionId: Scalars['UUID']['input'];
};
+export type QueryCoreWorkflowVersionByIdArgs = {
+ coreWorkflowVersionId: Scalars['UUID']['input'];
+};
+
+
export type QueryCoreWorkflowVersionsArgs = {
workspaceWorkflowId: Scalars['UUID']['input'];
};
+export type QueryCoreWorkflowVersionsByCoreWorkflowIdArgs = {
+ coreWorkflowId: Scalars['UUID']['input'];
+};
+
+
export type QueryCoreWorkflowsArgs = {
after?: InputMaybe<Scalars['String']['input']>;
filter?: InputMaybe<CoreWorkflowFilterInput>;
@@ -624,6 +803,15 @@ export type QueryWorkflowVersionContentArgs = {
workflowVersionId: Scalars['UUID']['input'];
};
+export type RunCoreWorkflowVersionInput = {
+ /** Core workflow version ID */
+ coreWorkflowVersionId: Scalars['UUID']['input'];
+ /** Execution result in JSON format */
+ payload?: InputMaybe<Scalars['JSON']['input']>;
+ /** Workflow run ID */
+ workflowRunId?: InputMaybe<Scalars['UUID']['input']>;
+};
+
export type RunWorkflowVersion = {
__typename?: 'RunWorkflowVersion';
workflowRunId: Scalars['UUID']['output'];
@@ -791,6 +979,32 @@ export type UuidFilter = {
neq?: InputMaybe<Scalars['UUID']['input']>;
};
+export type UpdateCoreWorkflowInput = {
+ coreWorkflowId: Scalars['UUID']['input'];
+ name: Scalars['String']['input'];
+};
+
+export type UpdateCoreWorkflowVersionPositionsInput = {
+ /** Core workflow version ID */
+ coreWorkflowVersionId: Scalars['UUID']['input'];
+ /** Workflow version updated positions */
+ positions: Array<WorkflowStepPositionUpdateInput>;
+};
+
+export type UpdateCoreWorkflowVersionStepInput = {
+ /** Core workflow version ID */
+ coreWorkflowVersionId: Scalars['UUID']['input'];
+ /** Step to update in JSON format */
+ step: Scalars['JSON']['input'];
+};
+
+export type UpdateCoreWorkflowVersionTriggerInput = {
+ /** Core workflow version ID */
+ coreWorkflowVersionId: Scalars['UUID']['input'];
+ /** Trigger to update in JSON format */
+ trigger: Scalars['JSON']['input'];
+};
+
export type UpdateWorkflowRunStepInput = {
/** Step to update in JSON format */
step: Scalars['JSON']['input'];
@@ -1007,14 +1221,14 @@ export type GetCoreWorkflowVersionQueryVariables = Exact<{
}>;
-export type GetCoreWorkflowVersionQuery = { __typename?: 'Query', coreWorkflowVersion?: { __typename?: 'CoreWorkflowVersionDTO', id: any, label: string, status: CoreWorkflowVersionStatus, workspaceWorkflowVersionId?: any | null, workspaceWorkflowId: any, trigger?: any | null, steps?: any | null, createdAt: string, updatedAt: string } | null };
+export type GetCoreWorkflowVersionQuery = { __typename?: 'Query', coreWorkflowVersion?: { __typename?: 'CoreWorkflowVersionDTO', id: any, label: string, status: CoreWorkflowVersionStatus, workspaceWorkflowVersionId?: any | null, workspaceWorkflowId?: any | null, trigger?: any | null, steps?: any | null, createdAt: string, updatedAt: string } | null };
export type GetCoreWorkflowVersionsQueryVariables = Exact<{
workspaceWorkflowId: Scalars['UUID']['input'];
}>;
-export type GetCoreWorkflowVersionsQuery = { __typename?: 'Query', coreWorkflowVersions: Array<{ __typename?: 'CoreWorkflowVersionDTO', id: any, label: string, status: CoreWorkflowVersionStatus, workspaceWorkflowVersionId?: any | null, workspaceWorkflowId: any, createdAt: string, updatedAt: string }> };
+export type GetCoreWorkflowVersionsQuery = { __typename?: 'Query', coreWorkflowVersions: Array<{ __typename?: 'CoreWorkflowVersionDTO', id: any, label: string, status: CoreWorkflowVersionStatus, workspaceWorkflowVersionId?: any | null, workspaceWorkflowId?: any | null, createdAt: string, updatedAt: string }> };
export type WorkflowDiffFragmentFragment = { __typename?: 'WorkflowVersionStepChanges', triggerDiff?: any | null, stepsDiff?: any | null };
diff --git a/packages/twenty-front/src/modules/object-core/workflows/versions/components/CoreWorkflowVersionCard.tsx b/packages/twenty-front/src/modules/object-core/workflows/versions/components/CoreWorkflowVersionCard.tsx
index dac3e26b9cb..db3b60c3309 100644
--- a/packages/twenty-front/src/modules/object-core/workflows/versions/components/CoreWorkflowVersionCard.tsx
+++ b/packages/twenty-front/src/modules/object-core/workflows/versions/components/CoreWorkflowVersionCard.tsx
@@ -22,7 +22,10 @@ export const CoreWorkflowVersionCard = ({
workspaceWorkflowVersionId,
);
- if (!isDefined(coreWorkflowVersion)) {
+ if (
+ !isDefined(coreWorkflowVersion) ||
+ !isDefined(coreWorkflowVersion.workspaceWorkflowId)
+ ) {
return null;
}
diff --git a/packages/twenty-front/src/modules/object-core/workflows/versions/components/SidePanelCoreWorkflowVersionPage.tsx b/packages/twenty-front/src/modules/object-core/workflows/versions/components/SidePanelCoreWorkflowVersionPage.tsx
index f9d131b69dc..13b47bbce23 100644
--- a/packages/twenty-front/src/modules/object-core/workflows/versions/components/SidePanelCoreWorkflowVersionPage.tsx
+++ b/packages/twenty-front/src/modules/object-core/workflows/versions/components/SidePanelCoreWorkflowVersionPage.tsx
@@ -47,10 +47,12 @@ export const SidePanelCoreWorkflowVersionPage = () => {
<StyledActions>
<Tag color={tagProps.color}>{t(tagProps.label)}</Tag>
<StyledSpacer />
- <CoreWorkflowVersionRestoreButton
- workflowId={coreWorkflowVersion.workspaceWorkflowId}
- workspaceWorkflowVersionId={workspaceWorkflowVersionId}
- />
+ {isDefined(coreWorkflowVersion.workspaceWorkflowId) && (
+ <CoreWorkflowVersionRestoreButton
+ workflowId={coreWorkflowVersion.workspaceWorkflowId}
+ workspaceWorkflowVersionId={workspaceWorkflowVersionId}
+ />
+ )}
</StyledActions>
<CoreWorkflowVersionCard
workspaceWorkflowVersionId={workspaceWorkflowVersionId}
diff --git a/packages/twenty-server/src/database/commands/upgrade-version-command/2-42/2-42-instance-command-fast-1789652804000-add-workspace-workflow-version-id-to-workflow-version.ts b/packages/twenty-server/src/database/commands/upgrade-version-command/2-42/2-42-instance-command-fast-1789652804000-add-workspace-workflow-version-id-to-workflow-version.ts
new file mode 100644
index 00000000000..e1b8fb73bca
--- /dev/null
+++ b/packages/twenty-server/src/database/commands/upgrade-version-command/2-42/2-42-instance-command-fast-1789652804000-add-workspace-workflow-version-id-to-workflow-version.ts
@@ -0,0 +1,27 @@
+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', 1789652804000)
+export class AddWorkspaceWorkflowVersionIdToWorkflowVersionFastInstanceCommand
+ implements FastInstanceCommand
+{
+ public async up(queryRunner: QueryRunner): Promise<void> {
+ await queryRunner.query(
+ `ALTER TABLE "core"."workflowVersion" ADD COLUMN IF NOT EXISTS "workspaceWorkflowVersionId" uuid`,
+ );
+ await queryRunner.query(
+ `CREATE INDEX IF NOT EXISTS "IDX_WORKFLOW_VERSION_WORKSPACE_WORKFLOW_VERSION_ID" ON "core"."workflowVersion" ("workspaceId", "workspaceWorkflowVersionId")`,
+ );
+ }
+
+ public async down(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" DROP COLUMN IF EXISTS "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.ts
index 4c50ace3a6b..01581abde25 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,3 +1,4 @@
+import { BackfillWorkspaceWorkflowVersionIdCommand } from 'src/database/commands/upgrade-version-command/2-42/2-42-workspace-command-1789652804001-backfill-workspace-workflow-version-id.command';
import { Module } from '@nestjs/common';
import { WorkspaceIteratorModule } from 'src/database/commands/command-runners/workspace-iterator.module';
@@ -19,6 +20,7 @@ import { WorkspaceSchemaMigrationRunnerActionHandlersModule } from 'src/engine/w
providers: [
UnpinCreationCommandsOnRecordSelectionCommand,
RelinkWorkflowVersionsToCoreWorkflowsCommand,
+ BackfillWorkspaceWorkflowVersionIdCommand,
],
exports: [RelinkWorkflowVersionsToCoreWorkflowsCommand],
})
diff --git a/packages/twenty-server/src/database/commands/upgrade-version-command/2-42/2-42-workspace-command-1789652804001-backfill-workspace-workflow-version-id.command.ts b/packages/twenty-server/src/database/commands/upgrade-version-command/2-42/2-42-workspace-command-1789652804001-backfill-workspace-workflow-version-id.command.ts
new file mode 100644
index 00000000000..2676fe11042
--- /dev/null
+++ b/packages/twenty-server/src/database/commands/upgrade-version-command/2-42/2-42-workspace-command-1789652804001-backfill-workspace-workflow-version-id.command.ts
@@ -0,0 +1,102 @@
+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';
+
+@RegisteredWorkspaceCommand('2.42.0', 1789652804001)
+@Command({
+ name: 'upgrade:2-42:backfill-workspace-workflow-version-id',
+ description:
+ 'Backfill workspaceWorkflowVersionId on core workflow versions from the workspace mirror',
+})
+export class BackfillWorkspaceWorkflowVersionIdCommand extends ProvisionedWorkspaceCommandRunner {
+ constructor(
+ protected readonly workspaceIteratorService: WorkspaceIteratorService,
+ ) {
+ super(workspaceIteratorService);
+ }
+
+ override async runOnWorkspace({
+ workspaceId,
+ options,
+ dataSource,
+ }: RunOnWorkspaceArgs): Promise<void> {
+ if (!isDefined(dataSource)) {
+ this.logger.warn(
+ `No data source for workspace ${workspaceId}, skipping backfill`,
+ );
+
+ return;
+ }
+
+ const schema = getWorkspaceSchemaName(workspaceId);
+ const queryRunner = dataSource.createQueryRunner();
+
+ await queryRunner.connect();
+
+ try {
+ if (!(await this.hasCoreWorkflowVersionIdColumn(queryRunner, schema))) {
+ this.logger.warn(
+ `workflowVersion.coreWorkflowVersionId missing for workspace ${workspaceId}, skipping backfill`,
+ );
+
+ return;
+ }
+
+ const predicate = `
+ FROM "${schema}"."workflowVersion" wv
+ WHERE wv."coreWorkflowVersionId" = cv."id"
+ AND wv."deletedAt" IS NULL
+ AND cv."workspaceId" = $1
+ AND cv."workspaceWorkflowVersionId" IS DISTINCT FROM wv."id"`;
+
+ if (options.dryRun ?? false) {
+ const [{ count }] = await queryRunner.query(
+ `SELECT count(*)::int AS count FROM core."workflowVersion" cv WHERE EXISTS (SELECT 1 ${predicate})`,
+ [workspaceId],
+ );
+
+ this.logger.log(
+ `[DRY RUN] ${count} core workflow version(s) would get their workspaceWorkflowVersionId in workspace ${workspaceId}`,
+ );
+
+ return;
+ }
+
+ const result = await queryRunner.query(
+ `UPDATE core."workflowVersion" cv
+ SET "workspaceWorkflowVersionId" = wv."id"
+ ${predicate}`,
+ [workspaceId],
+ );
+
+ this.logger.log(
+ `Backfilled workspaceWorkflowVersionId on ${result[1] ?? 0} core workflow version(s) in workspace ${workspaceId}`,
+ );
+ } finally {
+ await queryRunner.release();
+ }
+ }
+
+ private async hasCoreWorkflowVersionIdColumn(
+ queryRunner: QueryRunner,
+ schema: string,
+ ): Promise<boolean> {
+ const rows = await queryRunner.query(
+ `SELECT 1
+ FROM information_schema.columns
+ WHERE table_schema = $1
+ AND table_name = 'workflowVersion'
+ AND column_name = 'coreWorkflowVersionId'
+ LIMIT 1`,
+ [schema],
+ );
+
+ return rows.length > 0;
+ }
+}
diff --git a/packages/twenty-server/src/database/commands/upgrade-version-command/2-42/add-workspace-workflow-version-id-to-workflow-version-upgrade-command-name.constant.ts b/packages/twenty-server/src/database/commands/upgrade-version-command/2-42/add-workspace-workflow-version-id-to-workflow-version-upgrade-command-name.constant.ts
new file mode 100644
index 00000000000..a3ac9bc1683
--- /dev/null
+++ b/packages/twenty-server/src/database/commands/upgrade-version-command/2-42/add-workspace-workflow-version-id-to-workflow-version-upgrade-command-name.constant.ts
@@ -0,0 +1,2 @@
+export const ADD_WORKSPACE_WORKFLOW_VERSION_ID_TO_WORKFLOW_VERSION_UPGRADE_COMMAND_NAME =
+ '2.42.0_AddWorkspaceWorkflowVersionIdToWorkflowVersionFastInstanceCommand_1789652804000';
diff --git a/packages/twenty-server/src/database/commands/upgrade-version-command/instance-commands.constant.ts b/packages/twenty-server/src/database/commands/upgrade-version-command/instance-commands.constant.ts
index 7878212344e..10ae2daee28 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
@@ -190,6 +190,7 @@ import { AddIsSystemToSkillFastInstanceCommand } from 'src/database/commands/upg
import { MigrateCanvasTabsToVerticalListSlowInstanceCommand } from 'src/database/commands/upgrade-version-command/2-40/2-40-instance-command-slow-1789139070588-migrate-canvas-tabs-to-vertical-list';
import { AddWorkspaceWorkflowIdToWorkflowFastInstanceCommand } from 'src/database/commands/upgrade-version-command/2-41/2-41-instance-command-fast-1789350000001-add-workspace-workflow-id-to-workflow';
import { AddCoreVersionPointersFastInstanceCommand } from 'src/database/commands/upgrade-version-command/2-41/2-41-instance-command-fast-1789370101008-add-core-version-pointers';
+import { AddWorkspaceWorkflowVersionIdToWorkflowVersionFastInstanceCommand } from 'src/database/commands/upgrade-version-command/2-42/2-42-instance-command-fast-1789652804000-add-workspace-workflow-version-id-to-workflow-version';
import { 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';
@@ -385,6 +386,7 @@ export const INSTANCE_COMMANDS = [
MigrateCanvasTabsToVerticalListSlowInstanceCommand,
AddWorkspaceWorkflowIdToWorkflowFastInstanceCommand,
AddCoreVersionPointersFastInstanceCommand,
+ AddWorkspaceWorkflowVersionIdToWorkflowVersionFastInstanceCommand,
AddReadabilityParentFieldsToObjectMetadataFastInstanceCommand,
AddAppMessageChannelTypeFastInstanceCommand,
AddAppMessageChannelUniqueHandleFastInstanceCommand,
diff --git a/packages/twenty-server/src/engine/core-modules/workflow/dtos/compute-step-output-schema.input.ts b/packages/twenty-server/src/engine/core-modules/workflow/dtos/compute-step-output-schema.input.ts
index 6cc7d77c030..d8c916c19bb 100644
--- a/packages/twenty-server/src/engine/core-modules/workflow/dtos/compute-step-output-schema.input.ts
+++ b/packages/twenty-server/src/engine/core-modules/workflow/dtos/compute-step-output-schema.input.ts
@@ -19,4 +19,10 @@ export class ComputeStepOutputSchemaInput {
nullable: true,
})
workflowVersionId?: string;
+
+ @Field(() => UUIDScalarType, {
+ description: 'Core workflow version ID',
+ nullable: true,
+ })
+ coreWorkflowVersionId?: string;
}
diff --git a/packages/twenty-server/src/engine/core-modules/workflow/dtos/core-workflow-by-id.input.ts b/packages/twenty-server/src/engine/core-modules/workflow/dtos/core-workflow-by-id.input.ts
new file mode 100644
index 00000000000..b9e36dbbc76
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/workflow/dtos/core-workflow-by-id.input.ts
@@ -0,0 +1,12 @@
+import { ArgsType, Field } from '@nestjs/graphql';
+
+import { IsUUID } from 'class-validator';
+
+import { UUIDScalarType } from 'src/engine/api/graphql/workspace-schema-builder/graphql-types/scalars';
+
+@ArgsType()
+export class CoreWorkflowByIdArgs {
+ @Field(() => UUIDScalarType)
+ @IsUUID()
+ coreWorkflowId: string;
+}
diff --git a/packages/twenty-server/src/engine/core-modules/workflow/dtos/core-workflow-version-by-id.input.ts b/packages/twenty-server/src/engine/core-modules/workflow/dtos/core-workflow-version-by-id.input.ts
new file mode 100644
index 00000000000..281bb7a94cc
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/workflow/dtos/core-workflow-version-by-id.input.ts
@@ -0,0 +1,12 @@
+import { ArgsType, Field } from '@nestjs/graphql';
+
+import { IsUUID } from 'class-validator';
+
+import { UUIDScalarType } from 'src/engine/api/graphql/workspace-schema-builder/graphql-types/scalars';
+
+@ArgsType()
+export class CoreWorkflowVersionByIdArgs {
+ @Field(() => UUIDScalarType)
+ @IsUUID()
+ coreWorkflowVersionId: string;
+}
diff --git a/packages/twenty-server/src/engine/core-modules/workflow/dtos/core-workflow-version.dto.ts b/packages/twenty-server/src/engine/core-modules/workflow/dtos/core-workflow-version.dto.ts
index 590524b005e..f89fc5c7c4a 100644
--- a/packages/twenty-server/src/engine/core-modules/workflow/dtos/core-workflow-version.dto.ts
+++ b/packages/twenty-server/src/engine/core-modules/workflow/dtos/core-workflow-version.dto.ts
@@ -25,8 +25,8 @@ export class CoreWorkflowVersionDTO {
@Field(() => UUIDScalarType, { nullable: true })
workspaceWorkflowVersionId: string | null;
- @Field(() => UUIDScalarType)
- workspaceWorkflowId: string;
+ @Field(() => UUIDScalarType, { nullable: true })
+ workspaceWorkflowId: string | null;
@Field(() => GraphQLJSON, { nullable: true })
trigger: WorkflowTrigger | null;
diff --git a/packages/twenty-server/src/engine/core-modules/workflow/dtos/core-workflow-versions-by-core-workflow-id.input.ts b/packages/twenty-server/src/engine/core-modules/workflow/dtos/core-workflow-versions-by-core-workflow-id.input.ts
new file mode 100644
index 00000000000..b5a42c73931
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/workflow/dtos/core-workflow-versions-by-core-workflow-id.input.ts
@@ -0,0 +1,12 @@
+import { ArgsType, Field } from '@nestjs/graphql';
+
+import { IsUUID } from 'class-validator';
+
+import { UUIDScalarType } from 'src/engine/api/graphql/workspace-schema-builder/graphql-types/scalars';
+
+@ArgsType()
+export class CoreWorkflowVersionsByCoreWorkflowIdArgs {
+ @Field(() => UUIDScalarType)
+ @IsUUID()
+ coreWorkflowId: string;
+}
diff --git a/packages/twenty-server/src/engine/core-modules/workflow/dtos/create-core-workflow-version-edge.input.ts b/packages/twenty-server/src/engine/core-modules/workflow/dtos/create-core-workflow-version-edge.input.ts
new file mode 100644
index 00000000000..30c715a3a15
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/workflow/dtos/create-core-workflow-version-edge.input.ts
@@ -0,0 +1,19 @@
+import { Field, InputType, OmitType } from '@nestjs/graphql';
+
+import { IsUUID } from 'class-validator';
+
+import { UUIDScalarType } from 'src/engine/api/graphql/workspace-schema-builder/graphql-types/scalars';
+import { CreateWorkflowVersionEdgeInput } from 'src/engine/core-modules/workflow/dtos/create-workflow-version-edge.input';
+
+@InputType()
+export class CreateCoreWorkflowVersionEdgeInput extends OmitType(
+ CreateWorkflowVersionEdgeInput,
+ ['workflowVersionId'] as const,
+) {
+ @Field(() => UUIDScalarType, {
+ description: 'Core workflow version ID',
+ nullable: false,
+ })
+ @IsUUID()
+ coreWorkflowVersionId: string;
+}
diff --git a/packages/twenty-server/src/engine/core-modules/workflow/dtos/create-core-workflow-version-step.input.ts b/packages/twenty-server/src/engine/core-modules/workflow/dtos/create-core-workflow-version-step.input.ts
new file mode 100644
index 00000000000..20d961f857c
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/workflow/dtos/create-core-workflow-version-step.input.ts
@@ -0,0 +1,19 @@
+import { Field, InputType, OmitType } from '@nestjs/graphql';
+
+import { IsUUID } from 'class-validator';
+
+import { UUIDScalarType } from 'src/engine/api/graphql/workspace-schema-builder/graphql-types/scalars';
+import { CreateWorkflowVersionStepInput } from 'src/engine/core-modules/workflow/dtos/create-workflow-version-step.input';
+
+@InputType()
+export class CreateCoreWorkflowVersionStepInput extends OmitType(
+ CreateWorkflowVersionStepInput,
+ ['workflowVersionId'] as const,
+) {
+ @Field(() => UUIDScalarType, {
+ description: 'Core workflow version ID',
+ nullable: false,
+ })
+ @IsUUID()
+ coreWorkflowVersionId: string;
+}
diff --git a/packages/twenty-server/src/engine/core-modules/workflow/dtos/create-draft-from-core-workflow-version.input.ts b/packages/twenty-server/src/engine/core-modules/workflow/dtos/create-draft-from-core-workflow-version.input.ts
new file mode 100644
index 00000000000..d47172df1e7
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/workflow/dtos/create-draft-from-core-workflow-version.input.ts
@@ -0,0 +1,22 @@
+import { Field, InputType } from '@nestjs/graphql';
+
+import { IsUUID } from 'class-validator';
+
+import { UUIDScalarType } from 'src/engine/api/graphql/workspace-schema-builder/graphql-types/scalars';
+
+@InputType()
+export class CreateDraftFromCoreWorkflowVersionInput {
+ @Field(() => UUIDScalarType, {
+ description: 'Core workflow ID',
+ nullable: false,
+ })
+ @IsUUID()
+ coreWorkflowId: string;
+
+ @Field(() => UUIDScalarType, {
+ description: 'Core workflow version ID to copy',
+ nullable: false,
+ })
+ @IsUUID()
+ coreWorkflowVersionIdToCopy: string;
+}
diff --git a/packages/twenty-server/src/engine/core-modules/workflow/dtos/delete-core-workflow-version-edge.input.ts b/packages/twenty-server/src/engine/core-modules/workflow/dtos/delete-core-workflow-version-edge.input.ts
new file mode 100644
index 00000000000..e2a5c52ed6b
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/workflow/dtos/delete-core-workflow-version-edge.input.ts
@@ -0,0 +1,6 @@
+import { InputType } from '@nestjs/graphql';
+
+import { CreateCoreWorkflowVersionEdgeInput } from 'src/engine/core-modules/workflow/dtos/create-core-workflow-version-edge.input';
+
+@InputType()
+export class DeleteCoreWorkflowVersionEdgeInput extends CreateCoreWorkflowVersionEdgeInput {}
diff --git a/packages/twenty-server/src/engine/core-modules/workflow/dtos/delete-core-workflow-version-step.input.ts b/packages/twenty-server/src/engine/core-modules/workflow/dtos/delete-core-workflow-version-step.input.ts
new file mode 100644
index 00000000000..91ae643c4d2
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/workflow/dtos/delete-core-workflow-version-step.input.ts
@@ -0,0 +1,19 @@
+import { Field, InputType, OmitType } from '@nestjs/graphql';
+
+import { IsUUID } from 'class-validator';
+
+import { UUIDScalarType } from 'src/engine/api/graphql/workspace-schema-builder/graphql-types/scalars';
+import { DeleteWorkflowVersionStepInput } from 'src/engine/core-modules/workflow/dtos/delete-workflow-version-step.input';
+
+@InputType()
+export class DeleteCoreWorkflowVersionStepInput extends OmitType(
+ DeleteWorkflowVersionStepInput,
+ ['workflowVersionId'] as const,
+) {
+ @Field(() => UUIDScalarType, {
+ description: 'Core workflow version ID',
+ nullable: false,
+ })
+ @IsUUID()
+ coreWorkflowVersionId: string;
+}
diff --git a/packages/twenty-server/src/engine/core-modules/workflow/dtos/discard-core-workflow-draft.input.ts b/packages/twenty-server/src/engine/core-modules/workflow/dtos/discard-core-workflow-draft.input.ts
index 2bed2a62751..c5ec456d00b 100644
--- a/packages/twenty-server/src/engine/core-modules/workflow/dtos/discard-core-workflow-draft.input.ts
+++ b/packages/twenty-server/src/engine/core-modules/workflow/dtos/discard-core-workflow-draft.input.ts
@@ -1,12 +1,18 @@
import { Field, InputType } from '@nestjs/graphql';
-import { IsUUID } from 'class-validator';
+import { IsOptional, IsUUID } from 'class-validator';
import { UUIDScalarType } from 'src/engine/api/graphql/workspace-schema-builder/graphql-types/scalars';
@InputType()
export class DiscardCoreWorkflowDraftInput {
- @Field(() => UUIDScalarType)
+ @Field(() => UUIDScalarType, { nullable: true })
+ @IsOptional()
@IsUUID()
- workspaceWorkflowVersionId: string;
+ workspaceWorkflowVersionId?: string;
+
+ @Field(() => UUIDScalarType, { nullable: true })
+ @IsOptional()
+ @IsUUID()
+ coreWorkflowVersionId?: string;
}
diff --git a/packages/twenty-server/src/engine/core-modules/workflow/dtos/duplicate-core-workflow-version-step.input.ts b/packages/twenty-server/src/engine/core-modules/workflow/dtos/duplicate-core-workflow-version-step.input.ts
new file mode 100644
index 00000000000..72d9c72d442
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/workflow/dtos/duplicate-core-workflow-version-step.input.ts
@@ -0,0 +1,19 @@
+import { Field, InputType, OmitType } from '@nestjs/graphql';
+
+import { IsUUID } from 'class-validator';
+
+import { UUIDScalarType } from 'src/engine/api/graphql/workspace-schema-builder/graphql-types/scalars';
+import { DuplicateWorkflowVersionStepInput } from 'src/engine/core-modules/workflow/dtos/duplicate-workflow-version-step.input';
+
+@InputType()
+export class DuplicateCoreWorkflowVersionStepInput extends OmitType(
+ DuplicateWorkflowVersionStepInput,
+ ['workflowVersionId'] as const,
+) {
+ @Field(() => UUIDScalarType, {
+ description: 'Core workflow version ID',
+ nullable: false,
+ })
+ @IsUUID()
+ coreWorkflowVersionId: string;
+}
diff --git a/packages/twenty-server/src/engine/core-modules/workflow/dtos/duplicate-core-workflow.input.ts b/packages/twenty-server/src/engine/core-modules/workflow/dtos/duplicate-core-workflow.input.ts
new file mode 100644
index 00000000000..2fa5b0d29e7
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/workflow/dtos/duplicate-core-workflow.input.ts
@@ -0,0 +1,22 @@
+import { Field, InputType } from '@nestjs/graphql';
+
+import { IsUUID } from 'class-validator';
+
+import { UUIDScalarType } from 'src/engine/api/graphql/workspace-schema-builder/graphql-types/scalars';
+
+@InputType()
+export class DuplicateCoreWorkflowInput {
+ @Field(() => UUIDScalarType, {
+ description: 'Core workflow ID to duplicate',
+ nullable: false,
+ })
+ @IsUUID()
+ coreWorkflowIdToDuplicate: string;
+
+ @Field(() => UUIDScalarType, {
+ description: 'Core workflow version ID to copy',
+ nullable: false,
+ })
+ @IsUUID()
+ coreWorkflowVersionIdToCopy: string;
+}
diff --git a/packages/twenty-server/src/engine/core-modules/workflow/dtos/run-core-workflow-version.input.ts b/packages/twenty-server/src/engine/core-modules/workflow/dtos/run-core-workflow-version.input.ts
new file mode 100644
index 00000000000..7e30f82b6a9
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/workflow/dtos/run-core-workflow-version.input.ts
@@ -0,0 +1,19 @@
+import { Field, InputType, OmitType } from '@nestjs/graphql';
+
+import { IsUUID } from 'class-validator';
+
+import { UUIDScalarType } from 'src/engine/api/graphql/workspace-schema-builder/graphql-types/scalars';
+import { RunWorkflowVersionInput } from 'src/engine/core-modules/workflow/dtos/run-workflow-version.input';
+
+@InputType()
+export class RunCoreWorkflowVersionInput extends OmitType(
+ RunWorkflowVersionInput,
+ ['workflowVersionId'] as const,
+) {
+ @Field(() => UUIDScalarType, {
+ description: 'Core workflow version ID',
+ nullable: false,
+ })
+ @IsUUID()
+ coreWorkflowVersionId: string;
+}
diff --git a/packages/twenty-server/src/engine/core-modules/workflow/dtos/update-core-workflow-version-positions.input.ts b/packages/twenty-server/src/engine/core-modules/workflow/dtos/update-core-workflow-version-positions.input.ts
new file mode 100644
index 00000000000..b6a4654f576
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/workflow/dtos/update-core-workflow-version-positions.input.ts
@@ -0,0 +1,19 @@
+import { Field, InputType, OmitType } from '@nestjs/graphql';
+
+import { IsUUID } from 'class-validator';
+
+import { UUIDScalarType } from 'src/engine/api/graphql/workspace-schema-builder/graphql-types/scalars';
+import { UpdateWorkflowVersionPositionsInput } from 'src/engine/core-modules/workflow/dtos/update-workflow-version-positions.input';
+
+@InputType()
+export class UpdateCoreWorkflowVersionPositionsInput extends OmitType(
+ UpdateWorkflowVersionPositionsInput,
+ ['workflowVersionId'] as const,
+) {
+ @Field(() => UUIDScalarType, {
+ description: 'Core workflow version ID',
+ nullable: false,
+ })
+ @IsUUID()
+ coreWorkflowVersionId: string;
+}
diff --git a/packages/twenty-server/src/engine/core-modules/workflow/dtos/update-core-workflow-version-step.input.ts b/packages/twenty-server/src/engine/core-modules/workflow/dtos/update-core-workflow-version-step.input.ts
new file mode 100644
index 00000000000..b2bece57afb
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/workflow/dtos/update-core-workflow-version-step.input.ts
@@ -0,0 +1,19 @@
+import { Field, InputType, OmitType } from '@nestjs/graphql';
+
+import { IsUUID } from 'class-validator';
+
+import { UUIDScalarType } from 'src/engine/api/graphql/workspace-schema-builder/graphql-types/scalars';
+import { UpdateWorkflowVersionStepInput } from 'src/engine/core-modules/workflow/dtos/update-workflow-version-step.input';
+
+@InputType()
+export class UpdateCoreWorkflowVersionStepInput extends OmitType(
+ UpdateWorkflowVersionStepInput,
+ ['workflowVersionId'] as const,
+) {
+ @Field(() => UUIDScalarType, {
+ description: 'Core workflow version ID',
+ nullable: false,
+ })
+ @IsUUID()
+ coreWorkflowVersionId: string;
+}
diff --git a/packages/twenty-server/src/engine/core-modules/workflow/dtos/update-core-workflow-version-trigger.input.ts b/packages/twenty-server/src/engine/core-modules/workflow/dtos/update-core-workflow-version-trigger.input.ts
new file mode 100644
index 00000000000..6d4f8290c54
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/workflow/dtos/update-core-workflow-version-trigger.input.ts
@@ -0,0 +1,19 @@
+import { Field, InputType, OmitType } from '@nestjs/graphql';
+
+import { IsUUID } from 'class-validator';
+
+import { UUIDScalarType } from 'src/engine/api/graphql/workspace-schema-builder/graphql-types/scalars';
+import { UpdateWorkflowVersionTriggerInput } from 'src/engine/core-modules/workflow/dtos/update-workflow-version-trigger.input';
+
+@InputType()
+export class UpdateCoreWorkflowVersionTriggerInput extends OmitType(
+ UpdateWorkflowVersionTriggerInput,
+ ['workflowVersionId'] as const,
+) {
+ @Field(() => UUIDScalarType, {
+ description: 'Core workflow version ID',
+ nullable: false,
+ })
+ @IsUUID()
+ coreWorkflowVersionId: string;
+}
diff --git a/packages/twenty-server/src/engine/core-modules/workflow/dtos/update-core-workflow.input.ts b/packages/twenty-server/src/engine/core-modules/workflow/dtos/update-core-workflow.input.ts
new file mode 100644
index 00000000000..acf4c9f4895
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/workflow/dtos/update-core-workflow.input.ts
@@ -0,0 +1,16 @@
+import { Field, InputType } from '@nestjs/graphql';
+
+import { IsString, IsUUID } from 'class-validator';
+
+import { UUIDScalarType } from 'src/engine/api/graphql/workspace-schema-builder/graphql-types/scalars';
+
+@InputType()
+export class UpdateCoreWorkflowInput {
+ @Field(() => UUIDScalarType, { nullable: false })
+ @IsUUID()
+ coreWorkflowId: string;
+
+ @Field(() => String, { nullable: false })
+ @IsString()
+ name: string;
+}
diff --git a/packages/twenty-server/src/engine/core-modules/workflow/entities/workflow-version.entity.ts b/packages/twenty-server/src/engine/core-modules/workflow/entities/workflow-version.entity.ts
index a5ffc3a5d82..b78901b465a 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
@@ -9,6 +9,7 @@ import {
import { CREATE_WORKFLOW_VERSION_CORE_TABLE_UPGRADE_COMMAND_NAME } from 'src/database/commands/upgrade-version-command/2-20/create-workflow-version-core-table-upgrade-command-name.constant';
import { ADD_CORE_WORKFLOW_ID_TO_WORKFLOW_VERSION_UPGRADE_COMMAND_NAME } from 'src/database/commands/upgrade-version-command/2-40/add-core-workflow-id-to-workflow-version-upgrade-command-name.constant';
+import { ADD_WORKSPACE_WORKFLOW_VERSION_ID_TO_WORKFLOW_VERSION_UPGRADE_COMMAND_NAME } from 'src/database/commands/upgrade-version-command/2-42/add-workspace-workflow-version-id-to-workflow-version-upgrade-command-name.constant';
import { WasIntroducedInUpgrade } from 'src/engine/core-modules/upgrade/decorators/was-introduced-in-upgrade.decorator';
import { SyncableEntity } from 'src/engine/workspace-manager/types/syncable-entity.interface';
import { type WorkflowAction } from 'src/modules/workflow/workflow-executor/workflow-actions/types/workflow-action.type';
@@ -35,6 +36,10 @@ export enum WorkflowVersionStatus {
},
)
@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;
@@ -63,6 +68,13 @@ export class WorkflowVersionEntity extends SyncableEntity {
@Column({ type: 'uuid', nullable: true })
coreWorkflowId: string | null;
+ @WasIntroducedInUpgrade({
+ upgradeCommandName:
+ ADD_WORKSPACE_WORKFLOW_VERSION_ID_TO_WORKFLOW_VERSION_UPGRADE_COMMAND_NAME,
+ })
+ @Column({ type: 'uuid', nullable: true })
+ workspaceWorkflowVersionId: string | null;
+
@CreateDateColumn({ type: 'timestamptz' })
createdAt: Date;
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.ts
new file mode 100644
index 00000000000..d9aa2107705
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/workflow/resolvers/core-workflow-version-mutation.resolver.ts
@@ -0,0 +1,284 @@
+import { UseFilters, UseGuards, UsePipes } from '@nestjs/common';
+import { Args, Mutation } from '@nestjs/graphql';
+
+import { PermissionFlagType } from 'twenty-shared/constants';
+
+import { CoreResolver } from 'src/engine/api/graphql/graphql-config/decorators/core-resolver.decorator';
+import { UUIDScalarType } from 'src/engine/api/graphql/workspace-schema-builder/graphql-types/scalars';
+import { type AuthContextUser } from 'src/engine/core-modules/auth/types/auth-context.type';
+import { PreventNestToAutoLogGraphqlErrorsFilter } from 'src/engine/core-modules/graphql/filters/prevent-nest-to-auto-log-graphql-errors.filter';
+import { ResolverValidationPipe } from 'src/engine/core-modules/graphql/pipes/resolver-validation.pipe';
+import { CoreWorkflowVersionDTO } from 'src/engine/core-modules/workflow/dtos/core-workflow-version.dto';
+import { CreateCoreWorkflowVersionEdgeInput } from 'src/engine/core-modules/workflow/dtos/create-core-workflow-version-edge.input';
+import { CreateCoreWorkflowVersionStepInput } from 'src/engine/core-modules/workflow/dtos/create-core-workflow-version-step.input';
+import { CreateDraftFromCoreWorkflowVersionInput } from 'src/engine/core-modules/workflow/dtos/create-draft-from-core-workflow-version.input';
+import { DeleteCoreWorkflowVersionEdgeInput } from 'src/engine/core-modules/workflow/dtos/delete-core-workflow-version-edge.input';
+import { DeleteCoreWorkflowVersionStepInput } from 'src/engine/core-modules/workflow/dtos/delete-core-workflow-version-step.input';
+import { DuplicateCoreWorkflowVersionStepInput } from 'src/engine/core-modules/workflow/dtos/duplicate-core-workflow-version-step.input';
+import { RunCoreWorkflowVersionInput } from 'src/engine/core-modules/workflow/dtos/run-core-workflow-version.input';
+import { RunWorkflowVersionDTO } from 'src/engine/core-modules/workflow/dtos/run-workflow-version.dto';
+import { UpdateCoreWorkflowVersionPositionsInput } from 'src/engine/core-modules/workflow/dtos/update-core-workflow-version-positions.input';
+import { UpdateCoreWorkflowVersionStepInput } from 'src/engine/core-modules/workflow/dtos/update-core-workflow-version-step.input';
+import { UpdateCoreWorkflowVersionTriggerInput } from 'src/engine/core-modules/workflow/dtos/update-core-workflow-version-trigger.input';
+import { WorkflowActionDTO } from 'src/engine/core-modules/workflow/dtos/workflow-action.dto';
+import { WorkflowVersionStepChangesDTO } from 'src/engine/core-modules/workflow/dtos/workflow-version-step-changes.dto';
+import { WorkflowVersionTriggerDTO } from 'src/engine/core-modules/workflow/dtos/workflow-version-trigger.dto';
+import { WorkflowQueryValidationGraphqlApiExceptionFilter } from 'src/engine/core-modules/workflow/filters/workflow-query-validation-graphql-api-exception.filter';
+import { WorkflowTriggerGraphqlApiExceptionFilter } from 'src/engine/core-modules/workflow/filters/workflow-trigger-graphql-api-exception.filter';
+import { WorkflowVersionEdgeGraphqlApiExceptionFilter } from 'src/engine/core-modules/workflow/filters/workflow-version-edge-graphql-api-exception.filter';
+import { WorkflowVersionStepGraphqlApiExceptionFilter } from 'src/engine/core-modules/workflow/filters/workflow-version-step-graphql-api-exception.filter';
+import { WorkflowVersionValidationGraphqlApiExceptionFilter } from 'src/engine/core-modules/workflow/filters/workflow-version-validation-graphql-api-exception.filter';
+import { CoreWorkflowLifecycleWorkspaceService } from 'src/engine/core-modules/workflow/services/core-workflow-lifecycle.workspace-service';
+import { CoreWorkflowVersionMutationWorkspaceService } from 'src/engine/core-modules/workflow/services/core-workflow-version-mutation.workspace-service';
+import { WorkspaceEntity } from 'src/engine/core-modules/workspace/workspace.entity';
+import { AuthUser } from 'src/engine/decorators/auth/auth-user.decorator';
+import { AuthWorkspace } from 'src/engine/decorators/auth/auth-workspace.decorator';
+import { SettingsPermissionGuard } from 'src/engine/guards/settings-permission.guard';
+import { UserAuthGuard } from 'src/engine/guards/user-auth.guard';
+import { WorkspaceAuthGuard } from 'src/engine/guards/workspace-auth.guard';
+import { PermissionsGraphqlApiExceptionFilter } from 'src/engine/metadata-modules/permissions/utils/permissions-graphql-api-exception.filter';
+import { buildSystemAuthContext } from 'src/engine/twenty-orm/utils/build-system-auth-context.util';
+import { 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';
+
+@CoreResolver()
+@UsePipes(ResolverValidationPipe)
+@UseGuards(
+ WorkspaceAuthGuard,
+ UserAuthGuard,
+ SettingsPermissionGuard(PermissionFlagType.WORKFLOWS),
+)
+@UseFilters(
+ PermissionsGraphqlApiExceptionFilter,
+ PreventNestToAutoLogGraphqlErrorsFilter,
+ WorkflowQueryValidationGraphqlApiExceptionFilter,
+ WorkflowTriggerGraphqlApiExceptionFilter,
+ WorkflowVersionEdgeGraphqlApiExceptionFilter,
+ WorkflowVersionStepGraphqlApiExceptionFilter,
+ WorkflowVersionValidationGraphqlApiExceptionFilter,
+)
+export class CoreWorkflowVersionMutationResolver {
+ constructor(
+ private readonly coreWorkflowVersionMutationWorkspaceService: CoreWorkflowVersionMutationWorkspaceService,
+ private readonly coreWorkflowLifecycleWorkspaceService: CoreWorkflowLifecycleWorkspaceService,
+ private readonly workspaceOrmManager: WorkspaceOrmManager,
+ ) {}
+
+ @Mutation(() => Boolean)
+ async validateCoreWorkflowVersion(
+ @AuthWorkspace() { id: workspaceId }: WorkspaceEntity,
+ @Args('coreWorkflowVersionId', { type: () => UUIDScalarType })
+ coreWorkflowVersionId: string,
+ ): Promise<boolean> {
+ return this.coreWorkflowLifecycleWorkspaceService.validateCoreWorkflowVersion(
+ {
+ workspaceId,
+ coreWorkflowVersionId,
+ },
+ );
+ }
+
+ @Mutation(() => Boolean)
+ async activateCoreWorkflowVersion(
+ @AuthWorkspace() { id: workspaceId }: WorkspaceEntity,
+ @Args('coreWorkflowVersionId', { type: () => UUIDScalarType })
+ coreWorkflowVersionId: string,
+ ): Promise<boolean> {
+ return this.coreWorkflowLifecycleWorkspaceService.activateCoreWorkflowVersion(
+ {
+ workspaceId,
+ coreWorkflowVersionId,
+ },
+ );
+ }
+
+ @Mutation(() => Boolean)
+ async deactivateCoreWorkflowVersion(
+ @AuthWorkspace() { id: workspaceId }: WorkspaceEntity,
+ @Args('coreWorkflowVersionId', { type: () => UUIDScalarType })
+ coreWorkflowVersionId: string,
+ ): Promise<boolean> {
+ return this.coreWorkflowLifecycleWorkspaceService.deactivateCoreWorkflowVersion(
+ {
+ workspaceId,
+ coreWorkflowVersionId,
+ },
+ );
+ }
+
+ @Mutation(() => RunWorkflowVersionDTO)
+ async runCoreWorkflowVersion(
+ @AuthUser() user: AuthContextUser,
+ @AuthWorkspace() { id: workspaceId }: WorkspaceEntity,
+ @Args('input')
+ {
+ coreWorkflowVersionId,
+ workflowRunId,
+ payload,
+ }: RunCoreWorkflowVersionInput,
+ ): Promise<RunWorkflowVersionDTO> {
+ const workspaceMember =
+ await this.workspaceOrmManager.executeInWorkspaceContext(async () => {
+ const workspaceMemberRepository =
+ this.workspaceOrmManager.getRepository<WorkspaceMemberWorkspaceEntity>(
+ 'workspaceMember',
+ { shouldBypassPermissionChecks: true },
+ );
+
+ return workspaceMemberRepository.findOneOrFail({
+ where: { userId: user.id },
+ });
+ }, buildSystemAuthContext(workspaceId));
+
+ const { payload: triggerPayload, createdBy } =
+ buildWorkflowRunTriggerContext({ workspaceMember, payload });
+
+ return this.coreWorkflowLifecycleWorkspaceService.runCoreWorkflowVersion({
+ workspaceId,
+ coreWorkflowVersionId,
+ workflowRunId: workflowRunId ?? undefined,
+ payload: triggerPayload,
+ createdBy,
+ });
+ }
+
+ @Mutation(() => CoreWorkflowVersionDTO)
+ async createDraftFromCoreWorkflowVersion(
+ @AuthWorkspace() { id: workspaceId }: WorkspaceEntity,
+ @Args('input')
+ {
+ coreWorkflowId,
+ coreWorkflowVersionIdToCopy,
+ }: CreateDraftFromCoreWorkflowVersionInput,
+ ): Promise<CoreWorkflowVersionDTO> {
+ return this.coreWorkflowVersionMutationWorkspaceService.createDraftFromCoreWorkflowVersion(
+ {
+ workspaceId,
+ coreWorkflowId,
+ coreWorkflowVersionIdToCopy,
+ },
+ );
+ }
+
+ @Mutation(() => WorkflowVersionStepChangesDTO)
+ async createCoreWorkflowVersionStep(
+ @AuthWorkspace() { id: workspaceId }: WorkspaceEntity,
+ @Args('input') input: CreateCoreWorkflowVersionStepInput,
+ ): Promise<WorkflowVersionStepChangesDTO> {
+ return this.coreWorkflowVersionMutationWorkspaceService.createStep({
+ workspaceId,
+ input,
+ });
+ }
+
+ @Mutation(() => WorkflowActionDTO)
+ async updateCoreWorkflowVersionStep(
+ @AuthWorkspace() { id: workspaceId }: WorkspaceEntity,
+ @Args('input')
+ { coreWorkflowVersionId, step }: UpdateCoreWorkflowVersionStepInput,
+ ): Promise<WorkflowActionDTO> {
+ return this.coreWorkflowVersionMutationWorkspaceService.updateStep({
+ workspaceId,
+ coreWorkflowVersionId,
+ step,
+ });
+ }
+
+ @Mutation(() => WorkflowVersionTriggerDTO)
+ async updateCoreWorkflowVersionTrigger(
+ @AuthWorkspace() { id: workspaceId }: WorkspaceEntity,
+ @Args('input')
+ { coreWorkflowVersionId, trigger }: UpdateCoreWorkflowVersionTriggerInput,
+ ): Promise<WorkflowVersionTriggerDTO> {
+ return this.coreWorkflowVersionMutationWorkspaceService.updateTrigger({
+ workspaceId,
+ coreWorkflowVersionId,
+ trigger,
+ });
+ }
+
+ @Mutation(() => WorkflowVersionStepChangesDTO)
+ async deleteCoreWorkflowVersionStep(
+ @AuthWorkspace() { id: workspaceId }: WorkspaceEntity,
+ @Args('input')
+ { coreWorkflowVersionId, stepId }: DeleteCoreWorkflowVersionStepInput,
+ ): Promise<WorkflowVersionStepChangesDTO> {
+ return this.coreWorkflowVersionMutationWorkspaceService.deleteStep({
+ workspaceId,
+ coreWorkflowVersionId,
+ stepIdToDelete: stepId,
+ });
+ }
+
+ @Mutation(() => WorkflowVersionStepChangesDTO)
+ async duplicateCoreWorkflowVersionStep(
+ @AuthWorkspace() { id: workspaceId }: WorkspaceEntity,
+ @Args('input')
+ { coreWorkflowVersionId, stepId }: DuplicateCoreWorkflowVersionStepInput,
+ ): Promise<WorkflowVersionStepChangesDTO> {
+ return this.coreWorkflowVersionMutationWorkspaceService.duplicateStep({
+ workspaceId,
+ coreWorkflowVersionId,
+ stepId,
+ });
+ }
+
+ @Mutation(() => WorkflowVersionStepChangesDTO)
+ async createCoreWorkflowVersionEdge(
+ @AuthWorkspace() { id: workspaceId }: WorkspaceEntity,
+ @Args('input')
+ {
+ coreWorkflowVersionId,
+ source,
+ target,
+ sourceConnectionOptions,
+ }: CreateCoreWorkflowVersionEdgeInput,
+ ): Promise<WorkflowVersionStepChangesDTO> {
+ return this.coreWorkflowVersionMutationWorkspaceService.createEdge({
+ workspaceId,
+ coreWorkflowVersionId,
+ source,
+ target,
+ sourceConnectionOptions,
+ });
+ }
+
+ @Mutation(() => WorkflowVersionStepChangesDTO)
+ async deleteCoreWorkflowVersionEdge(
+ @AuthWorkspace() { id: workspaceId }: WorkspaceEntity,
+ @Args('input')
+ {
+ coreWorkflowVersionId,
+ source,
+ target,
+ sourceConnectionOptions,
+ }: DeleteCoreWorkflowVersionEdgeInput,
+ ): Promise<WorkflowVersionStepChangesDTO> {
+ return this.coreWorkflowVersionMutationWorkspaceService.deleteEdge({
+ workspaceId,
+ coreWorkflowVersionId,
+ source,
+ target,
+ sourceConnectionOptions,
+ });
+ }
+
+ @Mutation(() => Boolean)
+ async updateCoreWorkflowVersionPositions(
+ @AuthWorkspace() { id: workspaceId }: WorkspaceEntity,
+ @Args('input')
+ {
+ coreWorkflowVersionId,
+ positions,
+ }: UpdateCoreWorkflowVersionPositionsInput,
+ ): Promise<boolean> {
+ await this.coreWorkflowVersionMutationWorkspaceService.updatePositions({
+ workspaceId,
+ coreWorkflowVersionId,
+ positions,
+ });
+
+ return true;
+ }
+}
diff --git a/packages/twenty-server/src/engine/core-modules/workflow/resolvers/core-workflow.resolver.ts b/packages/twenty-server/src/engine/core-modules/workflow/resolvers/core-workflow.resolver.ts
index 780ac730356..416daeccadf 100644
--- a/packages/twenty-server/src/engine/core-modules/workflow/resolvers/core-workflow.resolver.ts
+++ b/packages/twenty-server/src/engine/core-modules/workflow/resolvers/core-workflow.resolver.ts
@@ -16,7 +16,12 @@ import { WorkflowQueryValidationGraphqlApiExceptionFilter } from 'src/engine/cor
import { CoreWorkflowVersionDTO } from 'src/engine/core-modules/workflow/dtos/core-workflow-version.dto';
import { CoreWorkflowVersionArgs } from 'src/engine/core-modules/workflow/dtos/core-workflow-version.input';
import { CoreWorkflowVersionsArgs } from 'src/engine/core-modules/workflow/dtos/core-workflow-versions.input';
+import { CoreWorkflowVersionByIdArgs } from 'src/engine/core-modules/workflow/dtos/core-workflow-version-by-id.input';
+import { CoreWorkflowVersionsByCoreWorkflowIdArgs } from 'src/engine/core-modules/workflow/dtos/core-workflow-versions-by-core-workflow-id.input';
+import { CoreWorkflowByIdArgs } from 'src/engine/core-modules/workflow/dtos/core-workflow-by-id.input';
import { CoreWorkflowArgs } from 'src/engine/core-modules/workflow/dtos/core-workflow.input';
+import { DuplicateCoreWorkflowInput } from 'src/engine/core-modules/workflow/dtos/duplicate-core-workflow.input';
+import { UpdateCoreWorkflowInput } from 'src/engine/core-modules/workflow/dtos/update-core-workflow.input';
import { CoreWorkflowsArgs } from 'src/engine/core-modules/workflow/dtos/core-workflows.input';
import { CoreWorkflowListService } from 'src/engine/core-modules/workflow/services/core-workflow-list.service';
import { CoreWorkflowMutationWorkspaceService } from 'src/engine/core-modules/workflow/services/core-workflow-mutation.workspace-service';
@@ -53,6 +58,40 @@ export class CoreWorkflowResolver {
private readonly coreWorkflowVersionListService: CoreWorkflowVersionListService,
) {}
+ @Mutation(() => CoreWorkflowDTO, { nullable: true })
+ async updateCoreWorkflow(
+ @AuthWorkspace() { id: workspaceId }: WorkspaceEntity,
+ @Args('input') input: UpdateCoreWorkflowInput,
+ ): Promise<CoreWorkflowDTO | null> {
+ await this.coreWorkflowMutationWorkspaceService.updateWorkflow(
+ workspaceId,
+ input,
+ );
+
+ return this.coreWorkflowListService.findOneById({
+ workspaceId,
+ coreWorkflowId: input.coreWorkflowId,
+ });
+ }
+
+ @Mutation(() => CoreWorkflowDTO)
+ async duplicateCoreWorkflow(
+ @AuthWorkspace() { id: workspaceId }: WorkspaceEntity,
+ @AuthUser() user: AuthContextUser,
+ @Args('input')
+ {
+ coreWorkflowIdToDuplicate,
+ coreWorkflowVersionIdToCopy,
+ }: DuplicateCoreWorkflowInput,
+ ): Promise<CoreWorkflowDTO> {
+ return this.coreWorkflowMutationWorkspaceService.duplicateWorkflow({
+ workspaceId,
+ user,
+ coreWorkflowIdToDuplicate,
+ coreWorkflowVersionIdToCopy,
+ });
+ }
+
@Mutation(() => CoreWorkflowDTO)
async createCoreWorkflow(
@AuthWorkspace() { id: workspaceId }: WorkspaceEntity,
@@ -82,19 +121,19 @@ export class CoreWorkflowResolver {
@AuthWorkspace() { id: workspaceId }: WorkspaceEntity,
@Args('input') input: DiscardCoreWorkflowDraftInput,
): Promise<CoreWorkflowDTO | null> {
- const workspaceWorkflowId =
+ const coreWorkflowId =
await this.coreWorkflowMutationWorkspaceService.discardDraftVersion(
workspaceId,
input,
);
- if (!isDefined(workspaceWorkflowId)) {
+ if (!isDefined(coreWorkflowId)) {
return null;
}
- return this.coreWorkflowListService.findOneByWorkspaceWorkflowId({
+ return this.coreWorkflowListService.findOneById({
workspaceId,
- workspaceWorkflowId,
+ coreWorkflowId,
});
}
@@ -109,6 +148,17 @@ export class CoreWorkflowResolver {
);
}
+ @Query(() => CoreWorkflowDTO, { nullable: true })
+ async coreWorkflowById(
+ @AuthWorkspace() { id: workspaceId }: WorkspaceEntity,
+ @Args() { coreWorkflowId }: CoreWorkflowByIdArgs,
+ ): Promise<CoreWorkflowDTO | null> {
+ return this.coreWorkflowListService.findOneById({
+ workspaceId,
+ coreWorkflowId,
+ });
+ }
+
@Query(() => CoreWorkflowDTO, { nullable: true })
async coreWorkflow(
@AuthWorkspace() { id: workspaceId }: WorkspaceEntity,
@@ -143,4 +193,26 @@ export class CoreWorkflowResolver {
},
);
}
+
+ @Query(() => [CoreWorkflowVersionDTO])
+ async coreWorkflowVersionsByCoreWorkflowId(
+ @AuthWorkspace() { id: workspaceId }: WorkspaceEntity,
+ @Args() { coreWorkflowId }: CoreWorkflowVersionsByCoreWorkflowIdArgs,
+ ): Promise<CoreWorkflowVersionDTO[]> {
+ return this.coreWorkflowVersionListService.findManyByCoreWorkflowId({
+ workspaceId,
+ coreWorkflowId,
+ });
+ }
+
+ @Query(() => CoreWorkflowVersionDTO, { nullable: true })
+ async coreWorkflowVersionById(
+ @AuthWorkspace() { id: workspaceId }: WorkspaceEntity,
+ @Args() { coreWorkflowVersionId }: CoreWorkflowVersionByIdArgs,
+ ): Promise<CoreWorkflowVersionDTO | null> {
+ return this.coreWorkflowVersionListService.findOneByCoreWorkflowVersionId({
+ workspaceId,
+ coreWorkflowVersionId,
+ });
+ }
}
diff --git a/packages/twenty-server/src/engine/core-modules/workflow/resolvers/workflow-builder.resolver.ts b/packages/twenty-server/src/engine/core-modules/workflow/resolvers/workflow-builder.resolver.ts
index 00df39d5d98..9d5c830e306 100644
--- a/packages/twenty-server/src/engine/core-modules/workflow/resolvers/workflow-builder.resolver.ts
+++ b/packages/twenty-server/src/engine/core-modules/workflow/resolvers/workflow-builder.resolver.ts
@@ -7,8 +7,23 @@ import { PermissionFlagType } from 'twenty-shared/constants';
import { CoreResolver } from 'src/engine/api/graphql/graphql-config/decorators/core-resolver.decorator';
import { PreventNestToAutoLogGraphqlErrorsFilter } from 'src/engine/core-modules/graphql/filters/prevent-nest-to-auto-log-graphql-errors.filter';
import { ResolverValidationPipe } from 'src/engine/core-modules/graphql/pipes/resolver-validation.pipe';
+import { isDefined } from 'twenty-shared/utils';
+
import { ComputeStepOutputSchemaInput } from 'src/engine/core-modules/workflow/dtos/compute-step-output-schema.input';
+import { WorkflowQueryValidationGraphqlApiExceptionFilter } from 'src/engine/core-modules/workflow/filters/workflow-query-validation-graphql-api-exception.filter';
import { WorkflowTriggerGraphqlApiExceptionFilter } from 'src/engine/core-modules/workflow/filters/workflow-trigger-graphql-api-exception.filter';
+import { msg } from '@lingui/core/macro';
+
+import { WorkflowVersionEntity } from 'src/engine/core-modules/workflow/entities/workflow-version.entity';
+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 {
+ WorkflowQueryValidationException,
+ WorkflowQueryValidationExceptionCode,
+} from 'src/modules/workflow/common/exceptions/workflow-query-validation.exception';
+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 { WorkspaceEntity } from 'src/engine/core-modules/workspace/workspace.entity';
import { AuthWorkspace } from 'src/engine/decorators/auth/auth-workspace.decorator';
import { SettingsPermissionGuard } from 'src/engine/guards/settings-permission.guard';
@@ -28,6 +43,7 @@ import { AuthGraphqlApiExceptionFilter } from 'src/engine/core-modules/auth/filt
@UsePipes(ResolverValidationPipe)
@UseFilters(
WorkflowTriggerGraphqlApiExceptionFilter,
+ WorkflowQueryValidationGraphqlApiExceptionFilter,
PermissionsGraphqlApiExceptionFilter,
PreventNestToAutoLogGraphqlErrorsFilter,
AuthGraphqlApiExceptionFilter,
@@ -35,17 +51,76 @@ import { AuthGraphqlApiExceptionFilter } from 'src/engine/core-modules/auth/filt
export class WorkflowBuilderResolver {
constructor(
private readonly workflowSchemaWorkspaceService: WorkflowSchemaWorkspaceService,
+ private readonly workflowCommonWorkspaceService: WorkflowCommonWorkspaceService,
+ @InjectWorkspaceScopedRepository(WorkflowVersionEntity)
+ private readonly coreWorkflowVersionRepository: WorkspaceScopedRepository<WorkflowVersionEntity>,
) {}
@Mutation(() => graphqlTypeJson)
async computeStepOutputSchema(
@AuthWorkspace() { id: workspaceId }: WorkspaceEntity,
- @Args('input') { step, workflowVersionId }: ComputeStepOutputSchemaInput,
+ @Args('input')
+ {
+ step,
+ workflowVersionId,
+ coreWorkflowVersionId,
+ }: ComputeStepOutputSchemaInput,
): Promise<OutputSchema> {
return this.workflowSchemaWorkspaceService.computeStepOutputSchema({
step,
workspaceId,
- workflowVersionId,
+ workflowVersionContent: await this.resolveWorkflowVersionContent({
+ workspaceId,
+ workflowVersionId,
+ coreWorkflowVersionId,
+ }),
});
}
+
+ private async resolveWorkflowVersionContent({
+ workspaceId,
+ workflowVersionId,
+ coreWorkflowVersionId,
+ }: {
+ workspaceId: string;
+ workflowVersionId?: string;
+ coreWorkflowVersionId?: string;
+ }): Promise<
+ | { trigger: WorkflowTrigger | null; steps: WorkflowAction[] | null }
+ | undefined
+ > {
+ if (isDefined(coreWorkflowVersionId)) {
+ const coreWorkflowVersion =
+ await this.coreWorkflowVersionRepository.findOne(workspaceId, {
+ where: { id: coreWorkflowVersionId },
+ });
+
+ if (!isDefined(coreWorkflowVersion)) {
+ throw new WorkflowQueryValidationException(
+ `Core workflow version '${coreWorkflowVersionId}' not found`,
+ WorkflowQueryValidationExceptionCode.FORBIDDEN,
+ {
+ userFriendlyMessage: msg`Workflow version not found`,
+ },
+ );
+ }
+
+ return {
+ trigger: coreWorkflowVersion.triggers?.[0] ?? null,
+ steps: coreWorkflowVersion.steps,
+ };
+ }
+
+ if (!isDefined(workflowVersionId)) {
+ return undefined;
+ }
+
+ const workflowVersion =
+ await this.workflowCommonWorkspaceService.getWorkflowVersionOrFail({
+ workflowVersionId,
+ workspaceId,
+ });
+
+ return { trigger: workflowVersion.trigger, steps: workflowVersion.steps };
+ }
}
diff --git a/packages/twenty-server/src/engine/core-modules/workflow/resolvers/workflow-trigger.resolver.ts b/packages/twenty-server/src/engine/core-modules/workflow/resolvers/workflow-trigger.resolver.ts
index b5511bdff3f..4e3eac5ba75 100644
--- a/packages/twenty-server/src/engine/core-modules/workflow/resolvers/workflow-trigger.resolver.ts
+++ b/packages/twenty-server/src/engine/core-modules/workflow/resolvers/workflow-trigger.resolver.ts
@@ -2,15 +2,9 @@ import { UseFilters, UseGuards, UsePipes } from '@nestjs/common';
import { Args, Mutation } from '@nestjs/graphql';
import { PermissionFlagType } from 'twenty-shared/constants';
-import {
- WORKFLOW_TRIGGER_METADATA_KEY,
- WORKFLOW_TRIGGER_METADATA_WORKSPACE_MEMBER_ID_KEY,
- WORKFLOW_TRIGGER_PAYLOAD_KEY,
-} from 'twenty-shared/workflow';
import { CoreResolver } from 'src/engine/api/graphql/graphql-config/decorators/core-resolver.decorator';
import { UUIDScalarType } from 'src/engine/api/graphql/workspace-schema-builder/graphql-types/scalars';
-import { buildCreatedByFromFullNameMetadata } from 'src/engine/core-modules/actor/utils/build-created-by-from-full-name-metadata.util';
import { PreventNestToAutoLogGraphqlErrorsFilter } from 'src/engine/core-modules/graphql/filters/prevent-nest-to-auto-log-graphql-errors.filter';
import { ResolverValidationPipe } from 'src/engine/core-modules/graphql/pipes/resolver-validation.pipe';
import { type AuthContextUser } from 'src/engine/core-modules/auth/types/auth-context.type';
@@ -29,6 +23,7 @@ import { WorkspaceAuthGuard } from 'src/engine/guards/workspace-auth.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 { buildSystemAuthContext } from 'src/engine/twenty-orm/utils/build-system-auth-context.util';
+import { buildWorkflowRunTriggerContext } from 'src/modules/workflow/workflow-trigger/utils/build-workflow-run-trigger-context.util';
import { WorkflowTriggerWorkspaceService } from 'src/modules/workflow/workflow-trigger/workspace-services/workflow-trigger.workspace-service';
import { WorkspaceMemberWorkspaceEntity } from 'src/modules/workspace-member/standard-objects/workspace-member.workspace-entity';
@@ -100,24 +95,14 @@ export class WorkflowTriggerResolver {
});
}, authContext);
+ const { payload: triggerPayload, createdBy } =
+ buildWorkflowRunTriggerContext({ workspaceMember, payload });
+
return this.workflowTriggerWorkspaceService.runWorkflowVersion({
workflowVersionId,
workflowRunId: workflowRunId ?? undefined,
- payload: {
- ...(payload ?? {}),
- [WORKFLOW_TRIGGER_PAYLOAD_KEY]: { ...(payload ?? {}) },
- [WORKFLOW_TRIGGER_METADATA_KEY]: {
- [WORKFLOW_TRIGGER_METADATA_WORKSPACE_MEMBER_ID_KEY]:
- workspaceMember.id,
- },
- },
- createdBy: buildCreatedByFromFullNameMetadata({
- fullNameMetadata: {
- firstName: workspaceMember.name.firstName,
- lastName: workspaceMember.name.lastName,
- },
- workspaceMemberId: workspaceMember.id,
- }),
+ payload: triggerPayload,
+ createdBy,
workspaceId: workspace.id,
});
}
diff --git a/packages/twenty-server/src/engine/core-modules/workflow/services/core-workflow-id-resolution.service.ts b/packages/twenty-server/src/engine/core-modules/workflow/services/core-workflow-id-resolution.service.ts
new file mode 100644
index 00000000000..4f0df1342f3
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/workflow/services/core-workflow-id-resolution.service.ts
@@ -0,0 +1,129 @@
+import { Injectable } from '@nestjs/common';
+
+import { msg } from '@lingui/core/macro';
+import { isDefined } from 'twenty-shared/utils';
+
+import { WorkflowVersionEntity } from 'src/engine/core-modules/workflow/entities/workflow-version.entity';
+import { WorkflowEntity } from 'src/engine/core-modules/workflow/entities/workflow.entity';
+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 {
+ WorkflowQueryValidationException,
+ WorkflowQueryValidationExceptionCode,
+} from 'src/modules/workflow/common/exceptions/workflow-query-validation.exception';
+
+@Injectable()
+export class CoreWorkflowIdResolutionService {
+ constructor(
+ @InjectWorkspaceScopedRepository(WorkflowEntity)
+ private readonly coreWorkflowRepository: WorkspaceScopedRepository<WorkflowEntity>,
+ @InjectWorkspaceScopedRepository(WorkflowVersionEntity)
+ private readonly coreWorkflowVersionRepository: WorkspaceScopedRepository<WorkflowVersionEntity>,
+ ) {}
+
+ async resolveWorkspaceVersionIdOrThrow({
+ workspaceId,
+ coreWorkflowVersionId,
+ }: {
+ workspaceId: string;
+ coreWorkflowVersionId: string;
+ }): Promise<{
+ coreWorkflowVersion: WorkflowVersionEntity;
+ workspaceWorkflowVersionId: string;
+ }> {
+ const resolved = await this.resolveWorkspaceVersionIdIfCoreVersionExists({
+ workspaceId,
+ coreWorkflowVersionId,
+ });
+
+ if (!isDefined(resolved)) {
+ throw new WorkflowQueryValidationException(
+ `Core workflow version '${coreWorkflowVersionId}' not found`,
+ WorkflowQueryValidationExceptionCode.FORBIDDEN,
+ {
+ userFriendlyMessage: msg`Workflow version not found`,
+ },
+ );
+ }
+
+ return resolved;
+ }
+
+ async resolveWorkspaceVersionIdIfCoreVersionExists({
+ workspaceId,
+ coreWorkflowVersionId,
+ }: {
+ workspaceId: string;
+ coreWorkflowVersionId: string;
+ }): Promise<{
+ coreWorkflowVersion: WorkflowVersionEntity;
+ workspaceWorkflowVersionId: string;
+ } | null> {
+ const coreWorkflowVersion =
+ await this.coreWorkflowVersionRepository.findOne(workspaceId, {
+ where: { id: coreWorkflowVersionId },
+ });
+
+ if (!isDefined(coreWorkflowVersion)) {
+ return null;
+ }
+
+ const workspaceWorkflowVersionId =
+ coreWorkflowVersion.workspaceWorkflowVersionId;
+
+ if (!isDefined(workspaceWorkflowVersionId)) {
+ throw new WorkflowQueryValidationException(
+ `Core workflow version '${coreWorkflowVersionId}' has no workspace mirror alias`,
+ WorkflowQueryValidationExceptionCode.FORBIDDEN,
+ {
+ userFriendlyMessage: msg`Workflow version is not correctly linked to its mirror`,
+ },
+ );
+ }
+
+ return {
+ coreWorkflowVersion,
+ workspaceWorkflowVersionId,
+ };
+ }
+
+ async resolveWorkspaceWorkflowIdOrThrow({
+ workspaceId,
+ coreWorkflowId,
+ }: {
+ workspaceId: string;
+ coreWorkflowId: string;
+ }): Promise<{
+ coreWorkflow: WorkflowEntity;
+ workspaceWorkflowId: string;
+ }> {
+ const coreWorkflow = await this.coreWorkflowRepository.findOne(
+ workspaceId,
+ { where: { id: coreWorkflowId } },
+ );
+
+ if (!isDefined(coreWorkflow)) {
+ throw new WorkflowQueryValidationException(
+ `Core workflow '${coreWorkflowId}' not found`,
+ WorkflowQueryValidationExceptionCode.FORBIDDEN,
+ {
+ userFriendlyMessage: msg`Workflow not found`,
+ },
+ );
+ }
+
+ const workspaceWorkflowId = coreWorkflow.workspaceWorkflowId;
+
+ if (!isDefined(workspaceWorkflowId)) {
+ throw new WorkflowQueryValidationException(
+ `Core workflow '${coreWorkflowId}' has no workspace mirror row`,
+ WorkflowQueryValidationExceptionCode.FORBIDDEN,
+ {
+ userFriendlyMessage: msg`Workflow is not correctly linked to its mirror`,
+ },
+ );
+ }
+
+ return { coreWorkflow, workspaceWorkflowId };
+ }
+}
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.ts
new file mode 100644
index 00000000000..5395f0bff2e
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/workflow/services/core-workflow-lifecycle.workspace-service.ts
@@ -0,0 +1,780 @@
+import { Injectable, Logger } from '@nestjs/common';
+
+import { msg } from '@lingui/core/macro';
+import {
+ CommandMenuItemAvailabilityType,
+ type ActorMetadata,
+} from 'twenty-shared/types';
+import { isDefined } from 'twenty-shared/utils';
+
+import { InjectCacheStorage } from 'src/engine/core-modules/cache-storage/decorators/cache-storage.decorator';
+import { 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 {
+ WorkflowVersionEntity,
+ WorkflowVersionStatus as CoreWorkflowVersionStatus,
+} from 'src/engine/core-modules/workflow/entities/workflow-version.entity';
+import { type WorkflowEntity } from 'src/engine/core-modules/workflow/entities/workflow.entity';
+import { CoreWorkflowIdResolutionService } from 'src/engine/core-modules/workflow/services/core-workflow-id-resolution.service';
+import { assertExactlyOneMirrorRowWasWritten } from 'src/engine/core-modules/workflow/utils/assert-exactly-one-mirror-row-was-written.util';
+import { WorkflowVersionCoreSyncService } from 'src/engine/core-modules/workflow/services/workflow-version-core-sync.service';
+import { buildCoreDispatchIds } from 'src/engine/core-modules/workflow/utils/build-core-dispatch-ids.util';
+import { CommandMenuItemService } from 'src/engine/metadata-modules/command-menu-item/command-menu-item.service';
+import { EngineComponentKey } from 'src/engine/metadata-modules/command-menu-item/enums/engine-component-key.enum';
+import { buildSystemAuthContext } from 'src/engine/twenty-orm/utils/build-system-auth-context.util';
+import { WorkspaceOrmManager } from 'src/engine/twenty-orm/workspace-orm.manager';
+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 { type WorkspaceTransactionScope } from 'src/engine/twenty-orm/types/workspace-transaction-scope.type';
+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 {
+ 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 { WorkflowCommonWorkspaceService } from 'src/modules/workflow/common/workspace-services/workflow-common.workspace-service';
+import { WorkflowVersionValidationWorkspaceService } from 'src/modules/workflow/workflow-builder/workflow-validation/workflow-version-validation.workspace-service';
+import { CodeStepBuildService } from 'src/modules/workflow/workflow-builder/workflow-version-step/code-step/services/code-step-build.service';
+import { type WorkflowAction } from 'src/modules/workflow/workflow-executor/workflow-actions/types/workflow-action.type';
+import { WorkflowRunnerWorkspaceService } from 'src/modules/workflow/workflow-runner/workspace-services/workflow-runner.workspace-service';
+import { WORKFLOW_VERSION_STATUS_UPDATED } from 'src/modules/workflow/workflow-status/constants/workflow-version-status-updated.constants';
+import { type WorkflowVersionStatusUpdate } from 'src/modules/workflow/workflow-status/jobs/workflow-statuses-update.job';
+import { AutomatedTriggerWorkspaceService } from 'src/modules/workflow/workflow-trigger/automated-trigger/automated-trigger.workspace-service';
+import { type DatabaseEventTriggerSettings } from 'src/modules/workflow/workflow-trigger/automated-trigger/constants/automated-trigger-settings';
+import { WORKFLOW_CRON_TRIGGER_CACHE_KEY } from 'src/modules/workflow/workflow-trigger/automated-trigger/crons/constants/workflow-cron-trigger-cache-key.constant';
+import { type CachedCronTrigger } from 'src/modules/workflow/workflow-trigger/automated-trigger/crons/types/cached-cron-trigger.type';
+import {
+ WorkflowTriggerException,
+ WorkflowTriggerExceptionCode,
+} from 'src/modules/workflow/workflow-trigger/exceptions/workflow-trigger.exception';
+import {
+ type WorkflowManualTrigger,
+ WorkflowTriggerType,
+ type WorkflowTrigger,
+} from 'src/modules/workflow/workflow-trigger/types/workflow-trigger.type';
+import { assertPickRecordLoadBalanceConfigIsValid } from 'src/modules/workflow/workflow-trigger/utils/assert-pick-record-load-balance-config-is-valid.util';
+import { assertVersionCanBeActivated } from 'src/modules/workflow/workflow-trigger/utils/assert-version-can-be-activated.util';
+import { computeCronPatternFromSchedule } from 'src/modules/workflow/workflow-trigger/utils/compute-cron-pattern-from-schedule';
+import { getWorkflowCommandMenuItemLabel } from 'src/modules/workflow/workflow-trigger/utils/get-workflow-command-menu-item-label.util';
+import { assertNever } from 'src/utils/assert';
+
+type ResolvedCoreVersion = {
+ coreWorkflowVersion: WorkflowVersionEntity;
+ coreWorkflow: WorkflowEntity;
+ trigger: WorkflowTrigger | null;
+ steps: WorkflowAction[] | null;
+ workspaceWorkflowVersionId: string;
+ workspaceWorkflowId: string;
+};
+
+@Injectable()
+export class CoreWorkflowLifecycleWorkspaceService {
+ private readonly logger = new Logger(
+ CoreWorkflowLifecycleWorkspaceService.name,
+ );
+
+ constructor(
+ @InjectWorkspaceScopedRepository(WorkflowVersionEntity)
+ private readonly coreWorkflowVersionRepository: WorkspaceScopedRepository<WorkflowVersionEntity>,
+ private readonly coreWorkflowIdResolutionService: CoreWorkflowIdResolutionService,
+ private readonly workflowVersionCoreSyncService: WorkflowVersionCoreSyncService,
+ private readonly workflowCommonWorkspaceService: WorkflowCommonWorkspaceService,
+ private readonly workflowVersionValidationWorkspaceService: WorkflowVersionValidationWorkspaceService,
+ private readonly codeStepBuildService: CodeStepBuildService,
+ private readonly automatedTriggerWorkspaceService: AutomatedTriggerWorkspaceService,
+ private readonly commandMenuItemService: CommandMenuItemService,
+ private readonly workflowRunnerWorkspaceService: WorkflowRunnerWorkspaceService,
+ private readonly workspaceEventEmitter: WorkspaceEventEmitter,
+ private readonly workspaceOrmManager: WorkspaceOrmManager,
+ @InjectCacheStorage(CacheStorageNamespace.ModuleWorkflow)
+ private readonly cacheStorageService: CacheStorageService,
+ ) {}
+
+ async validateCoreWorkflowVersion({
+ workspaceId,
+ coreWorkflowVersionId,
+ }: {
+ workspaceId: string;
+ coreWorkflowVersionId: string;
+ }): Promise<boolean> {
+ const coreWorkflowVersion =
+ await this.coreWorkflowVersionRepository.findOne(workspaceId, {
+ where: { id: coreWorkflowVersionId },
+ });
+
+ if (!isDefined(coreWorkflowVersion)) {
+ throw new WorkflowTriggerException(
+ `Core workflow version '${coreWorkflowVersionId}' not found`,
+ WorkflowTriggerExceptionCode.INVALID_WORKFLOW_VERSION,
+ {
+ userFriendlyMessage: msg`Workflow version not found`,
+ },
+ );
+ }
+
+ await this.workflowVersionValidationWorkspaceService.assertWorkflowVersionIsActivableOrThrow(
+ {
+ workspaceId,
+ trigger: coreWorkflowVersion.triggers?.[0] ?? null,
+ steps: coreWorkflowVersion.steps,
+ },
+ );
+
+ return true;
+ }
+
+ async activateCoreWorkflowVersion({
+ workspaceId,
+ coreWorkflowVersionId,
+ }: {
+ workspaceId: string;
+ coreWorkflowVersionId: string;
+ }): Promise<boolean> {
+ const resolved = await this.resolveCoreVersionWithWorkflowOrThrow({
+ workspaceId,
+ coreWorkflowVersionId,
+ });
+
+ const { coreWorkflowVersion, coreWorkflow, trigger, steps } = resolved;
+
+ await this.workflowVersionValidationWorkspaceService.assertWorkflowVersionIsActivableOrThrow(
+ {
+ workspaceId,
+ trigger,
+ steps,
+ },
+ );
+
+ const isLastPublishedVersion =
+ coreWorkflow.lastPublishedCoreWorkflowVersionId ===
+ coreWorkflowVersion.id ||
+ coreWorkflow.lastPublishedVersionId ===
+ resolved.workspaceWorkflowVersionId;
+
+ assertVersionCanBeActivated(
+ {
+ id: coreWorkflowVersion.id,
+ status: this.toWorkspaceVersionStatus(coreWorkflowVersion.status),
+ trigger,
+ steps,
+ },
+ {
+ lastPublishedVersionId: isLastPublishedVersion
+ ? coreWorkflowVersion.id
+ : null,
+ },
+ );
+
+ const { objectIdByNameSingular, flatFieldMetadataMaps } =
+ await this.workflowCommonWorkspaceService.getFlatEntityMaps(workspaceId);
+
+ assertPickRecordLoadBalanceConfigIsValid({
+ steps: steps ?? [],
+ objectIdByNameSingular,
+ flatFieldMetadataMaps,
+ });
+
+ await this.codeStepBuildService.buildCodeStepsFromSourceForSteps({
+ workspaceId,
+ steps: steps ?? [],
+ });
+
+ await this.codeStepBuildService.switchCodeStepLogicFunctionsToPrebuilt({
+ workspaceId,
+ 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`,
+ },
+ );
+ }
+
+ await this.workspaceOrmManager.executeInWorkspaceContext(async () => {
+ await this.workspaceOrmManager.runInWorkspaceTransaction(
+ async (transactionScope) => {
+ if (
+ isDefined(previousPublishedCoreVersionId) &&
+ previousPublishedCoreVersionId !== coreWorkflowVersion.id
+ ) {
+ await this.writeVersionStatusInTransaction({
+ transactionScope,
+ workspaceId,
+ coreWorkflowVersionId: previousPublishedCoreVersionId,
+ 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 this.writeVersionStatusInTransaction({
+ transactionScope,
+ workspaceId,
+ coreWorkflowVersionId: coreWorkflowVersion.id,
+ status: WorkflowVersionStatus.ACTIVE,
+ });
+
+ await this.enableAutomatedTrigger({
+ resolved,
+ transactionScope,
+ });
+ },
+ );
+ }, buildSystemAuthContext(workspaceId));
+
+ await this.writeCronTriggerCacheEntryAfterCommit({ resolved });
+
+ await this.createOrUpdateCommandMenuItem({
+ workspaceId,
+ resolved,
+ });
+
+ await this.workflowVersionCoreSyncService.invalidateAutomatedTriggerMaps(
+ workspaceId,
+ );
+
+ this.emitStatusUpdateEvent({
+ workspaceId,
+ resolved,
+ newStatus: WorkflowVersionStatus.ACTIVE,
+ });
+
+ return true;
+ }
+
+ async deactivateCoreWorkflowVersion({
+ workspaceId,
+ coreWorkflowVersionId,
+ }: {
+ workspaceId: string;
+ coreWorkflowVersionId: string;
+ }): Promise<boolean> {
+ const resolved = await this.resolveCoreVersionWithWorkflowOrThrow({
+ workspaceId,
+ coreWorkflowVersionId,
+ });
+
+ if (
+ resolved.coreWorkflowVersion.status !== CoreWorkflowVersionStatus.ACTIVE
+ ) {
+ return true;
+ }
+
+ await this.deleteCommandMenuItem({ workspaceId, resolved });
+
+ await this.workspaceOrmManager.executeInWorkspaceContext(async () => {
+ await this.workspaceOrmManager.runInWorkspaceTransaction(
+ async (transactionScope) => {
+ await this.writeVersionStatusInTransaction({
+ transactionScope,
+ workspaceId,
+ coreWorkflowVersionId: resolved.coreWorkflowVersion.id,
+ status: WorkflowVersionStatus.DEACTIVATED,
+ });
+
+ await this.disableAutomatedTrigger({
+ resolved,
+ transactionScope,
+ });
+ },
+ );
+ }, buildSystemAuthContext(workspaceId));
+
+ await this.workflowVersionCoreSyncService.invalidateAutomatedTriggerMaps(
+ workspaceId,
+ );
+
+ this.emitStatusUpdateEvent({
+ workspaceId,
+ resolved,
+ newStatus: WorkflowVersionStatus.DEACTIVATED,
+ });
+
+ return true;
+ }
+
+ async runCoreWorkflowVersion({
+ workspaceId,
+ coreWorkflowVersionId,
+ payload,
+ createdBy,
+ workflowRunId,
+ }: {
+ workspaceId: string;
+ coreWorkflowVersionId: string;
+ payload: object;
+ createdBy: ActorMetadata;
+ workflowRunId?: string;
+ }): Promise<{ workflowRunId: string }> {
+ const { workspaceWorkflowVersionId } =
+ await this.coreWorkflowIdResolutionService.resolveWorkspaceVersionIdOrThrow(
+ { workspaceId, coreWorkflowVersionId },
+ );
+
+ return this.workflowRunnerWorkspaceService.run({
+ workspaceId,
+ workflowRunId,
+ workflowVersionId: workspaceWorkflowVersionId,
+ payload,
+ source: createdBy,
+ });
+ }
+
+ private async resolveCoreVersionWithWorkflowOrThrow({
+ workspaceId,
+ coreWorkflowVersionId,
+ }: {
+ workspaceId: string;
+ coreWorkflowVersionId: string;
+ }): Promise<ResolvedCoreVersion> {
+ const { coreWorkflowVersion, workspaceWorkflowVersionId } =
+ await this.coreWorkflowIdResolutionService.resolveWorkspaceVersionIdOrThrow(
+ { workspaceId, coreWorkflowVersionId },
+ );
+
+ if (!isDefined(coreWorkflowVersion.coreWorkflowId)) {
+ throw new WorkflowTriggerException(
+ `Core workflow version '${coreWorkflowVersionId}' is not linked to a core workflow`,
+ WorkflowTriggerExceptionCode.INVALID_WORKFLOW_VERSION,
+ {
+ userFriendlyMessage: msg`Workflow version is not correctly linked, please retry later`,
+ },
+ );
+ }
+
+ const { coreWorkflow, workspaceWorkflowId } =
+ await this.coreWorkflowIdResolutionService.resolveWorkspaceWorkflowIdOrThrow(
+ { workspaceId, coreWorkflowId: coreWorkflowVersion.coreWorkflowId },
+ );
+
+ return {
+ coreWorkflowVersion,
+ coreWorkflow,
+ trigger: coreWorkflowVersion.triggers?.[0] ?? null,
+ steps: coreWorkflowVersion.steps,
+ workspaceWorkflowVersionId,
+ workspaceWorkflowId,
+ };
+ }
+
+ private async findPreviousPublishedCoreVersionId({
+ workspaceId,
+ coreWorkflow,
+ }: {
+ workspaceId: string;
+ coreWorkflow: WorkflowEntity;
+ }): Promise<string | null> {
+ const publishedVersionWhere = isDefined(
+ coreWorkflow.lastPublishedCoreWorkflowVersionId,
+ )
+ ? { id: coreWorkflow.lastPublishedCoreWorkflowVersionId }
+ : isDefined(coreWorkflow.lastPublishedVersionId)
+ ? {
+ workspaceWorkflowVersionId: coreWorkflow.lastPublishedVersionId,
+ }
+ : null;
+
+ const previousPublishedCoreVersion = isDefined(publishedVersionWhere)
+ ? await this.coreWorkflowVersionRepository.findOne(workspaceId, {
+ where: { ...publishedVersionWhere, coreWorkflowId: coreWorkflow.id },
+ })
+ : null;
+
+ if (isDefined(previousPublishedCoreVersion)) {
+ return previousPublishedCoreVersion.id;
+ }
+
+ const currentlyActiveCoreVersion =
+ await this.coreWorkflowVersionRepository.findOne(workspaceId, {
+ where: {
+ coreWorkflowId: coreWorkflow.id,
+ status: CoreWorkflowVersionStatus.ACTIVE,
+ },
+ });
+
+ return currentlyActiveCoreVersion?.id ?? null;
+ }
+
+ private async writeVersionStatusInTransaction({
+ transactionScope,
+ workspaceId,
+ coreWorkflowVersionId,
+ status,
+ }: {
+ transactionScope: WorkspaceTransactionScope;
+ workspaceId: string;
+ 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,
+ })
+ .update({ coreWorkflowVersionId }, { status });
+
+ assertExactlyOneMirrorRowWasWritten({
+ affected: mirrorUpdateResult.affected,
+ coreWorkflowVersionId,
+ });
+ }
+
+ private async enableAutomatedTrigger({
+ resolved,
+ transactionScope,
+ }: {
+ resolved: ResolvedCoreVersion;
+ transactionScope: WorkspaceTransactionScope;
+ }): Promise<void> {
+ const { trigger, workspaceWorkflowId } = resolved;
+ const workspaceId = resolved.coreWorkflowVersion.workspaceId;
+
+ if (!isDefined(trigger)) {
+ return;
+ }
+
+ switch (trigger.type) {
+ case WorkflowTriggerType.MANUAL:
+ case WorkflowTriggerType.WEBHOOK:
+ return;
+ case WorkflowTriggerType.DATABASE_EVENT: {
+ await this.automatedTriggerWorkspaceService.addAutomatedTrigger({
+ workflowId: workspaceWorkflowId,
+ type: AutomatedTriggerType.DATABASE_EVENT,
+ settings: trigger.settings as DatabaseEventTriggerSettings,
+ workspaceId,
+ transactionScope,
+ });
+
+ return;
+ }
+ case WorkflowTriggerType.CRON: {
+ const pattern = computeCronPatternFromSchedule(trigger);
+
+ await this.automatedTriggerWorkspaceService.addAutomatedTrigger({
+ workflowId: workspaceWorkflowId,
+ type: AutomatedTriggerType.CRON,
+ settings: { pattern },
+ workspaceId,
+ transactionScope,
+ });
+
+ return;
+ }
+ default:
+ assertNever(trigger);
+ }
+ }
+
+ private async writeCronTriggerCacheEntryAfterCommit({
+ resolved,
+ }: {
+ resolved: ResolvedCoreVersion;
+ }): Promise<void> {
+ const { trigger, workspaceWorkflowId, workspaceWorkflowVersionId } =
+ resolved;
+
+ if (!isDefined(trigger) || trigger.type !== WorkflowTriggerType.CRON) {
+ return;
+ }
+
+ const cachedTrigger: CachedCronTrigger = {
+ workspaceId: resolved.coreWorkflowVersion.workspaceId,
+ workflowId: workspaceWorkflowId,
+ pattern: computeCronPatternFromSchedule(trigger),
+ ...buildCoreDispatchIds({
+ coreWorkflowVersionId: resolved.coreWorkflowVersion.id,
+ workspaceWorkflowVersionId,
+ }),
+ };
+
+ try {
+ await this.cacheStorageService.hashSetIfExists({
+ key: WORKFLOW_CRON_TRIGGER_CACHE_KEY,
+ field: workspaceWorkflowId,
+ value: JSON.stringify(cachedTrigger),
+ });
+ } catch (error) {
+ this.logger.error(
+ `Cron trigger cache entry not published for workflow ${workspaceWorkflowId}, 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);
+ }
+ }
+ }
+
+ private async disableAutomatedTrigger({
+ resolved,
+ transactionScope,
+ }: {
+ resolved: ResolvedCoreVersion;
+ transactionScope: WorkspaceTransactionScope;
+ }): Promise<void> {
+ const { trigger, workspaceWorkflowId } = resolved;
+ const workspaceId = resolved.coreWorkflowVersion.workspaceId;
+
+ if (!isDefined(trigger)) {
+ return;
+ }
+
+ switch (trigger.type) {
+ case WorkflowTriggerType.DATABASE_EVENT:
+ await this.automatedTriggerWorkspaceService.deleteAutomatedTrigger({
+ workflowId: workspaceWorkflowId,
+ workspaceId,
+ transactionScope,
+ });
+
+ return;
+ case WorkflowTriggerType.CRON:
+ await this.automatedTriggerWorkspaceService.deleteAutomatedTrigger({
+ workflowId: workspaceWorkflowId,
+ workspaceId,
+ transactionScope,
+ });
+
+ await this.cacheStorageService.hashDelete({
+ key: WORKFLOW_CRON_TRIGGER_CACHE_KEY,
+ field: workspaceWorkflowId,
+ });
+
+ return;
+ case WorkflowTriggerType.MANUAL:
+ case WorkflowTriggerType.WEBHOOK:
+ return;
+ default:
+ assertNever(trigger);
+ }
+ }
+
+ private async createOrUpdateCommandMenuItem({
+ workspaceId,
+ resolved,
+ }: {
+ workspaceId: string;
+ resolved: ResolvedCoreVersion;
+ }): Promise<void> {
+ const { trigger } = resolved;
+
+ if (!isDefined(trigger) || trigger.type !== WorkflowTriggerType.MANUAL) {
+ return;
+ }
+
+ const { availabilityType, availabilityObjectMetadataId } =
+ await this.resolveManualTriggerAvailability({ trigger, workspaceId });
+
+ const label = getWorkflowCommandMenuItemLabel({
+ name: resolved.coreWorkflow.name,
+ });
+
+ const existingCommandMenuItem =
+ await this.commandMenuItemService.findByWorkflowVersionId(
+ resolved.workspaceWorkflowVersionId,
+ workspaceId,
+ );
+
+ if (isDefined(existingCommandMenuItem)) {
+ await this.commandMenuItemService.update(
+ {
+ id: existingCommandMenuItem.id,
+ label,
+ shortLabel: label,
+ icon: trigger.settings.icon,
+ isPinned: trigger.settings.isPinned,
+ availabilityType,
+ availabilityObjectMetadataId,
+ },
+ workspaceId,
+ );
+ } else {
+ await this.commandMenuItemService.create(
+ {
+ workflowVersionId: resolved.workspaceWorkflowVersionId,
+ coreWorkflowVersionId: resolved.coreWorkflowVersion.id,
+ engineComponentKey: EngineComponentKey.TRIGGER_WORKFLOW_VERSION,
+ label,
+ shortLabel: label,
+ icon: trigger.settings.icon,
+ isPinned: trigger.settings.isPinned,
+ availabilityType,
+ availabilityObjectMetadataId,
+ },
+ workspaceId,
+ );
+ }
+ }
+
+ private async deleteCommandMenuItem({
+ workspaceId,
+ resolved,
+ }: {
+ workspaceId: string;
+ resolved: ResolvedCoreVersion;
+ }): Promise<void> {
+ const { trigger } = resolved;
+
+ if (!isDefined(trigger) || trigger.type !== WorkflowTriggerType.MANUAL) {
+ return;
+ }
+
+ const existingCommandMenuItem =
+ await this.commandMenuItemService.findByWorkflowVersionId(
+ resolved.workspaceWorkflowVersionId,
+ workspaceId,
+ );
+
+ if (isDefined(existingCommandMenuItem)) {
+ await this.commandMenuItemService.delete(
+ existingCommandMenuItem.id,
+ workspaceId,
+ );
+ }
+ }
+
+ private async resolveManualTriggerAvailability({
+ trigger,
+ workspaceId,
+ }: {
+ trigger: WorkflowManualTrigger;
+ workspaceId: string;
+ }): Promise<{
+ availabilityType: CommandMenuItemAvailabilityType;
+ availabilityObjectMetadataId: string | undefined;
+ }> {
+ const availability = trigger.settings.availability;
+
+ let availabilityType = CommandMenuItemAvailabilityType.GLOBAL;
+ let availabilityObjectMetadataId: string | undefined;
+
+ if (isDefined(availability)) {
+ switch (availability.type) {
+ case 'GLOBAL':
+ availabilityType = CommandMenuItemAvailabilityType.GLOBAL;
+ break;
+ case 'SINGLE_RECORD':
+ case 'BULK_RECORDS': {
+ availabilityType = CommandMenuItemAvailabilityType.RECORD_SELECTION;
+
+ const { objectIdByNameSingular } =
+ await this.workflowCommonWorkspaceService.getFlatEntityMaps(
+ workspaceId,
+ );
+
+ const objectId =
+ objectIdByNameSingular[availability.objectNameSingular];
+
+ if (!isDefined(objectId)) {
+ throw new WorkflowTriggerException(
+ `Object metadata not found for object: ${availability.objectNameSingular}`,
+ WorkflowTriggerExceptionCode.INVALID_WORKFLOW_VERSION,
+ );
+ }
+
+ availabilityObjectMetadataId = objectId;
+ break;
+ }
+ }
+ }
+
+ return { availabilityType, availabilityObjectMetadataId };
+ }
+
+ private toWorkspaceVersionStatus(
+ status: CoreWorkflowVersionStatus,
+ ): WorkflowVersionStatus {
+ return WorkflowVersionStatus[status];
+ }
+
+ private emitStatusUpdateEvent({
+ workspaceId,
+ resolved,
+ newStatus,
+ }: {
+ workspaceId: string;
+ resolved: ResolvedCoreVersion;
+ newStatus: WorkflowVersionStatus;
+ }): void {
+ this.workspaceEventEmitter.emitCustomBatchEvent<WorkflowVersionStatusUpdate>(
+ WORKFLOW_VERSION_STATUS_UPDATED,
+ [
+ {
+ workflowId: resolved.workspaceWorkflowId,
+ workflowVersionId: resolved.workspaceWorkflowVersionId,
+ previousStatus: this.toWorkspaceVersionStatus(
+ resolved.coreWorkflowVersion.status,
+ ),
+ newStatus,
+ },
+ ],
+ workspaceId,
+ );
+ }
+}
diff --git a/packages/twenty-server/src/engine/core-modules/workflow/services/core-workflow-list.service.ts b/packages/twenty-server/src/engine/core-modules/workflow/services/core-workflow-list.service.ts
index 7b99f73c447..e3b84dcbd3d 100644
--- a/packages/twenty-server/src/engine/core-modules/workflow/services/core-workflow-list.service.ts
+++ b/packages/twenty-server/src/engine/core-modules/workflow/services/core-workflow-list.service.ts
@@ -18,9 +18,6 @@ import {
import { buildCoreWorkflowFilterPredicate } from 'src/engine/core-modules/workflow/utils/build-core-workflow-filter-predicate.util';
import { computeCoreWorkflowStatuses } from 'src/engine/core-modules/workflow/utils/compute-core-workflow-statuses.util';
-import { escapeIdentifier } from 'src/engine/workspace-manager/workspace-migration/utils/remove-sql-injection.util';
-import { getWorkspaceSchemaName } from 'src/engine/workspace-datasource/utils/get-workspace-schema-name.util';
-
type CoreWorkflowRow = {
createdAt: Date;
id: string;
@@ -88,11 +85,10 @@ const toCoreWorkflowDTO = (row: CoreWorkflowRow): CoreWorkflowDTO => ({
updatedAt: row.updatedAt.toISOString(),
});
-const buildWorkflowVersionsJoinClause = (schemaName: string) =>
- `LEFT JOIN ${schemaName}."workflow" wf
- ON wf."coreWorkflowId" = c.id AND wf."deletedAt" IS NULL
- LEFT JOIN core."workflowVersion" v
- ON v."workflowId" = wf.id AND v."workspaceId" = $1`;
+const CORE_WORKFLOW_VERSIONS_JOIN_CLAUSE = `LEFT JOIN core."workflowVersion" v
+ ON v."coreWorkflowId" = c.id AND v."workspaceId" = $1`;
+
+const GROUP_BY_CLAUSE = `${GROUPED_WORKFLOW_COLUMNS}, c."lastPublishedVersionId", c."applicationId", c."workspaceWorkflowId"`;
@Injectable()
export class CoreWorkflowListService {
@@ -105,7 +101,6 @@ export class CoreWorkflowListService {
workspaceId: string,
{ first, after, orderBy, orderByDirection, filter }: CoreWorkflowsArgs,
): Promise<CoreWorkflowConnectionDTO> {
- const schemaName = escapeIdentifier(getWorkspaceSchemaName(workspaceId));
const { column, cursorExpression, nullable, cast } =
SORT_COLUMN_BY_FIELD[orderBy];
const isAscending = orderByDirection === CoreWorkflowOrderByDirection.ASC;
@@ -157,13 +152,13 @@ export class CoreWorkflowListService {
`SELECT
c.id,
${cursorExpression} AS "cursorSortValue",
- min(wf.id::text) AS "workspaceWorkflowId",
+ c."workspaceWorkflowId",
${CORE_WORKFLOW_AGGREGATE_COLUMNS}
FROM core."workflow" c
- ${buildWorkflowVersionsJoinClause(schemaName)}
+ ${CORE_WORKFLOW_VERSIONS_JOIN_CLAUSE}
WHERE c."workspaceId" = $1
${keysetCondition}
- GROUP BY ${GROUPED_WORKFLOW_COLUMNS}, c."lastPublishedVersionId", c."applicationId"
+ GROUP BY ${GROUP_BY_CLAUSE}
${havingClause}
ORDER BY ${column} ${direction}${nullsClause}, c.id ${direction}
LIMIT ${limitParameter}`,
@@ -172,7 +167,6 @@ export class CoreWorkflowListService {
const totalCount = await this.countByWorkspaceId({
workspaceId,
- schemaName,
filterPredicate,
filterParameters,
});
@@ -198,6 +192,20 @@ export class CoreWorkflowListService {
};
}
+ async findOneById({
+ workspaceId,
+ coreWorkflowId,
+ }: {
+ workspaceId: string;
+ coreWorkflowId: string;
+ }): Promise<CoreWorkflowDTO | null> {
+ return this.findOneByFilterExpression({
+ workspaceId,
+ filterExpression: 'c.id = $2',
+ filterParameter: coreWorkflowId,
+ });
+ }
+
async findOneByWorkspaceWorkflowId({
workspaceId,
workspaceWorkflowId,
@@ -205,24 +213,34 @@ export class CoreWorkflowListService {
workspaceId: string;
workspaceWorkflowId: string;
}): Promise<CoreWorkflowDTO | null> {
- const schemaName = escapeIdentifier(getWorkspaceSchemaName(workspaceId));
+ return this.findOneByFilterExpression({
+ workspaceId,
+ filterExpression: 'c."workspaceWorkflowId" = $2',
+ filterParameter: workspaceWorkflowId,
+ });
+ }
+ private async findOneByFilterExpression({
+ workspaceId,
+ filterExpression,
+ filterParameter,
+ }: {
+ workspaceId: string;
+ filterExpression: string;
+ filterParameter: string;
+ }): Promise<CoreWorkflowDTO | null> {
const rows: CoreWorkflowRow[] = await this.coreDataSource.query(
`SELECT
c.id,
null AS "cursorSortValue",
- wf.id::text AS "workspaceWorkflowId",
+ c."workspaceWorkflowId",
${CORE_WORKFLOW_AGGREGATE_COLUMNS}
FROM core."workflow" c
- JOIN ${schemaName}."workflow" wf
- ON wf."coreWorkflowId" = c.id
- AND wf."deletedAt" IS NULL
- AND wf.id = $2
- LEFT JOIN core."workflowVersion" v
- ON v."workflowId" = wf.id AND v."workspaceId" = $1
+ ${CORE_WORKFLOW_VERSIONS_JOIN_CLAUSE}
WHERE c."workspaceId" = $1
- GROUP BY ${GROUPED_WORKFLOW_COLUMNS}, c."lastPublishedVersionId", c."applicationId", wf.id`,
- [workspaceId, workspaceWorkflowId],
+ AND ${filterExpression}
+ GROUP BY ${GROUP_BY_CLAUSE}`,
+ [workspaceId, filterParameter],
);
const [row] = rows;
@@ -236,12 +254,10 @@ export class CoreWorkflowListService {
private async countByWorkspaceId({
workspaceId,
- schemaName,
filterPredicate,
filterParameters,
}: {
workspaceId: string;
- schemaName: string;
filterPredicate?: string;
filterParameters: unknown[];
}): Promise<number> {
@@ -267,7 +283,7 @@ export class CoreWorkflowListService {
FROM (
SELECT c.id
FROM core."workflow" c
- ${buildWorkflowVersionsJoinClause(schemaName)}
+ ${CORE_WORKFLOW_VERSIONS_JOIN_CLAUSE}
WHERE c."workspaceId" = $1
GROUP BY ${GROUPED_WORKFLOW_COLUMNS}
HAVING ${filterPredicate}
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.ts
index fb87fbeb6d4..132c7aee6ca 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
@@ -1,6 +1,6 @@
import { Injectable, Logger } from '@nestjs/common';
-import { In, IsNull, Not } from 'typeorm';
+import { In } from 'typeorm';
import { msg } from '@lingui/core/macro';
import { isDefined } from 'twenty-shared/utils';
import { v4 as uuidv4 } from 'uuid';
@@ -10,7 +10,18 @@ import { type AuthContextUser } from 'src/engine/core-modules/auth/types/auth-co
import { RecordPositionService } from 'src/engine/core-modules/record-position/services/record-position.service';
import { type CoreWorkflowDTO } from 'src/engine/core-modules/workflow/dtos/core-workflow.dto';
import { type DeletedCoreWorkflowDTO } from 'src/engine/core-modules/workflow/dtos/deleted-core-workflow.dto';
+import { type DiscardCoreWorkflowDraftInput } from 'src/engine/core-modules/workflow/dtos/discard-core-workflow-draft.input';
+import {
+ WorkflowVersionEntity,
+ WorkflowVersionStatus as CoreWorkflowVersionStatus,
+} from 'src/engine/core-modules/workflow/entities/workflow-version.entity';
import { WorkflowEntity } from 'src/engine/core-modules/workflow/entities/workflow.entity';
+import { CommandMenuItemService } from 'src/engine/metadata-modules/command-menu-item/command-menu-item.service';
+import { getWorkflowCommandMenuItemLabel } from 'src/modules/workflow/workflow-trigger/utils/get-workflow-command-menu-item-label.util';
+import { CoreWorkflowIdResolutionService } from 'src/engine/core-modules/workflow/services/core-workflow-id-resolution.service';
+import { CoreWorkflowListService } from 'src/engine/core-modules/workflow/services/core-workflow-list.service';
+import { CoreWorkflowVersionWriteService } from 'src/engine/core-modules/workflow/services/core-workflow-version-write.service';
+import { assertExactlyOneMirrorRowWasWritten } from 'src/engine/core-modules/workflow/utils/assert-exactly-one-mirror-row-was-written.util';
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 { buildSystemAuthContext } from 'src/engine/twenty-orm/utils/build-system-auth-context.util';
@@ -21,23 +32,17 @@ import {
WorkflowQueryValidationException,
WorkflowQueryValidationExceptionCode,
} from 'src/modules/workflow/common/exceptions/workflow-query-validation.exception';
-import { assertWorkflowVersionIsDraft } from 'src/modules/workflow/common/utils/assert-workflow-version-is-draft.util';
-import {
- WorkflowVersionStatus,
- type WorkflowVersionWorkspaceEntity,
-} from 'src/modules/workflow/common/standard-objects/workflow-version.workspace-entity';
+import { type WorkflowVersionWorkspaceEntity } from 'src/modules/workflow/common/standard-objects/workflow-version.workspace-entity';
import {
WorkflowStatus,
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 { remapDuplicatedStepDestinations } from 'src/modules/workflow/workflow-builder/utils/remap-duplicated-step-destinations.util';
+import { WorkflowVersionStepOperationsWorkspaceService } from 'src/modules/workflow/workflow-builder/workflow-version-step/workflow-version-step-operations.workspace-service';
+import { type WorkflowAction } from 'src/modules/workflow/workflow-executor/workflow-actions/types/workflow-action.type';
import { type WorkspaceMemberWorkspaceEntity } from 'src/modules/workspace-member/standard-objects/workspace-member.workspace-entity';
-type DiscardDraftVersionOutcome =
- | { status: 'versionNotFound' }
- | { status: 'alreadyDiscarded' }
- | { status: 'discarded'; workflowId: string };
-
@Injectable()
export class CoreWorkflowMutationWorkspaceService {
private readonly logger = new Logger(
@@ -50,10 +55,258 @@ export class CoreWorkflowMutationWorkspaceService {
private readonly workflowCoreSyncService: WorkflowCoreSyncService,
private readonly workflowVersionCoreSyncService: WorkflowVersionCoreSyncService,
private readonly workflowCommonWorkspaceService: WorkflowCommonWorkspaceService,
+ private readonly coreWorkflowIdResolutionService: CoreWorkflowIdResolutionService,
+ private readonly commandMenuItemService: CommandMenuItemService,
+ private readonly coreWorkflowListService: CoreWorkflowListService,
+ private readonly coreWorkflowVersionWriteService: CoreWorkflowVersionWriteService,
+ private readonly workflowVersionStepOperationsWorkspaceService: WorkflowVersionStepOperationsWorkspaceService,
+ @InjectWorkspaceScopedRepository(WorkflowVersionEntity)
+ private readonly coreWorkflowVersionRepository: WorkspaceScopedRepository<WorkflowVersionEntity>,
private readonly workspaceOrmManager: WorkspaceOrmManager,
private readonly recordPositionService: RecordPositionService,
) {}
+ async duplicateWorkflow({
+ workspaceId,
+ user,
+ coreWorkflowIdToDuplicate,
+ coreWorkflowVersionIdToCopy,
+ }: {
+ workspaceId: string;
+ user: AuthContextUser;
+ coreWorkflowIdToDuplicate: string;
+ coreWorkflowVersionIdToCopy: string;
+ }): Promise<CoreWorkflowDTO> {
+ const { coreWorkflow: sourceCoreWorkflow } =
+ await this.coreWorkflowIdResolutionService.resolveWorkspaceWorkflowIdOrThrow(
+ { workspaceId, coreWorkflowId: coreWorkflowIdToDuplicate },
+ );
+
+ const sourceVersion = await this.coreWorkflowVersionRepository.findOne(
+ workspaceId,
+ {
+ where: {
+ id: coreWorkflowVersionIdToCopy,
+ coreWorkflowId: coreWorkflowIdToDuplicate,
+ },
+ },
+ );
+
+ const sourceTrigger = sourceVersion?.triggers?.[0];
+
+ if (!isDefined(sourceVersion) || !isDefined(sourceTrigger)) {
+ throw new WorkflowQueryValidationException(
+ `Core workflow version '${coreWorkflowVersionIdToCopy}' to copy not found or has no trigger`,
+ WorkflowQueryValidationExceptionCode.FORBIDDEN,
+ {
+ userFriendlyMessage: msg`Workflow version to copy not found`,
+ },
+ );
+ }
+
+ const { trigger: remappedTrigger, steps: remappedSteps } =
+ await this.cloneVersionContent({
+ workspaceId,
+ trigger: sourceTrigger,
+ steps: sourceVersion.steps ?? [],
+ });
+
+ const duplicatedWorkflow = await this.createWorkflow(workspaceId, user, {
+ name: `${sourceCoreWorkflow.name ?? ''} (Duplicate)`,
+ });
+
+ try {
+ return await this.writeDuplicatedContentAndReturn({
+ workspaceId,
+ duplicatedCoreWorkflowId: duplicatedWorkflow.id,
+ trigger: remappedTrigger,
+ steps: remappedSteps,
+ });
+ } catch (error) {
+ try {
+ await this.deleteWorkflows(workspaceId, {
+ coreWorkflowIds: [duplicatedWorkflow.id],
+ });
+ } catch (cleanupError) {
+ this.logger.error(cleanupError);
+ }
+
+ throw error;
+ }
+ }
+
+ private async writeDuplicatedContentAndReturn({
+ workspaceId,
+ duplicatedCoreWorkflowId,
+ trigger,
+ steps,
+ }: {
+ workspaceId: string;
+ duplicatedCoreWorkflowId: string;
+ trigger: NonNullable<WorkflowVersionEntity['triggers']>[number];
+ steps: WorkflowAction[];
+ }): Promise<CoreWorkflowDTO> {
+ const initialDraft = await this.coreWorkflowVersionRepository.findOne(
+ workspaceId,
+ {
+ where: {
+ coreWorkflowId: duplicatedCoreWorkflowId,
+ status: CoreWorkflowVersionStatus.DRAFT,
+ },
+ },
+ );
+
+ if (!isDefined(initialDraft)) {
+ throw new WorkflowQueryValidationException(
+ `Duplicated core workflow '${duplicatedCoreWorkflowId}' has no initial draft version`,
+ WorkflowQueryValidationExceptionCode.FORBIDDEN,
+ {
+ userFriendlyMessage: msg`Workflow duplication failed, please retry`,
+ },
+ );
+ }
+
+ await this.coreWorkflowVersionWriteService.writeContentAndMirror({
+ workspaceId,
+ coreWorkflowVersionId: initialDraft.id,
+ trigger,
+ steps,
+ });
+
+ const duplicatedCoreWorkflow =
+ await this.coreWorkflowListService.findOneById({
+ workspaceId,
+ coreWorkflowId: duplicatedCoreWorkflowId,
+ });
+
+ if (!isDefined(duplicatedCoreWorkflow)) {
+ throw new WorkflowQueryValidationException(
+ `Core row '${duplicatedCoreWorkflowId}' of the duplicated workflow not found`,
+ WorkflowQueryValidationExceptionCode.FORBIDDEN,
+ {
+ userFriendlyMessage: msg`Workflow duplication failed, please retry`,
+ },
+ );
+ }
+
+ return duplicatedCoreWorkflow;
+ }
+
+ private async cloneVersionContent({
+ workspaceId,
+ trigger,
+ steps,
+ }: {
+ workspaceId: string;
+ trigger: NonNullable<WorkflowVersionEntity['triggers']>[number];
+ steps: WorkflowAction[];
+ }) {
+ const sourceToClonedPairs: {
+ source: WorkflowAction;
+ duplicated: WorkflowAction;
+ }[] = [];
+ const clonedStepIdBySourceStepId = new Map<string, string>();
+
+ for (const step of steps) {
+ const clonedStep =
+ await this.workflowVersionStepOperationsWorkspaceService.cloneStep({
+ step,
+ workspaceId,
+ });
+
+ sourceToClonedPairs.push({ source: step, duplicated: clonedStep });
+ clonedStepIdBySourceStepId.set(step.id, clonedStep.id);
+ }
+
+ return remapDuplicatedStepDestinations({
+ trigger,
+ sourceToClonedPairs,
+ clonedStepIdBySourceStepId,
+ });
+ }
+
+ async updateWorkflow(
+ workspaceId: string,
+ { coreWorkflowId, name }: { coreWorkflowId: string; name: string },
+ ): Promise<void> {
+ const { workspaceWorkflowId } =
+ await this.coreWorkflowIdResolutionService.resolveWorkspaceWorkflowIdOrThrow(
+ { workspaceId, coreWorkflowId },
+ );
+
+ 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 });
+ },
+ );
+ }, buildSystemAuthContext(workspaceId));
+
+ await this.syncCommandMenuItemLabelFromCore({
+ workspaceId,
+ coreWorkflowId,
+ name,
+ });
+ }
+
+ private async syncCommandMenuItemLabelFromCore({
+ workspaceId,
+ coreWorkflowId,
+ name,
+ }: {
+ workspaceId: string;
+ coreWorkflowId: string;
+ name: string;
+ }): Promise<void> {
+ const coreWorkflow = await this.coreWorkflowRepository.findOne(
+ workspaceId,
+ {
+ where: { id: coreWorkflowId },
+ select: { id: true, lastPublishedCoreWorkflowVersionId: true },
+ },
+ );
+
+ const publishedCoreVersionId =
+ coreWorkflow?.lastPublishedCoreWorkflowVersionId;
+
+ if (!isDefined(publishedCoreVersionId)) {
+ return;
+ }
+
+ const existingCommandMenuItem =
+ await this.commandMenuItemService.findByCoreWorkflowVersionId(
+ publishedCoreVersionId,
+ workspaceId,
+ );
+
+ if (!isDefined(existingCommandMenuItem)) {
+ return;
+ }
+
+ const label = getWorkflowCommandMenuItemLabel({ name });
+
+ if (
+ existingCommandMenuItem.label === label &&
+ existingCommandMenuItem.shortLabel === label
+ ) {
+ return;
+ }
+
+ await this.commandMenuItemService.update(
+ { id: existingCommandMenuItem.id, label, shortLabel: label },
+ workspaceId,
+ );
+ }
+
async createWorkflow(
workspaceId: string,
user: AuthContextUser,
@@ -158,43 +411,43 @@ export class CoreWorkflowMutationWorkspaceService {
workspaceId: string,
{ coreWorkflowIds }: { coreWorkflowIds: string[] },
): Promise<DeletedCoreWorkflowDTO[]> {
- const authContext = buildSystemAuthContext(workspaceId);
+ const coreWorkflowsToDelete = await this.coreWorkflowRepository.find(
+ workspaceId,
+ {
+ where: { id: In(coreWorkflowIds) },
+ select: { id: true, workspaceWorkflowId: true },
+ },
+ );
- const workflowsToDelete =
- await this.workspaceOrmManager.executeInWorkspaceContext(async () => {
- const workflowRepository =
- this.workspaceOrmManager.getRepository<WorkflowWorkspaceEntity>(
- 'workflow',
- { shouldBypassPermissionChecks: true },
- );
+ const deletedCoreWorkflows = coreWorkflowsToDelete
+ .map(({ id, workspaceWorkflowId }) =>
+ isDefined(workspaceWorkflowId)
+ ? { id, workspaceWorkflowId }
+ : undefined,
+ )
+ .filter(isDefined);
- return workflowRepository.find({
- where: { coreWorkflowId: In(coreWorkflowIds) },
- withDeleted: true,
- });
- }, authContext);
+ const mirrorWorkflowIds = await this.findMirrorWorkflowIdsToDelete({
+ workspaceId,
+ coreWorkflowIds,
+ knownMirrorWorkflowIds: deletedCoreWorkflows.map(
+ ({ workspaceWorkflowId }) => workspaceWorkflowId,
+ ),
+ });
- const liveWorkflowsToDelete = workflowsToDelete.filter(
- (workflow) => !isDefined(workflow.deletedAt),
- );
+ if (mirrorWorkflowIds.length > 0) {
+ const authContext = buildSystemAuthContext(workspaceId);
- if (workflowsToDelete.length > 0) {
- if (liveWorkflowsToDelete.length > 0) {
- await this.workspaceOrmManager.executeInWorkspaceContext(async () => {
- const workflowRepository =
- this.workspaceOrmManager.getRepository<WorkflowWorkspaceEntity>(
- 'workflow',
- { shouldBypassPermissionChecks: true },
- );
-
- await workflowRepository.softDelete({
- id: In(liveWorkflowsToDelete.map((workflow) => workflow.id)),
- });
- }, authContext);
- }
+ await this.workspaceOrmManager.executeInWorkspaceContext(async () => {
+ await this.workspaceOrmManager
+ .getRepository<WorkflowWorkspaceEntity>('workflow', {
+ shouldBypassPermissionChecks: true,
+ })
+ .softDelete({ id: In(mirrorWorkflowIds) });
+ }, authContext);
await this.workflowCommonWorkspaceService.handleWorkflowSubEntities({
- workflowIds: workflowsToDelete.map((workflow) => workflow.id),
+ workflowIds: mirrorWorkflowIds,
workspaceId,
operation: 'delete',
});
@@ -205,94 +458,195 @@ export class CoreWorkflowMutationWorkspaceService {
coreWorkflowIds,
);
- return liveWorkflowsToDelete
- .map((workflow) =>
- isDefined(workflow.coreWorkflowId)
- ? { id: workflow.coreWorkflowId, workspaceWorkflowId: workflow.id }
- : undefined,
- )
- .filter(isDefined);
+ return deletedCoreWorkflows;
+ }
+
+ private async findMirrorWorkflowIdsToDelete({
+ workspaceId,
+ coreWorkflowIds,
+ knownMirrorWorkflowIds,
+ }: {
+ workspaceId: string;
+ coreWorkflowIds: string[];
+ knownMirrorWorkflowIds: string[];
+ }): Promise<string[]> {
+ const mirrorWorkflows =
+ await this.workspaceOrmManager.executeInWorkspaceContext(
+ async () =>
+ this.workspaceOrmManager
+ .getRepository<WorkflowWorkspaceEntity>('workflow', {
+ shouldBypassPermissionChecks: true,
+ })
+ .find({
+ where: { coreWorkflowId: In(coreWorkflowIds) },
+ select: { id: true },
+ withDeleted: true,
+ }),
+ buildSystemAuthContext(workspaceId),
+ );
+
+ return [
+ ...new Set([
+ ...knownMirrorWorkflowIds,
+ ...mirrorWorkflows.map(({ id }) => id),
+ ]),
+ ];
}
async discardDraftVersion(
workspaceId: string,
- { workspaceWorkflowVersionId }: { workspaceWorkflowVersionId: string },
+ {
+ workspaceWorkflowVersionId,
+ coreWorkflowVersionId,
+ }: DiscardCoreWorkflowDraftInput,
): Promise<string | null> {
- const authContext = buildSystemAuthContext(workspaceId);
+ if (
+ isDefined(workspaceWorkflowVersionId) &&
+ isDefined(coreWorkflowVersionId)
+ ) {
+ throw new WorkflowQueryValidationException(
+ 'Only one of workspaceWorkflowVersionId or coreWorkflowVersionId may be provided',
+ WorkflowQueryValidationExceptionCode.FORBIDDEN,
+ {
+ userFriendlyMessage: msg`Only one workflow version identifier may be provided`,
+ },
+ );
+ }
- const outcome: DiscardDraftVersionOutcome =
- await this.workspaceOrmManager.executeInWorkspaceContext(async () => {
- const workflowVersionRepository =
- this.workspaceOrmManager.getRepository<WorkflowVersionWorkspaceEntity>(
- 'workflowVersion',
- { shouldBypassPermissionChecks: true },
- );
+ const resolvedCoreVersionId = await this.resolveDiscardTargetCoreVersionId(
+ workspaceId,
+ { workspaceWorkflowVersionId, coreWorkflowVersionId },
+ );
- const version = await workflowVersionRepository.findOne({
- where: { id: workspaceWorkflowVersionId },
- withDeleted: true,
- });
+ if (!isDefined(resolvedCoreVersionId)) {
+ return null;
+ }
- if (!isDefined(version)) {
- return { status: 'versionNotFound' };
- }
+ const coreVersion = await this.coreWorkflowVersionRepository.findOne(
+ workspaceId,
+ { where: { id: resolvedCoreVersionId } },
+ );
- if (isDefined(version.deletedAt)) {
- return { status: 'alreadyDiscarded' };
- }
+ if (!isDefined(coreVersion)) {
+ return null;
+ }
- assertWorkflowVersionIsDraft(version);
+ if (coreVersion.status !== CoreWorkflowVersionStatus.DRAFT) {
+ throw new WorkflowQueryValidationException(
+ 'Workflow version is not in draft status',
+ WorkflowQueryValidationExceptionCode.FORBIDDEN,
+ {
+ userFriendlyMessage: msg`Workflow version is not in draft status`,
+ },
+ );
+ }
- const otherLiveVersionsExist = await workflowVersionRepository.exists({
- where: {
- workflowId: version.workflowId,
- deletedAt: IsNull(),
- id: Not(workspaceWorkflowVersionId),
- },
- });
+ if (!isDefined(coreVersion.coreWorkflowId)) {
+ throw new WorkflowQueryValidationException(
+ `Core workflow version '${coreVersion.id}' is not linked to a core workflow`,
+ WorkflowQueryValidationExceptionCode.FORBIDDEN,
+ {
+ userFriendlyMessage: msg`Workflow version is not correctly linked to its workflow`,
+ },
+ );
+ }
- if (!otherLiveVersionsExist) {
- throw new WorkflowQueryValidationException(
- 'The initial version of a workflow can not be deleted',
- WorkflowQueryValidationExceptionCode.FORBIDDEN,
- {
- userFriendlyMessage: msg`The initial version of a workflow can not be deleted`,
- },
- );
- }
+ const siblingCount = await this.coreWorkflowVersionRepository.count(
+ workspaceId,
+ { where: { coreWorkflowId: coreVersion.coreWorkflowId } },
+ );
- const softDeleteResult = await workflowVersionRepository.softDelete({
- id: workspaceWorkflowVersionId,
- status: WorkflowVersionStatus.DRAFT,
- });
+ if (siblingCount <= 1) {
+ throw new WorkflowQueryValidationException(
+ 'The initial version of a workflow can not be deleted',
+ WorkflowQueryValidationExceptionCode.FORBIDDEN,
+ {
+ userFriendlyMessage: msg`The initial version of a workflow can not be deleted`,
+ },
+ );
+ }
- if (softDeleteResult.affected === 0) {
- throw new WorkflowQueryValidationException(
- 'Workflow version is not in draft status',
- WorkflowQueryValidationExceptionCode.FORBIDDEN,
- {
- userFriendlyMessage: msg`Workflow version is not in draft status`,
- },
+ await this.workspaceOrmManager.executeInWorkspaceContext(async () => {
+ await this.workspaceOrmManager.runInWorkspaceTransaction(
+ async (transactionScope) => {
+ await transactionScope.executeRawQuery(
+ `DELETE FROM core."workflowVersion" WHERE "id" = $1 AND "workspaceId" = $2`,
+ [coreVersion.id, workspaceId],
);
- }
- return { status: 'discarded', workflowId: version.workflowId };
- }, authContext);
+ const mirrorDeleteResult = await transactionScope
+ .getRepository<WorkflowVersionWorkspaceEntity>('workflowVersion', {
+ shouldBypassPermissionChecks: true,
+ })
+ .softDelete({ coreWorkflowVersionId: coreVersion.id });
- if (outcome.status === 'versionNotFound') {
- return null;
- }
+ assertExactlyOneMirrorRowWasWritten({
+ affected: mirrorDeleteResult.affected,
+ coreWorkflowVersionId: coreVersion.id,
+ });
+ },
+ );
+ }, buildSystemAuthContext(workspaceId));
- await this.workflowVersionCoreSyncService.deleteCoreVersionsByWorkspaceVersionIds(
+ await this.workflowVersionCoreSyncService.invalidateAutomatedTriggerMaps(
workspaceId,
- [workspaceWorkflowVersionId],
);
- if (outcome.status === 'alreadyDiscarded') {
- return null;
+ return coreVersion.coreWorkflowId;
+ }
+
+ private async resolveDiscardTargetCoreVersionId(
+ workspaceId: string,
+ {
+ workspaceWorkflowVersionId,
+ coreWorkflowVersionId,
+ }: DiscardCoreWorkflowDraftInput,
+ ): Promise<string | null> {
+ if (isDefined(coreWorkflowVersionId)) {
+ return coreWorkflowVersionId;
+ }
+
+ if (!isDefined(workspaceWorkflowVersionId)) {
+ throw new WorkflowQueryValidationException(
+ 'Either workspaceWorkflowVersionId or coreWorkflowVersionId must be provided',
+ WorkflowQueryValidationExceptionCode.FORBIDDEN,
+ {
+ userFriendlyMessage: msg`Workflow version is missing from the request`,
+ },
+ );
}
- return outcome.workflowId;
+ return this.workspaceOrmManager.executeInWorkspaceContext(async () => {
+ const workflowVersionRepository =
+ this.workspaceOrmManager.getRepository<WorkflowVersionWorkspaceEntity>(
+ 'workflowVersion',
+ { shouldBypassPermissionChecks: true },
+ );
+
+ const workspaceVersion = await workflowVersionRepository.findOne({
+ where: { id: workspaceWorkflowVersionId },
+ withDeleted: true,
+ });
+
+ if (
+ !isDefined(workspaceVersion) ||
+ isDefined(workspaceVersion.deletedAt)
+ ) {
+ return null;
+ }
+
+ if (!isDefined(workspaceVersion.coreWorkflowVersionId)) {
+ throw new WorkflowQueryValidationException(
+ `Workspace version '${workspaceWorkflowVersionId}' has no core twin`,
+ WorkflowQueryValidationExceptionCode.FORBIDDEN,
+ {
+ userFriendlyMessage: msg`Workflow version is not correctly linked to its mirror`,
+ },
+ );
+ }
+
+ return workspaceVersion.coreWorkflowVersionId;
+ }, buildSystemAuthContext(workspaceId));
}
private async rollbackCreatedWorkflow(
diff --git a/packages/twenty-server/src/engine/core-modules/workflow/services/core-workflow-version-list.service.ts b/packages/twenty-server/src/engine/core-modules/workflow/services/core-workflow-version-list.service.ts
index a1502857ecb..42d7f2500ad 100644
--- a/packages/twenty-server/src/engine/core-modules/workflow/services/core-workflow-version-list.service.ts
+++ b/packages/twenty-server/src/engine/core-modules/workflow/services/core-workflow-version-list.service.ts
@@ -1,23 +1,25 @@
import { Injectable } from '@nestjs/common';
+import { InjectDataSource } from '@nestjs/typeorm';
import { isDefined } from 'twenty-shared/utils';
-import { In } from 'typeorm';
+import { DataSource } from 'typeorm';
import { WorkflowVersionEntity } from 'src/engine/core-modules/workflow/entities/workflow-version.entity';
+import { WorkflowEntity } from 'src/engine/core-modules/workflow/entities/workflow.entity';
import { type CoreWorkflowVersionDTO } from 'src/engine/core-modules/workflow/dtos/core-workflow-version.dto';
import { buildCoreWorkflowVersionLabel } from 'src/engine/core-modules/workflow/utils/build-core-workflow-version-label.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 { WorkspaceOrmManager } from 'src/engine/twenty-orm/workspace-orm.manager';
-import { buildSystemAuthContext } from 'src/engine/twenty-orm/utils/build-system-auth-context.util';
-import { type WorkflowVersionWorkspaceEntity } from 'src/modules/workflow/common/standard-objects/workflow-version.workspace-entity';
@Injectable()
export class CoreWorkflowVersionListService {
constructor(
@InjectWorkspaceScopedRepository(WorkflowVersionEntity)
private readonly coreWorkflowVersionRepository: WorkspaceScopedRepository<WorkflowVersionEntity>,
- private readonly workspaceOrmManager: WorkspaceOrmManager,
+ @InjectWorkspaceScopedRepository(WorkflowEntity)
+ private readonly coreWorkflowRepository: WorkspaceScopedRepository<WorkflowEntity>,
+ @InjectDataSource()
+ private readonly coreDataSource: DataSource,
) {}
async findManyByWorkspaceWorkflowId({
@@ -32,26 +34,23 @@ export class CoreWorkflowVersionListService {
{
where: { workflowId: workspaceWorkflowId },
order: { createdAt: 'ASC', id: 'ASC' },
- select: { id: true, status: true, createdAt: true, updatedAt: true },
+ select: {
+ id: true,
+ status: true,
+ createdAt: true,
+ updatedAt: true,
+ workspaceWorkflowVersionId: true,
+ },
},
);
- const workspaceVersionIdByCoreVersionId =
- await this.findWorkspaceVersionIdByCoreVersionId({
- workspaceId,
- workspaceWorkflowId,
- coreWorkflowVersionIds: coreWorkflowVersions.map(
- (coreWorkflowVersion) => coreWorkflowVersion.id,
- ),
- });
-
return coreWorkflowVersions
.map((coreWorkflowVersion, index) => ({
id: coreWorkflowVersion.id,
label: buildCoreWorkflowVersionLabel(index + 1),
status: coreWorkflowVersion.status,
workspaceWorkflowVersionId:
- workspaceVersionIdByCoreVersionId[coreWorkflowVersion.id] ?? null,
+ coreWorkflowVersion.workspaceWorkflowVersionId,
workspaceWorkflowId,
trigger: null,
steps: null,
@@ -68,94 +67,136 @@ export class CoreWorkflowVersionListService {
workspaceId: string;
workspaceWorkflowVersionId: string;
}): Promise<CoreWorkflowVersionDTO | null> {
- const authContext = buildSystemAuthContext(workspaceId);
-
- const workspaceWorkflowVersion =
- await this.workspaceOrmManager.executeInWorkspaceContext(
- async () =>
- this.workspaceOrmManager
- .getRepository<WorkflowVersionWorkspaceEntity>('workflowVersion', {
- shouldBypassPermissionChecks: true,
- })
- .findOne({
- where: { id: workspaceWorkflowVersionId },
- select: { id: true, workflowId: true },
- }),
- authContext,
- );
-
- if (!isDefined(workspaceWorkflowVersion)) {
+ const coreWorkflowVersion =
+ await this.coreWorkflowVersionRepository.findOne(workspaceId, {
+ where: { workspaceWorkflowVersionId },
+ select: { id: true },
+ });
+
+ if (!isDefined(coreWorkflowVersion)) {
return null;
}
- const coreWorkflowVersions = await this.findManyByWorkspaceWorkflowId({
+ return this.findOneByCoreWorkflowVersionId({
workspaceId,
- workspaceWorkflowId: workspaceWorkflowVersion.workflowId,
+ coreWorkflowVersionId: coreWorkflowVersion.id,
});
+ }
- const coreWorkflowVersionMetadata = coreWorkflowVersions.find(
- (coreWorkflowVersion) =>
- coreWorkflowVersion.workspaceWorkflowVersionId ===
- workspaceWorkflowVersionId,
+ async findManyByCoreWorkflowId({
+ workspaceId,
+ coreWorkflowId,
+ }: {
+ workspaceId: string;
+ coreWorkflowId: string;
+ }): Promise<CoreWorkflowVersionDTO[]> {
+ const coreWorkflow = await this.coreWorkflowRepository.findOne(
+ workspaceId,
+ {
+ where: { id: coreWorkflowId },
+ select: { id: true, workspaceWorkflowId: true },
+ },
);
- if (!isDefined(coreWorkflowVersionMetadata)) {
- return null;
+ if (!isDefined(coreWorkflow)) {
+ return [];
}
- const coreWorkflowVersionContent =
+ const coreWorkflowVersions = await this.coreWorkflowVersionRepository.find(
+ workspaceId,
+ {
+ where: { coreWorkflowId },
+ order: { createdAt: 'ASC', id: 'ASC' },
+ select: {
+ id: true,
+ status: true,
+ createdAt: true,
+ updatedAt: true,
+ workspaceWorkflowVersionId: true,
+ },
+ },
+ );
+
+ return coreWorkflowVersions
+ .map((coreWorkflowVersion, index) => ({
+ id: coreWorkflowVersion.id,
+ label: buildCoreWorkflowVersionLabel(index + 1),
+ status: coreWorkflowVersion.status,
+ workspaceWorkflowVersionId:
+ coreWorkflowVersion.workspaceWorkflowVersionId,
+ workspaceWorkflowId: coreWorkflow.workspaceWorkflowId,
+ trigger: null,
+ steps: null,
+ createdAt: coreWorkflowVersion.createdAt.toISOString(),
+ updatedAt: coreWorkflowVersion.updatedAt.toISOString(),
+ }))
+ .reverse();
+ }
+
+ async findOneByCoreWorkflowVersionId({
+ workspaceId,
+ coreWorkflowVersionId,
+ }: {
+ workspaceId: string;
+ coreWorkflowVersionId: string;
+ }): Promise<CoreWorkflowVersionDTO | null> {
+ const coreWorkflowVersion =
await this.coreWorkflowVersionRepository.findOne(workspaceId, {
- where: { id: coreWorkflowVersionMetadata.id },
- select: { id: true, triggers: true, steps: true },
+ where: { id: coreWorkflowVersionId },
});
+ if (!isDefined(coreWorkflowVersion?.coreWorkflowId)) {
+ return null;
+ }
+
+ const coreWorkflow = await this.coreWorkflowRepository.findOne(
+ workspaceId,
+ {
+ where: { id: coreWorkflowVersion.coreWorkflowId },
+ select: { id: true, workspaceWorkflowId: true },
+ },
+ );
+
+ const versionRank = await this.computeCoreWorkflowVersionRank({
+ workspaceId,
+ coreWorkflowId: coreWorkflowVersion.coreWorkflowId,
+ coreWorkflowVersionId: coreWorkflowVersion.id,
+ });
+
return {
- ...coreWorkflowVersionMetadata,
- trigger: coreWorkflowVersionContent?.triggers?.[0] ?? null,
- steps: coreWorkflowVersionContent?.steps ?? null,
+ id: coreWorkflowVersion.id,
+ label: buildCoreWorkflowVersionLabel(versionRank),
+ status: coreWorkflowVersion.status,
+ workspaceWorkflowVersionId:
+ coreWorkflowVersion.workspaceWorkflowVersionId,
+ workspaceWorkflowId: coreWorkflow?.workspaceWorkflowId ?? null,
+ trigger: coreWorkflowVersion.triggers?.[0] ?? null,
+ steps: coreWorkflowVersion.steps ?? null,
+ createdAt: coreWorkflowVersion.createdAt.toISOString(),
+ updatedAt: coreWorkflowVersion.updatedAt.toISOString(),
};
}
- private async findWorkspaceVersionIdByCoreVersionId({
+ private async computeCoreWorkflowVersionRank({
workspaceId,
- workspaceWorkflowId,
- coreWorkflowVersionIds,
+ coreWorkflowId,
+ coreWorkflowVersionId,
}: {
workspaceId: string;
- workspaceWorkflowId: string;
- coreWorkflowVersionIds: string[];
- }): Promise<Record<string, string>> {
- if (coreWorkflowVersionIds.length === 0) {
- return {};
- }
+ coreWorkflowId: string;
+ coreWorkflowVersionId: string;
+ }): Promise<number> {
+ const [{ rank }]: [{ rank: number }] = await this.coreDataSource.query(
+ `SELECT count(*)::int AS "rank"
+ FROM core."workflowVersion" sibling
+ JOIN core."workflowVersion" target
+ ON target."id" = $2 AND target."workspaceId" = $1
+ WHERE sibling."coreWorkflowId" = $3
+ AND sibling."workspaceId" = $1
+ AND (sibling."createdAt", sibling."id") <= (target."createdAt", target."id")`,
+ [workspaceId, coreWorkflowVersionId, coreWorkflowId],
+ );
- const authContext = buildSystemAuthContext(workspaceId);
-
- return this.workspaceOrmManager.executeInWorkspaceContext(async () => {
- const workspaceWorkflowVersions = await this.workspaceOrmManager
- .getRepository<WorkflowVersionWorkspaceEntity>('workflowVersion', {
- shouldBypassPermissionChecks: true,
- })
- .find({
- where: {
- workflowId: workspaceWorkflowId,
- coreWorkflowVersionId: In(coreWorkflowVersionIds),
- },
- select: { id: true, coreWorkflowVersionId: true },
- });
-
- return Object.fromEntries(
- workspaceWorkflowVersions.flatMap((workspaceWorkflowVersion) =>
- isDefined(workspaceWorkflowVersion.coreWorkflowVersionId)
- ? [
- [
- workspaceWorkflowVersion.coreWorkflowVersionId,
- workspaceWorkflowVersion.id,
- ],
- ]
- : [],
- ),
- );
- }, authContext);
+ return rank;
}
}
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.ts
new file mode 100644
index 00000000000..90440f4959a
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/workflow/services/core-workflow-version-mutation.workspace-service.ts
@@ -0,0 +1,805 @@
+import { Injectable } from '@nestjs/common';
+
+import { msg } from '@lingui/core/macro';
+import { isDefined, isNonEmptyArray } from 'twenty-shared/utils';
+import { TRIGGER_STEP_ID } from 'twenty-shared/workflow';
+
+import { type CoreWorkflowVersionDTO } from 'src/engine/core-modules/workflow/dtos/core-workflow-version.dto';
+import { type CreateCoreWorkflowVersionStepInput } from 'src/engine/core-modules/workflow/dtos/create-core-workflow-version-step.input';
+import { type WorkflowStepPositionUpdateInput } from 'src/engine/core-modules/workflow/dtos/update-workflow-step-position-update.input';
+import { type WorkflowActionDTO } from 'src/engine/core-modules/workflow/dtos/workflow-action.dto';
+import { type WorkflowVersionStepChangesDTO } from 'src/engine/core-modules/workflow/dtos/workflow-version-step-changes.dto';
+import { type WorkflowVersionTriggerDTO } from 'src/engine/core-modules/workflow/dtos/workflow-version-trigger.dto';
+import {
+ WorkflowVersionEntity,
+ WorkflowVersionStatus as CoreWorkflowVersionStatus,
+} 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 { 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';
+import {
+ WorkflowQueryValidationException,
+ WorkflowQueryValidationExceptionCode,
+} from 'src/modules/workflow/common/exceptions/workflow-query-validation.exception';
+import {
+ WorkflowVersionEdgeException,
+ WorkflowVersionEdgeExceptionCode,
+} from 'src/modules/workflow/common/exceptions/workflow-version-edge.exception';
+import {
+ WorkflowVersionStepException,
+ WorkflowVersionStepExceptionCode,
+} from 'src/modules/workflow/common/exceptions/workflow-version-step.exception';
+import { computeWorkflowVersionStepChanges } from 'src/modules/workflow/workflow-builder/utils/compute-workflow-version-step-updates.util';
+import { WorkflowSchemaWorkspaceService } from 'src/modules/workflow/workflow-builder/workflow-schema/workflow-schema.workspace-service';
+import {
+ assertEdgeConnectionOptionsAreSupported,
+ buildSourceStepWithAddedEdge,
+ buildSourceStepWithRemovedEdge,
+} from 'src/modules/workflow/workflow-builder/workflow-version-edge/utils/build-updated-source-step-for-edge.util';
+import { type WorkflowStepConnectionOptions } from 'src/modules/workflow/workflow-builder/workflow-version-step/types/WorkflowStepConnectionOptions';
+import { getNextStepIdsForStepTypeChange } from 'src/modules/workflow/workflow-builder/workflow-version-step/utils/get-next-step-ids-for-step-type-change.util';
+import { insertStep } from 'src/modules/workflow/workflow-builder/workflow-version-step/utils/insert-step';
+import { removeStep } from 'src/modules/workflow/workflow-builder/workflow-version-step/utils/remove-step';
+import { WorkflowVersionStepOperationsWorkspaceService } from 'src/modules/workflow/workflow-builder/workflow-version-step/workflow-version-step-operations.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 { WithLock } from 'src/engine/core-modules/cache-lock/with-lock.decorator';
+
+@Injectable()
+export class CoreWorkflowVersionMutationWorkspaceService {
+ constructor(
+ @InjectWorkspaceScopedRepository(WorkflowVersionEntity)
+ private readonly coreWorkflowVersionRepository: WorkspaceScopedRepository<WorkflowVersionEntity>,
+ private readonly coreWorkflowIdResolutionService: CoreWorkflowIdResolutionService,
+ private readonly coreWorkflowVersionWriteService: CoreWorkflowVersionWriteService,
+ private readonly coreWorkflowVersionListService: CoreWorkflowVersionListService,
+ private readonly workflowCoreSyncService: WorkflowCoreSyncService,
+ private readonly workflowVersionStepOperationsWorkspaceService: WorkflowVersionStepOperationsWorkspaceService,
+ private readonly workflowSchemaWorkspaceService: WorkflowSchemaWorkspaceService,
+ ) {}
+
+ async createStep({
+ workspaceId,
+ input,
+ }: {
+ workspaceId: string;
+ input: CreateCoreWorkflowVersionStepInput;
+ }): Promise<WorkflowVersionStepChangesDTO> {
+ const {
+ coreWorkflowVersionId,
+ stepType,
+ parentStepId,
+ nextStepId,
+ position,
+ parentStepConnectionOptions,
+ id,
+ defaultSettings,
+ } = input;
+
+ const { trigger, steps } =
+ await this.coreWorkflowVersionWriteService.getValidatedDraftCoreWorkflowVersion(
+ { workspaceId, coreWorkflowVersionId },
+ );
+
+ const { builtStep, additionalCreatedSteps } =
+ await this.workflowVersionStepOperationsWorkspaceService.runStepCreationSideEffectsAndBuildStep(
+ {
+ type: stepType,
+ workspaceId,
+ position,
+ id,
+ defaultSettings,
+ },
+ );
+
+ const enrichedNewStep =
+ await this.workflowSchemaWorkspaceService.enrichOutputSchema({
+ step: builtStep,
+ workspaceId,
+ workflowVersionContent: { trigger, steps },
+ });
+
+ const { updatedSteps, updatedTrigger } = insertStep({
+ existingSteps: steps ?? [],
+ existingTrigger: trigger,
+ insertedStep: enrichedNewStep,
+ additionalCreatedSteps,
+ parentStepId,
+ nextStepId,
+ parentStepConnectionOptions,
+ });
+
+ await this.coreWorkflowVersionWriteService.writeContentAndMirror({
+ workspaceId,
+ coreWorkflowVersionId,
+ trigger: updatedTrigger === trigger ? undefined : updatedTrigger,
+ steps: updatedSteps,
+ });
+
+ return computeWorkflowVersionStepChanges({
+ existingTrigger: trigger,
+ existingSteps: steps,
+ updatedTrigger,
+ updatedSteps,
+ });
+ }
+
+ async duplicateStep({
+ workspaceId,
+ coreWorkflowVersionId,
+ stepId,
+ }: {
+ workspaceId: string;
+ coreWorkflowVersionId: string;
+ stepId: string;
+ }): Promise<WorkflowVersionStepChangesDTO> {
+ const { trigger, steps } =
+ await this.coreWorkflowVersionWriteService.getValidatedDraftCoreWorkflowVersion(
+ { workspaceId, coreWorkflowVersionId },
+ );
+
+ const stepToDuplicate = steps?.find((step) => step.id === stepId);
+
+ if (!isDefined(stepToDuplicate)) {
+ throw new WorkflowVersionStepException(
+ 'Step not found',
+ WorkflowVersionStepExceptionCode.NOT_FOUND,
+ );
+ }
+
+ const clonedStep =
+ await this.workflowVersionStepOperationsWorkspaceService.cloneStep({
+ step: stepToDuplicate,
+ workspaceId,
+ });
+
+ const duplicatedStep =
+ this.workflowVersionStepOperationsWorkspaceService.markStepAsDuplicate({
+ step: clonedStep,
+ });
+
+ const { updatedSteps, updatedTrigger } = insertStep({
+ existingSteps: steps ?? [],
+ existingTrigger: trigger,
+ insertedStep: duplicatedStep,
+ });
+
+ await this.coreWorkflowVersionWriteService.writeContentAndMirror({
+ workspaceId,
+ coreWorkflowVersionId,
+ steps: updatedSteps,
+ });
+
+ return computeWorkflowVersionStepChanges({
+ existingTrigger: trigger,
+ existingSteps: steps,
+ updatedTrigger,
+ updatedSteps,
+ });
+ }
+
+ async updateStep({
+ workspaceId,
+ coreWorkflowVersionId,
+ step,
+ }: {
+ workspaceId: string;
+ coreWorkflowVersionId: string;
+ step: WorkflowAction;
+ }): Promise<WorkflowActionDTO> {
+ const { trigger, steps } =
+ await this.coreWorkflowVersionWriteService.getValidatedDraftCoreWorkflowVersion(
+ { workspaceId, coreWorkflowVersionId },
+ );
+
+ if (!isDefined(steps)) {
+ throw new WorkflowVersionStepException(
+ "Can't update step from undefined steps",
+ WorkflowVersionStepExceptionCode.INVALID_REQUEST,
+ );
+ }
+
+ const existingStep = steps.find(
+ (candidateStep) => candidateStep.id === step.id,
+ );
+
+ if (!isDefined(existingStep)) {
+ throw new WorkflowVersionStepException(
+ 'Step not found',
+ WorkflowVersionStepExceptionCode.NOT_FOUND,
+ );
+ }
+
+ const isStepTypeChanged = existingStep.type !== step.type;
+
+ const { updatedStep, additionalCreatedSteps } = isStepTypeChanged
+ ? await this.rebuildStepForTypeChange({
+ existingStep,
+ newStep: step,
+ workspaceId,
+ workflowVersionContent: { trigger, steps },
+ })
+ : {
+ updatedStep:
+ await this.workflowSchemaWorkspaceService.enrichOutputSchema({
+ step,
+ workspaceId,
+ workflowVersionContent: { trigger, steps },
+ }),
+ additionalCreatedSteps: undefined,
+ };
+
+ const updatedSteps = steps.map((candidateStep) =>
+ candidateStep.id === step.id ? updatedStep : candidateStep,
+ );
+
+ if (isDefined(additionalCreatedSteps)) {
+ updatedSteps.push(...additionalCreatedSteps);
+ }
+
+ await this.coreWorkflowVersionWriteService.writeContentAndMirror({
+ workspaceId,
+ coreWorkflowVersionId,
+ steps: updatedSteps,
+ });
+
+ return updatedStep;
+ }
+
+ async updateTrigger({
+ workspaceId,
+ coreWorkflowVersionId,
+ trigger,
+ }: {
+ workspaceId: string;
+ coreWorkflowVersionId: string;
+ trigger: WorkflowTrigger;
+ }): Promise<WorkflowVersionTriggerDTO> {
+ await this.coreWorkflowVersionWriteService.getValidatedDraftCoreWorkflowVersion(
+ { workspaceId, coreWorkflowVersionId },
+ );
+
+ await this.coreWorkflowVersionWriteService.writeContentAndMirror({
+ workspaceId,
+ coreWorkflowVersionId,
+ trigger,
+ });
+
+ return { trigger };
+ }
+
+ async deleteStep({
+ workspaceId,
+ coreWorkflowVersionId,
+ stepIdToDelete,
+ }: {
+ workspaceId: string;
+ coreWorkflowVersionId: string;
+ stepIdToDelete: string;
+ }): Promise<WorkflowVersionStepChangesDTO> {
+ const { trigger, steps } =
+ await this.coreWorkflowVersionWriteService.getValidatedDraftCoreWorkflowVersion(
+ { workspaceId, coreWorkflowVersionId },
+ );
+
+ const isDeletingTrigger =
+ stepIdToDelete === TRIGGER_STEP_ID && isDefined(trigger);
+
+ if (!isDeletingTrigger && !isDefined(steps)) {
+ throw new WorkflowVersionStepException(
+ "Can't delete step from undefined steps",
+ WorkflowVersionStepExceptionCode.INVALID_REQUEST,
+ );
+ }
+
+ const stepToDelete = steps?.find((step) => step.id === stepIdToDelete);
+
+ if (!isDeletingTrigger && !isDefined(stepToDelete)) {
+ throw new WorkflowVersionStepException(
+ "Can't delete not existing step",
+ WorkflowVersionStepExceptionCode.NOT_FOUND,
+ );
+ }
+
+ const stepToDeleteChildrenIds = isDeletingTrigger
+ ? (trigger?.nextStepIds ?? [])
+ : (stepToDelete?.nextStepIds ?? []);
+
+ const { updatedSteps, updatedTrigger, removedStepIds } = removeStep({
+ existingTrigger: trigger,
+ existingSteps: steps,
+ stepIdToDelete,
+ stepToDeleteChildrenIds,
+ });
+
+ await this.coreWorkflowVersionWriteService.writeContentAndMirror({
+ workspaceId,
+ coreWorkflowVersionId,
+ trigger: updatedTrigger === trigger ? undefined : updatedTrigger,
+ steps: updatedSteps === steps ? undefined : (updatedSteps ?? null),
+ });
+
+ const removedSteps =
+ steps?.filter((step) => removedStepIds.includes(step.id)) ?? [];
+
+ await Promise.all(
+ removedSteps.map((step) =>
+ this.workflowVersionStepOperationsWorkspaceService.runWorkflowVersionStepDeletionSideEffects(
+ {
+ step,
+ workspaceId,
+ },
+ ),
+ ),
+ );
+
+ return computeWorkflowVersionStepChanges({
+ existingTrigger: trigger,
+ existingSteps: steps,
+ updatedTrigger,
+ updatedSteps,
+ });
+ }
+
+ async createEdge({
+ workspaceId,
+ coreWorkflowVersionId,
+ source,
+ target,
+ sourceConnectionOptions,
+ }: {
+ workspaceId: string;
+ coreWorkflowVersionId: string;
+ source: string;
+ target: string;
+ sourceConnectionOptions?: WorkflowStepConnectionOptions;
+ }): Promise<WorkflowVersionStepChangesDTO> {
+ assertEdgeConnectionOptionsAreSupported(sourceConnectionOptions);
+
+ const { trigger, steps } = await this.getValidatedDraftWithTargetStep({
+ workspaceId,
+ coreWorkflowVersionId,
+ target,
+ });
+
+ if (source === TRIGGER_STEP_ID) {
+ if (!isDefined(trigger)) {
+ throw new WorkflowVersionEdgeException(
+ `Trigger not found in core workflow version '${coreWorkflowVersionId}'`,
+ WorkflowVersionEdgeExceptionCode.NOT_FOUND,
+ );
+ }
+
+ if (trigger.nextStepIds?.includes(target)) {
+ return computeWorkflowVersionStepChanges({
+ existingTrigger: trigger,
+ existingSteps: steps,
+ });
+ }
+
+ const updatedTrigger = {
+ ...trigger,
+ nextStepIds: [...(trigger.nextStepIds ?? []), target],
+ };
+
+ await this.coreWorkflowVersionWriteService.writeContentAndMirror({
+ workspaceId,
+ coreWorkflowVersionId,
+ trigger: updatedTrigger,
+ });
+
+ return computeWorkflowVersionStepChanges({
+ existingTrigger: trigger,
+ existingSteps: steps,
+ updatedTrigger,
+ });
+ }
+
+ const sourceStep = this.getSourceStepOrThrow({
+ steps,
+ source,
+ coreWorkflowVersionId,
+ });
+
+ if (
+ sourceStep.nextStepIds?.includes(target) &&
+ !isDefined(sourceConnectionOptions)
+ ) {
+ return computeWorkflowVersionStepChanges({
+ existingTrigger: trigger,
+ existingSteps: steps,
+ });
+ }
+
+ const { updatedSourceStep, shouldPersist } = buildSourceStepWithAddedEdge({
+ sourceStep,
+ target,
+ sourceConnectionOptions,
+ });
+
+ const updatedSteps = (steps ?? []).map((step) =>
+ step.id === source ? updatedSourceStep : step,
+ );
+
+ if (shouldPersist) {
+ await this.coreWorkflowVersionWriteService.writeContentAndMirror({
+ workspaceId,
+ coreWorkflowVersionId,
+ steps: updatedSteps,
+ });
+ }
+
+ return computeWorkflowVersionStepChanges({
+ existingTrigger: trigger,
+ existingSteps: steps,
+ updatedSteps,
+ });
+ }
+
+ async deleteEdge({
+ workspaceId,
+ coreWorkflowVersionId,
+ source,
+ target,
+ sourceConnectionOptions,
+ }: {
+ workspaceId: string;
+ coreWorkflowVersionId: string;
+ source: string;
+ target: string;
+ sourceConnectionOptions?: WorkflowStepConnectionOptions;
+ }): Promise<WorkflowVersionStepChangesDTO> {
+ assertEdgeConnectionOptionsAreSupported(sourceConnectionOptions);
+
+ const { trigger, steps } = await this.getValidatedDraftWithTargetStep({
+ workspaceId,
+ coreWorkflowVersionId,
+ target,
+ });
+
+ if (source === TRIGGER_STEP_ID) {
+ if (!isDefined(trigger)) {
+ throw new WorkflowVersionEdgeException(
+ `Trigger not found in core workflow version '${coreWorkflowVersionId}'`,
+ WorkflowVersionEdgeExceptionCode.NOT_FOUND,
+ );
+ }
+
+ if (!trigger.nextStepIds?.includes(target)) {
+ return computeWorkflowVersionStepChanges({
+ existingTrigger: trigger,
+ existingSteps: steps,
+ });
+ }
+
+ const updatedTrigger = {
+ ...trigger,
+ nextStepIds: trigger.nextStepIds?.filter(
+ (nextStepId) => nextStepId !== target,
+ ),
+ };
+
+ await this.coreWorkflowVersionWriteService.writeContentAndMirror({
+ workspaceId,
+ coreWorkflowVersionId,
+ trigger: updatedTrigger,
+ });
+
+ return computeWorkflowVersionStepChanges({
+ existingTrigger: trigger,
+ existingSteps: steps,
+ updatedTrigger,
+ });
+ }
+
+ const sourceStep = this.getSourceStepOrThrow({
+ steps,
+ source,
+ coreWorkflowVersionId,
+ });
+
+ if (
+ !sourceStep.nextStepIds?.includes(target) &&
+ !isDefined(sourceConnectionOptions)
+ ) {
+ return computeWorkflowVersionStepChanges({
+ existingTrigger: trigger,
+ existingSteps: steps,
+ });
+ }
+
+ const { updatedSourceStep, shouldPersist } = buildSourceStepWithRemovedEdge(
+ {
+ sourceStep,
+ target,
+ sourceConnectionOptions,
+ },
+ );
+
+ if (!shouldPersist) {
+ return computeWorkflowVersionStepChanges({
+ existingTrigger: trigger,
+ existingSteps: steps,
+ });
+ }
+
+ const updatedSteps = (steps ?? []).map((step) =>
+ step.id === source ? updatedSourceStep : step,
+ );
+
+ await this.coreWorkflowVersionWriteService.writeContentAndMirror({
+ workspaceId,
+ coreWorkflowVersionId,
+ steps: updatedSteps,
+ });
+
+ return computeWorkflowVersionStepChanges({
+ existingTrigger: trigger,
+ existingSteps: steps,
+ updatedSteps,
+ });
+ }
+
+ async updatePositions({
+ workspaceId,
+ coreWorkflowVersionId,
+ positions,
+ }: {
+ workspaceId: string;
+ coreWorkflowVersionId: string;
+ positions: WorkflowStepPositionUpdateInput[];
+ }): Promise<void> {
+ const { trigger, steps } =
+ await this.coreWorkflowVersionWriteService.getValidatedDraftCoreWorkflowVersion(
+ { workspaceId, coreWorkflowVersionId },
+ );
+
+ const triggerPosition = positions.find(
+ (position) => position.id === TRIGGER_STEP_ID,
+ );
+
+ const updatedTrigger =
+ isDefined(triggerPosition) && isDefined(trigger)
+ ? { ...trigger, position: triggerPosition.position }
+ : undefined;
+
+ const updatedSteps = steps?.map((step) => {
+ const stepPosition = positions.find(
+ (position) => position.id === step.id,
+ );
+
+ return isDefined(stepPosition)
+ ? { ...step, position: stepPosition.position }
+ : step;
+ });
+
+ await this.coreWorkflowVersionWriteService.writeContentAndMirror({
+ workspaceId,
+ coreWorkflowVersionId,
+ trigger: updatedTrigger,
+ steps: updatedSteps,
+ });
+ }
+
+ @WithLock('coreWorkflowId')
+ async createDraftFromCoreWorkflowVersion({
+ workspaceId,
+ coreWorkflowId,
+ coreWorkflowVersionIdToCopy,
+ }: {
+ workspaceId: string;
+ coreWorkflowId: string;
+ coreWorkflowVersionIdToCopy: string;
+ }): Promise<CoreWorkflowVersionDTO> {
+ const { coreWorkflow, workspaceWorkflowId } =
+ await this.coreWorkflowIdResolutionService.resolveWorkspaceWorkflowIdOrThrow(
+ { workspaceId, coreWorkflowId },
+ );
+
+ const versionToCopy = await this.coreWorkflowVersionRepository.findOne(
+ workspaceId,
+ { where: { id: coreWorkflowVersionIdToCopy, coreWorkflowId } },
+ );
+
+ if (!isDefined(versionToCopy)) {
+ throw new WorkflowVersionStepException(
+ 'WorkflowVersion to copy not found',
+ WorkflowVersionStepExceptionCode.NOT_FOUND,
+ );
+ }
+
+ const triggerToCopy = versionToCopy.triggers?.[0];
+
+ if (
+ !isDefined(triggerToCopy) ||
+ !isNonEmptyArray(versionToCopy.steps ?? [])
+ ) {
+ throw new WorkflowVersionStepException(
+ 'WorkflowVersion to copy has no trigger or no steps',
+ WorkflowVersionStepExceptionCode.INVALID_REQUEST,
+ );
+ }
+
+ const copiedSteps: WorkflowAction[] = [];
+
+ for (const step of versionToCopy.steps ?? []) {
+ copiedSteps.push(
+ await this.workflowVersionStepOperationsWorkspaceService.createDraftStep(
+ {
+ step,
+ workspaceId,
+ },
+ ),
+ );
+ }
+
+ const existingDraft = await this.coreWorkflowVersionRepository.findOne(
+ workspaceId,
+ { where: { coreWorkflowId, status: CoreWorkflowVersionStatus.DRAFT } },
+ );
+
+ if (isDefined(existingDraft)) {
+ await this.coreWorkflowVersionWriteService.writeContentAndMirror({
+ workspaceId,
+ coreWorkflowVersionId: existingDraft.id,
+ trigger: triggerToCopy,
+ steps: copiedSteps,
+ });
+
+ return this.findCoreVersionDTOOrThrow({
+ workspaceId,
+ coreWorkflowVersionId: existingDraft.id,
+ });
+ }
+
+ const applicationId =
+ await this.workflowCoreSyncService.getCustomApplicationIdOrThrow(
+ workspaceId,
+ );
+
+ const { coreWorkflowVersionId } =
+ await this.coreWorkflowVersionWriteService.createDraftCoreWorkflowVersionAndMirror(
+ {
+ workspaceId,
+ coreWorkflowId: coreWorkflow.id,
+ workspaceWorkflowId,
+ applicationId,
+ trigger: triggerToCopy,
+ steps: copiedSteps,
+ },
+ );
+
+ return this.findCoreVersionDTOOrThrow({
+ workspaceId,
+ coreWorkflowVersionId,
+ });
+ }
+
+ private async rebuildStepForTypeChange({
+ existingStep,
+ newStep,
+ workspaceId,
+ workflowVersionContent,
+ }: {
+ existingStep: WorkflowAction;
+ newStep: WorkflowAction;
+ workspaceId: string;
+ workflowVersionContent: {
+ trigger: WorkflowTrigger | null;
+ steps: WorkflowAction[] | null;
+ };
+ }): Promise<{
+ updatedStep: WorkflowAction;
+ additionalCreatedSteps?: WorkflowAction[];
+ }> {
+ await this.workflowVersionStepOperationsWorkspaceService.runWorkflowVersionStepDeletionSideEffects(
+ {
+ step: existingStep,
+ workspaceId,
+ },
+ );
+
+ const { builtStep, additionalCreatedSteps } =
+ await this.workflowVersionStepOperationsWorkspaceService.runStepCreationSideEffectsAndBuildStep(
+ {
+ type: newStep.type,
+ workspaceId,
+ position: newStep.position,
+ defaultSettings: newStep.settings,
+ },
+ );
+
+ const updatedStep =
+ await this.workflowSchemaWorkspaceService.enrichOutputSchema({
+ step: {
+ ...builtStep,
+ id: existingStep.id,
+ nextStepIds: getNextStepIdsForStepTypeChange({
+ existingStep,
+ builtStep,
+ }),
+ position: existingStep.position,
+ },
+ workspaceId,
+ workflowVersionContent,
+ });
+
+ return { updatedStep, additionalCreatedSteps };
+ }
+
+ private async getValidatedDraftWithTargetStep({
+ workspaceId,
+ coreWorkflowVersionId,
+ target,
+ }: {
+ workspaceId: string;
+ coreWorkflowVersionId: string;
+ target: string;
+ }) {
+ const validatedDraft =
+ await this.coreWorkflowVersionWriteService.getValidatedDraftCoreWorkflowVersion(
+ { workspaceId, coreWorkflowVersionId },
+ );
+
+ const targetStep = validatedDraft.steps?.find((step) => step.id === target);
+
+ if (!isDefined(targetStep)) {
+ throw new WorkflowVersionEdgeException(
+ `Target step '${target}' not found in core workflow version '${coreWorkflowVersionId}'`,
+ WorkflowVersionEdgeExceptionCode.NOT_FOUND,
+ );
+ }
+
+ return validatedDraft;
+ }
+
+ private getSourceStepOrThrow({
+ steps,
+ source,
+ coreWorkflowVersionId,
+ }: {
+ steps: WorkflowAction[] | null;
+ source: string;
+ coreWorkflowVersionId: string;
+ }): WorkflowAction {
+ const sourceStep = steps?.find((step) => step.id === source);
+
+ if (!isDefined(sourceStep)) {
+ throw new WorkflowVersionEdgeException(
+ `Source step '${source}' not found in core workflow version '${coreWorkflowVersionId}'`,
+ WorkflowVersionEdgeExceptionCode.NOT_FOUND,
+ );
+ }
+
+ return sourceStep;
+ }
+
+ private async findCoreVersionDTOOrThrow({
+ workspaceId,
+ coreWorkflowVersionId,
+ }: {
+ workspaceId: string;
+ coreWorkflowVersionId: string;
+ }): Promise<CoreWorkflowVersionDTO> {
+ const coreWorkflowVersion =
+ await this.coreWorkflowVersionListService.findOneByCoreWorkflowVersionId({
+ workspaceId,
+ coreWorkflowVersionId,
+ });
+
+ if (!isDefined(coreWorkflowVersion)) {
+ throw new WorkflowQueryValidationException(
+ `Core version '${coreWorkflowVersionId}' not found after the draft write`,
+ WorkflowQueryValidationExceptionCode.FORBIDDEN,
+ {
+ userFriendlyMessage: msg`Draft creation failed, please retry`,
+ },
+ );
+ }
+
+ return coreWorkflowVersion;
+ }
+}
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.ts
new file mode 100644
index 00000000000..646d9d17b1a
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/workflow/services/core-workflow-version-write.service.ts
@@ -0,0 +1,330 @@
+import { Injectable } from '@nestjs/common';
+
+import { msg } from '@lingui/core/macro';
+import { isDefined } from 'twenty-shared/utils';
+import { v4 as uuidv4 } from 'uuid';
+
+import { RecordPositionService } from 'src/engine/core-modules/record-position/services/record-position.service';
+import {
+ WorkflowVersionEntity,
+ WorkflowVersionStatus as CoreWorkflowVersionStatus,
+} from 'src/engine/core-modules/workflow/entities/workflow-version.entity';
+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 { WorkflowVersionCoreSyncService } from 'src/engine/core-modules/workflow/services/workflow-version-core-sync.service';
+import { buildSystemAuthContext } from 'src/engine/twenty-orm/utils/build-system-auth-context.util';
+import { WorkspaceOrmManager } from 'src/engine/twenty-orm/workspace-orm.manager';
+import { assertExactlyOneMirrorRowWasWritten } from 'src/engine/core-modules/workflow/utils/assert-exactly-one-mirror-row-was-written.util';
+import {
+ WorkflowQueryValidationException,
+ WorkflowQueryValidationExceptionCode,
+} from 'src/modules/workflow/common/exceptions/workflow-query-validation.exception';
+import {
+ WorkflowVersionStatus,
+ type WorkflowVersionWorkspaceEntity,
+} from 'src/modules/workflow/common/standard-objects/workflow-version.workspace-entity';
+import { WorkflowMetadataReadService } from 'src/modules/workflow/common/workspace-services/workflow-metadata-read.workspace-service';
+import { assertWorkflowVersionIsNotMalformedOrThrow } from 'src/modules/workflow/workflow-builder/workflow-validation/utils/assert-workflow-version-is-not-malformed-or-throw.util';
+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';
+
+export type ValidatedDraftCoreWorkflowVersion = {
+ coreWorkflowVersion: WorkflowVersionEntity;
+ trigger: WorkflowTrigger | null;
+ steps: WorkflowAction[] | null;
+};
+
+@Injectable()
+export class CoreWorkflowVersionWriteService {
+ constructor(
+ @InjectWorkspaceScopedRepository(WorkflowVersionEntity)
+ private readonly coreWorkflowVersionRepository: WorkspaceScopedRepository<WorkflowVersionEntity>,
+ private readonly workflowVersionCoreSyncService: WorkflowVersionCoreSyncService,
+ private readonly workflowMetadataReadService: WorkflowMetadataReadService,
+ private readonly workspaceOrmManager: WorkspaceOrmManager,
+ private readonly recordPositionService: RecordPositionService,
+ ) {}
+
+ async getValidatedDraftCoreWorkflowVersion({
+ workspaceId,
+ coreWorkflowVersionId,
+ }: {
+ workspaceId: string;
+ coreWorkflowVersionId: string;
+ }): Promise<ValidatedDraftCoreWorkflowVersion> {
+ const coreWorkflowVersion =
+ await this.coreWorkflowVersionRepository.findOne(workspaceId, {
+ where: { id: coreWorkflowVersionId },
+ });
+
+ if (!isDefined(coreWorkflowVersion)) {
+ throw new WorkflowQueryValidationException(
+ `Core workflow version '${coreWorkflowVersionId}' not found`,
+ WorkflowQueryValidationExceptionCode.FORBIDDEN,
+ {
+ userFriendlyMessage: msg`Workflow version not found`,
+ },
+ );
+ }
+
+ if (coreWorkflowVersion.status !== CoreWorkflowVersionStatus.DRAFT) {
+ throw new WorkflowQueryValidationException(
+ `Core workflow version '${coreWorkflowVersionId}' is not a draft`,
+ WorkflowQueryValidationExceptionCode.FORBIDDEN,
+ {
+ userFriendlyMessage: msg`Workflow version is not a draft`,
+ },
+ );
+ }
+
+ return {
+ coreWorkflowVersion,
+ trigger: coreWorkflowVersion.triggers?.[0] ?? null,
+ steps: coreWorkflowVersion.steps,
+ };
+ }
+
+ async writeContentAndMirror({
+ workspaceId,
+ coreWorkflowVersionId,
+ trigger,
+ steps,
+ }: {
+ workspaceId: string;
+ coreWorkflowVersionId: string;
+ 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,
+ })),
+ });
+
+ 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);
+
+ assertExactlyOneMirrorRowWasWritten({
+ affected: mirrorUpdateResult.affected,
+ coreWorkflowVersionId,
+ });
+ },
+ );
+ }, buildSystemAuthContext(workspaceId));
+
+ await this.workflowVersionCoreSyncService.invalidateAutomatedTriggerMaps(
+ workspaceId,
+ );
+ }
+
+ async createDraftCoreWorkflowVersionAndMirror({
+ workspaceId,
+ coreWorkflowId,
+ workspaceWorkflowId,
+ applicationId,
+ trigger,
+ steps,
+ }: {
+ workspaceId: string;
+ coreWorkflowId: string;
+ workspaceWorkflowId: string;
+ applicationId: string;
+ trigger: WorkflowTrigger | null;
+ steps: WorkflowAction[] | null;
+ }): Promise<{ coreWorkflowVersionId: string }> {
+ await this.assertContentIsNotMalformed({
+ workspaceId,
+ coreWorkflowVersionId: 'new draft',
+ trigger,
+ steps,
+ });
+
+ const coreWorkflowVersionId = uuidv4();
+ const workspaceWorkflowVersionId = uuidv4();
+
+ const coreSiblingsCount = await this.countCoreVersions({
+ workspaceId,
+ coreWorkflowId,
+ });
+
+ const position = await this.recordPositionService.buildRecordPosition({
+ value: 'first',
+ objectMetadata: {
+ isCustom: false,
+ nameSingular: 'workflowVersion',
+ },
+ workspaceId,
+ });
+
+ await this.workspaceOrmManager.executeInWorkspaceContext(async () => {
+ await this.workspaceOrmManager.runInWorkspaceTransaction(
+ async (transactionScope) => {
+ await transactionScope.executeRawQuery(
+ `INSERT INTO core."workflowVersion"
+ ("id", "workspaceId", "workflowId", "coreWorkflowId", "triggers", "steps", "status", "universalIdentifier", "applicationId", "workspaceWorkflowVersionId")
+ VALUES ($1, $2, $3, $4, $5, $6, 'DRAFT', $7, $8, $9)`,
+ [
+ coreWorkflowVersionId,
+ workspaceId,
+ workspaceWorkflowId,
+ coreWorkflowId,
+ isDefined(trigger) ? JSON.stringify([trigger]) : null,
+ isDefined(steps) ? JSON.stringify(steps) : null,
+ uuidv4(),
+ applicationId,
+ workspaceWorkflowVersionId,
+ ],
+ );
+
+ await transactionScope
+ .getRepository<WorkflowVersionWorkspaceEntity>('workflowVersion', {
+ shouldBypassPermissionChecks: true,
+ })
+ .insert({
+ id: workspaceWorkflowVersionId,
+ workflowId: workspaceWorkflowId,
+ name: `v${coreSiblingsCount + 1}`,
+ status: WorkflowVersionStatus.DRAFT,
+ trigger,
+ steps,
+ position,
+ coreWorkflowVersionId,
+ });
+ },
+ );
+ }, buildSystemAuthContext(workspaceId));
+
+ await this.workflowVersionCoreSyncService.invalidateAutomatedTriggerMaps(
+ workspaceId,
+ );
+
+ return { coreWorkflowVersionId };
+ }
+
+ async countCoreVersions({
+ workspaceId,
+ coreWorkflowId,
+ }: {
+ workspaceId: string;
+ coreWorkflowId: string;
+ }): Promise<number> {
+ return this.coreWorkflowVersionRepository.count(workspaceId, {
+ where: { coreWorkflowId },
+ });
+ }
+
+ 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,
+ trigger,
+ steps,
+ }: {
+ workspaceId: string;
+ coreWorkflowVersionId: string;
+ trigger: WorkflowTrigger | null;
+ steps: WorkflowAction[] | null;
+ }): Promise<void> {
+ const {
+ flatObjectMetadataMaps,
+ flatFieldMetadataMaps,
+ objectIdByNameSingular,
+ } = await this.workflowMetadataReadService.getFlatEntityMaps(workspaceId);
+
+ try {
+ assertWorkflowVersionIsNotMalformedOrThrow({
+ trigger,
+ steps,
+ flatObjectMetadataMaps,
+ flatFieldMetadataMaps,
+ objectIdByNameSingular,
+ });
+ } catch (error) {
+ throw new WorkflowQueryValidationException(
+ `Refusing malformed content write on core workflow version '${coreWorkflowVersionId}': ${error instanceof Error ? error.message : String(error)}`,
+ WorkflowQueryValidationExceptionCode.FORBIDDEN,
+ {
+ userFriendlyMessage: msg`This change would corrupt the workflow, it was not saved`,
+ },
+ );
+ }
+ }
+}
diff --git a/packages/twenty-server/src/engine/core-modules/workflow/services/workflow-version-core-sync.service.ts b/packages/twenty-server/src/engine/core-modules/workflow/services/workflow-version-core-sync.service.ts
index 3431957f4ee..bf45472f8c1 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
@@ -97,6 +97,7 @@ export class WorkflowVersionCoreSyncService {
: null,
steps: workflowVersion.steps ?? null,
status: workflowVersion.status as unknown as WorkflowVersionStatus,
+ workspaceWorkflowVersionId: workflowVersion.id,
universalIdentifier: uuidv4(),
applicationId,
};
@@ -212,13 +213,14 @@ export class WorkflowVersionCoreSyncService {
// and steps overwritten.
await transactionScope.executeRawQuery(
`INSERT INTO core."workflowVersion"
- ("id", "workspaceId", "workflowId", "triggers", "steps", "status", "universalIdentifier", "applicationId", "coreWorkflowId")
- VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)
+ ("id", "workspaceId", "workflowId", "triggers", "steps", "status", "universalIdentifier", "applicationId", "coreWorkflowId", "workspaceWorkflowVersionId")
+ VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)
ON CONFLICT ("id") DO UPDATE SET
"triggers" = EXCLUDED."triggers",
"steps" = EXCLUDED."steps",
"status" = EXCLUDED."status",
- "coreWorkflowId" = COALESCE(EXCLUDED."coreWorkflowId", core."workflowVersion"."coreWorkflowId")
+ "coreWorkflowId" = COALESCE(EXCLUDED."coreWorkflowId", core."workflowVersion"."coreWorkflowId"),
+ "workspaceWorkflowVersionId" = EXCLUDED."workspaceWorkflowVersionId"
WHERE core."workflowVersion"."workspaceId" = EXCLUDED."workspaceId"`,
[
coreWorkflowVersionId,
@@ -234,6 +236,7 @@ export class WorkflowVersionCoreSyncService {
uuidv4(),
resolvedApplicationId,
coreWorkflowId,
+ workflowVersion.id,
],
);
diff --git a/packages/twenty-server/src/engine/core-modules/workflow/utils/assert-exactly-one-mirror-row-was-written.util.ts b/packages/twenty-server/src/engine/core-modules/workflow/utils/assert-exactly-one-mirror-row-was-written.util.ts
new file mode 100644
index 00000000000..c02d6c89785
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/workflow/utils/assert-exactly-one-mirror-row-was-written.util.ts
@@ -0,0 +1,26 @@
+import { msg } from '@lingui/core/macro';
+
+import {
+ WorkflowQueryValidationException,
+ WorkflowQueryValidationExceptionCode,
+} from 'src/modules/workflow/common/exceptions/workflow-query-validation.exception';
+
+export const assertExactlyOneMirrorRowWasWritten = ({
+ affected,
+ coreWorkflowVersionId,
+}: {
+ affected: number | null | undefined;
+ coreWorkflowVersionId: string;
+}): void => {
+ if (affected === 1) {
+ return;
+ }
+
+ throw new WorkflowQueryValidationException(
+ `Core workflow version '${coreWorkflowVersionId}' wrote ${affected ?? 0} workspace mirror rows instead of exactly one`,
+ WorkflowQueryValidationExceptionCode.FORBIDDEN,
+ {
+ userFriendlyMessage: msg`Workflow version is not correctly linked to its mirror`,
+ },
+ );
+};
diff --git a/packages/twenty-server/src/engine/core-modules/workflow/workflow-api.module.ts b/packages/twenty-server/src/engine/core-modules/workflow/workflow-api.module.ts
index 2fd94b5fadf..18d892870ad 100644
--- a/packages/twenty-server/src/engine/core-modules/workflow/workflow-api.module.ts
+++ b/packages/twenty-server/src/engine/core-modules/workflow/workflow-api.module.ts
@@ -3,9 +3,12 @@ import { Module } from '@nestjs/common';
import { WorkflowVersionValidationModule } from 'src/modules/workflow/workflow-builder/workflow-validation/workflow-version-validation.module';
import { TypeOrmModule } from '@nestjs/typeorm';
+import { CacheLockModule } from 'src/engine/core-modules/cache-lock/cache-lock.module';
+import { CacheStorageModule } from 'src/engine/core-modules/cache-storage/cache-storage.module';
import { ToolModule } from 'src/engine/core-modules/tool/tool.module';
import { WorkflowTriggerController } from 'src/engine/core-modules/workflow/controllers/workflow-trigger.controller';
import { CoreWorkflowResolver } from 'src/engine/core-modules/workflow/resolvers/core-workflow.resolver';
+import { CoreWorkflowVersionMutationResolver } from 'src/engine/core-modules/workflow/resolvers/core-workflow-version-mutation.resolver';
import { WorkflowBuilderResolver } from 'src/engine/core-modules/workflow/resolvers/workflow-builder.resolver';
import { WorkflowTriggerResolver } from 'src/engine/core-modules/workflow/resolvers/workflow-trigger.resolver';
import { WorkflowVersionEdgeResolver } from 'src/engine/core-modules/workflow/resolvers/workflow-version-edge.resolver';
@@ -13,34 +16,46 @@ import { WorkflowVersionStepResolver } from 'src/engine/core-modules/workflow/re
import { WorkflowVersionResolver } from 'src/engine/core-modules/workflow/resolvers/workflow-version.resolver';
import { RecordPositionModule } from 'src/engine/core-modules/record-position/record-position.module';
import { WorkflowEntity } from 'src/engine/core-modules/workflow/entities/workflow.entity';
+import { CoreWorkflowIdResolutionService } from 'src/engine/core-modules/workflow/services/core-workflow-id-resolution.service';
+import { CoreWorkflowLifecycleWorkspaceService } from 'src/engine/core-modules/workflow/services/core-workflow-lifecycle.workspace-service';
import { CoreWorkflowListService } from 'src/engine/core-modules/workflow/services/core-workflow-list.service';
import { CoreWorkflowMutationWorkspaceService } from 'src/engine/core-modules/workflow/services/core-workflow-mutation.workspace-service';
+import { CoreWorkflowVersionMutationWorkspaceService } from 'src/engine/core-modules/workflow/services/core-workflow-version-mutation.workspace-service';
+import { CoreWorkflowVersionWriteService } from 'src/engine/core-modules/workflow/services/core-workflow-version-write.service';
import { WorkflowCoreModule } from 'src/engine/core-modules/workflow/workflow-core.module';
import { CoreWorkflowVersionListService } from 'src/engine/core-modules/workflow/services/core-workflow-version-list.service';
import { WorkflowVersionEntity } from 'src/engine/core-modules/workflow/entities/workflow-version.entity';
import { WorkflowVersionCoreModule } from 'src/engine/core-modules/workflow/workflow-version-core.module';
import { WorkspaceEntity } from 'src/engine/core-modules/workspace/workspace.entity';
import { provideWorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/provide-workspace-scoped-repository';
+import { CommandMenuItemModule } from 'src/engine/metadata-modules/command-menu-item/command-menu-item.module';
import { ConnectedAccountMetadataModule } from 'src/engine/metadata-modules/connected-account/connected-account-metadata.module';
import { WorkspaceManyOrAllFlatEntityMapsCacheModule } from 'src/engine/metadata-modules/flat-entity/services/workspace-many-or-all-flat-entity-maps-cache.module';
import { LogicFunctionModule } from 'src/engine/metadata-modules/logic-function/logic-function.module';
import { PermissionsModule } from 'src/engine/metadata-modules/permissions/permissions.module';
import { WorkflowCommonModule } from 'src/modules/workflow/common/workflow-common.module';
+import { WorkflowMetadataReadModule } from 'src/modules/workflow/common/workspace-services/workflow-metadata-read.module';
import { WorkflowBuilderModule } from 'src/modules/workflow/workflow-builder/workflow-builder.module';
import { CodeStepBuildModule } from 'src/modules/workflow/workflow-builder/workflow-version-step/code-step/code-step-build.module';
import { WorkflowVersionModule } from 'src/modules/workflow/workflow-builder/workflow-version/workflow-version.module';
import { WorkflowRunModule } from 'src/modules/workflow/workflow-runner/workflow-run/workflow-run.module';
import { WorkflowRunnerModule } from 'src/modules/workflow/workflow-runner/workflow-runner.module';
+import { AutomatedTriggerModule } from 'src/modules/workflow/workflow-trigger/automated-trigger/automated-trigger.module';
import { WorkflowTriggerModule } from 'src/modules/workflow/workflow-trigger/workflow-trigger.module';
@Module({
imports: [
TypeOrmModule.forFeature([WorkspaceEntity, WorkflowVersionEntity]),
RecordPositionModule,
+ AutomatedTriggerModule,
+ CacheLockModule,
+ CacheStorageModule,
+ CommandMenuItemModule,
WorkflowCoreModule,
WorkflowTriggerModule,
WorkflowBuilderModule,
WorkflowCommonModule,
+ WorkflowMetadataReadModule,
WorkflowVersionModule,
WorkflowRunModule,
WorkflowRunnerModule,
@@ -61,8 +76,13 @@ import { WorkflowTriggerModule } from 'src/modules/workflow/workflow-trigger/wor
WorkflowVersionEdgeResolver,
WorkflowVersionResolver,
CoreWorkflowResolver,
+ CoreWorkflowVersionMutationResolver,
+ CoreWorkflowIdResolutionService,
+ CoreWorkflowLifecycleWorkspaceService,
CoreWorkflowListService,
CoreWorkflowMutationWorkspaceService,
+ CoreWorkflowVersionMutationWorkspaceService,
+ CoreWorkflowVersionWriteService,
CoreWorkflowVersionListService,
provideWorkspaceScopedRepository(WorkflowVersionEntity),
provideWorkspaceScopedRepository(WorkflowEntity),
diff --git a/packages/twenty-server/src/engine/metadata-modules/command-menu-item/command-menu-item.service.ts b/packages/twenty-server/src/engine/metadata-modules/command-menu-item/command-menu-item.service.ts
index b5dba082994..5245865d230 100644
--- a/packages/twenty-server/src/engine/metadata-modules/command-menu-item/command-menu-item.service.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/command-menu-item/command-menu-item.service.ts
@@ -533,6 +533,32 @@ export class CommandMenuItemService {
});
}
+ async findByCoreWorkflowVersionId(
+ coreWorkflowVersionId: string,
+ workspaceId: string,
+ ): Promise<CommandMenuItemDTO | null> {
+ const { flatCommandMenuItemMaps } =
+ await this.workspaceManyOrAllFlatEntityMapsCacheService.getOrRecomputeManyOrAllFlatEntityMaps(
+ {
+ workspaceId,
+ flatMapsKeys: ['flatCommandMenuItemMaps'],
+ },
+ );
+
+ const flatCommandMenuItem = Object.values(
+ flatCommandMenuItemMaps.byUniversalIdentifier,
+ ).find(
+ (item) =>
+ isDefined(item) && item.coreWorkflowVersionId === coreWorkflowVersionId,
+ );
+
+ if (!isDefined(flatCommandMenuItem)) {
+ return null;
+ }
+
+ return fromFlatCommandMenuItemToCommandMenuItemDto(flatCommandMenuItem);
+ }
+
async findByWorkflowVersionId(
workflowVersionId: string,
workspaceId: string,
diff --git a/packages/twenty-server/src/engine/workspace-manager/standard-objects-prefill-data/utils/prefill-workflows.util.ts b/packages/twenty-server/src/engine/workspace-manager/standard-objects-prefill-data/utils/prefill-workflows.util.ts
index 321af956898..46832c5492e 100644
--- a/packages/twenty-server/src/engine/workspace-manager/standard-objects-prefill-data/utils/prefill-workflows.util.ts
+++ b/packages/twenty-server/src/engine/workspace-manager/standard-objects-prefill-data/utils/prefill-workflows.util.ts
@@ -886,6 +886,7 @@ export const prefillWorkflows = async (
'status',
'workflowId',
'coreWorkflowId',
+ 'workspaceWorkflowVersionId',
])
.orIgnore()
.values([
@@ -899,6 +900,7 @@ export const prefillWorkflows = async (
status: 'ACTIVE',
workflowId: quickLeadWorkflowId,
coreWorkflowId: coreQuickLeadWorkflowId,
+ workspaceWorkflowVersionId: quickLeadWorkflowVersionId,
},
{
id: coreCreateCompanyWorkflowVersionId,
@@ -910,6 +912,7 @@ export const prefillWorkflows = async (
status: 'ACTIVE',
workflowId: createCompanyWorkflowId,
coreWorkflowId: coreCreateCompanyWorkflowId,
+ workspaceWorkflowVersionId: createCompanyWorkflowVersionId,
},
])
.execute();
diff --git a/packages/twenty-server/src/modules/workflow/workflow-builder/utils/__tests__/remap-duplicated-step-destinations.util.spec.ts b/packages/twenty-server/src/modules/workflow/workflow-builder/utils/__tests__/remap-duplicated-step-destinations.util.spec.ts
new file mode 100644
index 00000000000..743418a3f10
--- /dev/null
+++ b/packages/twenty-server/src/modules/workflow/workflow-builder/utils/__tests__/remap-duplicated-step-destinations.util.spec.ts
@@ -0,0 +1,133 @@
+import { WorkflowActionType } from 'twenty-shared/workflow';
+
+import { remapDuplicatedStepDestinations } from 'src/modules/workflow/workflow-builder/utils/remap-duplicated-step-destinations.util';
+import { type WorkflowAction } from 'src/modules/workflow/workflow-executor/workflow-actions/types/workflow-action.type';
+import {
+ type WorkflowTrigger,
+ WorkflowTriggerType,
+} from 'src/modules/workflow/workflow-trigger/types/workflow-trigger.type';
+
+const buildStep = (step: Partial<WorkflowAction> & { id: string }) =>
+ ({
+ name: 'Step',
+ type: WorkflowActionType.CODE,
+ valid: true,
+ settings: { input: {} },
+ position: { x: 0, y: 0 },
+ ...step,
+ }) as WorkflowAction;
+
+const TRIGGER = {
+ name: 'Manual Trigger',
+ type: WorkflowTriggerType.MANUAL,
+ settings: { outputSchema: {} },
+ nextStepIds: ['source-if-else'],
+ position: { x: 0, y: 0 },
+} as WorkflowTrigger;
+
+describe('remapDuplicatedStepDestinations', () => {
+ it('remaps the trigger and plain step destinations', () => {
+ const source = buildStep({ id: 'source-a', nextStepIds: ['source-b'] });
+ const other = buildStep({ id: 'source-b' });
+
+ const { trigger, steps } = remapDuplicatedStepDestinations({
+ trigger: { ...TRIGGER, nextStepIds: ['source-a'] },
+ sourceToClonedPairs: [
+ { source, duplicated: buildStep({ id: 'cloned-a' }) },
+ { source: other, duplicated: buildStep({ id: 'cloned-b' }) },
+ ],
+ clonedStepIdBySourceStepId: new Map([
+ ['source-a', 'cloned-a'],
+ ['source-b', 'cloned-b'],
+ ]),
+ });
+
+ expect(trigger.nextStepIds).toEqual(['cloned-a']);
+ expect(steps[0].nextStepIds).toEqual(['cloned-b']);
+ });
+
+ it('remaps the destinations of connected if/else branches', () => {
+ const sourceIfElse = buildStep({
+ id: 'source-if-else',
+ type: WorkflowActionType.IF_ELSE,
+ settings: {
+ input: {
+ stepFilterGroups: [],
+ stepFilters: [],
+ branches: [
+ {
+ id: 'branch-if',
+ filterGroupId: 'filter-group',
+ nextStepIds: ['source-then'],
+ },
+ { id: 'branch-else', nextStepIds: ['source-otherwise'] },
+ ],
+ },
+ },
+ } as unknown as Partial<WorkflowAction> & { id: string });
+
+ const { steps } = remapDuplicatedStepDestinations({
+ trigger: TRIGGER,
+ sourceToClonedPairs: [
+ {
+ source: sourceIfElse,
+ duplicated: { ...sourceIfElse, id: 'cloned-if-else' },
+ },
+ {
+ source: buildStep({ id: 'source-then' }),
+ duplicated: buildStep({ id: 'cloned-then' }),
+ },
+ {
+ source: buildStep({ id: 'source-otherwise' }),
+ duplicated: buildStep({ id: 'cloned-otherwise' }),
+ },
+ ],
+ clonedStepIdBySourceStepId: new Map([
+ ['source-if-else', 'cloned-if-else'],
+ ['source-then', 'cloned-then'],
+ ['source-otherwise', 'cloned-otherwise'],
+ ]),
+ });
+
+ const branches = (
+ steps[0] as unknown as {
+ settings: { input: { branches: { nextStepIds: string[] }[] } };
+ }
+ ).settings.input.branches;
+
+ expect(branches[0].nextStepIds).toEqual(['cloned-then']);
+ expect(branches[1].nextStepIds).toEqual(['cloned-otherwise']);
+ });
+
+ it('remaps the initial loop steps of an iterator', () => {
+ const sourceIterator = buildStep({
+ id: 'source-iterator',
+ type: WorkflowActionType.ITERATOR,
+ settings: {
+ input: { items: [], initialLoopStepIds: ['source-loop-start'] },
+ },
+ } as unknown as Partial<WorkflowAction> & { id: string });
+
+ const { steps } = remapDuplicatedStepDestinations({
+ trigger: TRIGGER,
+ sourceToClonedPairs: [
+ {
+ source: sourceIterator,
+ duplicated: { ...sourceIterator, id: 'cloned-iterator' },
+ },
+ ],
+ clonedStepIdBySourceStepId: new Map([
+ ['source-iterator', 'cloned-iterator'],
+ ['source-loop-start', 'cloned-loop-start'],
+ ]),
+ });
+
+ const initialLoopStepIds = (
+ steps[0] as unknown as {
+ settings: { input: { initialLoopStepIds: string[] } };
+ }
+ ).settings.input.initialLoopStepIds;
+
+ expect(initialLoopStepIds).toEqual(['cloned-loop-start']);
+ });
+});
diff --git a/packages/twenty-server/src/modules/workflow/workflow-builder/utils/remap-duplicated-step-destinations.util.ts b/packages/twenty-server/src/modules/workflow/workflow-builder/utils/remap-duplicated-step-destinations.util.ts
new file mode 100644
index 00000000000..1bbaea539b3
--- /dev/null
+++ b/packages/twenty-server/src/modules/workflow/workflow-builder/utils/remap-duplicated-step-destinations.util.ts
@@ -0,0 +1,75 @@
+import { isDefined } from 'twenty-shared/utils';
+import { WorkflowActionType } from 'twenty-shared/workflow';
+
+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';
+
+const remapIds = (
+ stepIds: string[] | undefined,
+ clonedStepIdBySourceStepId: Map<string, string>,
+): string[] =>
+ (stepIds ?? []).map(
+ (stepId) => clonedStepIdBySourceStepId.get(stepId) ?? stepId,
+ );
+
+export const remapDuplicatedStepDestinations = <
+ TTrigger extends WorkflowTrigger,
+>({
+ trigger,
+ sourceToClonedPairs,
+ clonedStepIdBySourceStepId,
+}: {
+ trigger: TTrigger;
+ sourceToClonedPairs: { source: WorkflowAction; duplicated: WorkflowAction }[];
+ clonedStepIdBySourceStepId: Map<string, string>;
+}): { trigger: TTrigger; steps: WorkflowAction[] } => ({
+ trigger: {
+ ...trigger,
+ nextStepIds: remapIds(trigger.nextStepIds, clonedStepIdBySourceStepId),
+ },
+ steps: sourceToClonedPairs.map(({ source, duplicated }) => {
+ const remappedStep: WorkflowAction = {
+ ...duplicated,
+ nextStepIds: remapIds(source.nextStepIds, clonedStepIdBySourceStepId),
+ };
+
+ if (
+ source.type === WorkflowActionType.ITERATOR &&
+ remappedStep.type === WorkflowActionType.ITERATOR &&
+ isDefined(source.settings.input.initialLoopStepIds)
+ ) {
+ remappedStep.settings = {
+ ...remappedStep.settings,
+ input: {
+ ...remappedStep.settings.input,
+ initialLoopStepIds: remapIds(
+ source.settings.input.initialLoopStepIds,
+ clonedStepIdBySourceStepId,
+ ),
+ },
+ };
+ }
+
+ if (
+ source.type === WorkflowActionType.IF_ELSE &&
+ remappedStep.type === WorkflowActionType.IF_ELSE &&
+ isDefined(source.settings.input.branches)
+ ) {
+ remappedStep.settings = {
+ ...remappedStep.settings,
+ input: {
+ ...remappedStep.settings.input,
+ branches: source.settings.input.branches.map((branch) => ({
+ ...branch,
+ nextStepIds: remapIds(
+ branch.nextStepIds,
+ clonedStepIdBySourceStepId,
+ ),
+ })),
+ },
+ };
+ }
+
+ return remappedStep;
+ }),
+});
diff --git a/packages/twenty-server/src/modules/workflow/workflow-builder/workflow-schema/workflow-schema.workspace-service.ts b/packages/twenty-server/src/modules/workflow/workflow-builder/workflow-schema/workflow-schema.workspace-service.ts
index c20401bad06..c4ec5df336b 100644
--- a/packages/twenty-server/src/modules/workflow/workflow-builder/workflow-schema/workflow-schema.workspace-service.ts
+++ b/packages/twenty-server/src/modules/workflow/workflow-builder/workflow-schema/workflow-schema.workspace-service.ts
@@ -51,6 +51,11 @@ import {
WorkflowTriggerType,
} from 'src/modules/workflow/workflow-trigger/types/workflow-trigger.type';
+type WorkflowVersionContent = {
+ trigger: WorkflowTrigger | null;
+ steps: WorkflowAction[] | null;
+};
+
@Injectable()
export class WorkflowSchemaWorkspaceService {
private readonly logger = new Logger(WorkflowSchemaWorkspaceService.name);
@@ -63,11 +68,11 @@ export class WorkflowSchemaWorkspaceService {
async computeStepOutputSchema({
step,
workspaceId,
- workflowVersionId,
+ workflowVersionContent,
}: {
step: WorkflowTrigger | WorkflowAction;
workspaceId: string;
- workflowVersionId?: string;
+ workflowVersionContent?: WorkflowVersionContent;
}): Promise<OutputSchema> {
const stepType = step.type;
@@ -122,7 +127,7 @@ export class WorkflowSchemaWorkspaceService {
currentItem: await this.computeLoopCurrentItemOutputSchema({
items,
workspaceId,
- workflowVersionId,
+ workflowVersionContent,
}),
currentItemIndex: {
label: 'Current Item Index',
@@ -169,11 +174,11 @@ export class WorkflowSchemaWorkspaceService {
async enrichOutputSchema({
step,
workspaceId,
- workflowVersionId,
+ workflowVersionContent,
}: {
step: WorkflowAction;
workspaceId: string;
- workflowVersionId: string;
+ workflowVersionContent?: WorkflowVersionContent;
}): Promise<WorkflowAction> {
const BACKEND_ENRICHED_TYPES = [
WorkflowActionType.ITERATOR,
@@ -188,7 +193,7 @@ export class WorkflowSchemaWorkspaceService {
const outputSchema = await this.computeStepOutputSchema({
step,
workspaceId,
- workflowVersionId,
+ workflowVersionContent,
});
result.settings = {
@@ -551,11 +556,11 @@ export class WorkflowSchemaWorkspaceService {
private async computeLoopCurrentItemOutputSchema({
items,
workspaceId,
- workflowVersionId,
+ workflowVersionContent,
}: {
items: string | undefined | unknown[];
workspaceId: string;
- workflowVersionId?: string;
+ workflowVersionContent?: WorkflowVersionContent;
}): Promise<Leaf | Node> {
if (!isDefined(items)) {
return DEFAULT_ITERATOR_CURRENT_ITEM;
@@ -565,7 +570,7 @@ export class WorkflowSchemaWorkspaceService {
return this.computeIteratorCurrentItemFromVariable({
items,
workspaceId,
- workflowVersionId,
+ workflowVersionContent,
});
}
@@ -575,21 +580,17 @@ export class WorkflowSchemaWorkspaceService {
private async computeIteratorCurrentItemFromVariable({
items,
workspaceId,
- workflowVersionId,
+ workflowVersionContent,
}: {
items: string;
workspaceId: string;
- workflowVersionId?: string;
+ workflowVersionContent?: WorkflowVersionContent;
}): Promise<Leaf | Node> {
- if (!isDefined(workflowVersionId)) {
+ if (!isDefined(workflowVersionContent)) {
return DEFAULT_ITERATOR_CURRENT_ITEM;
}
- const workflowVersion =
- await this.workflowCommonWorkspaceService.getWorkflowVersionOrFail({
- workflowVersionId,
- workspaceId,
- });
+ const workflowVersion = workflowVersionContent;
const stepId = extractRawVariableNamePart({
rawVariableName: items,
diff --git a/packages/twenty-server/src/modules/workflow/workflow-builder/workflow-version-edge/utils/build-updated-source-step-for-edge.util.ts b/packages/twenty-server/src/modules/workflow/workflow-builder/workflow-version-edge/utils/build-updated-source-step-for-edge.util.ts
new file mode 100644
index 00000000000..6fcceacda34
--- /dev/null
+++ b/packages/twenty-server/src/modules/workflow/workflow-builder/workflow-version-edge/utils/build-updated-source-step-for-edge.util.ts
@@ -0,0 +1,181 @@
+import { isDefined } from 'twenty-shared/utils';
+import { WorkflowActionType } from 'twenty-shared/workflow';
+
+import {
+ WorkflowVersionEdgeException,
+ WorkflowVersionEdgeExceptionCode,
+} from 'src/modules/workflow/common/exceptions/workflow-version-edge.exception';
+import { type WorkflowStepConnectionOptions } from 'src/modules/workflow/workflow-builder/workflow-version-step/types/WorkflowStepConnectionOptions';
+import { type WorkflowAction } from 'src/modules/workflow/workflow-executor/workflow-actions/types/workflow-action.type';
+
+type UpdatedSourceStepResult = {
+ updatedSourceStep: WorkflowAction;
+ shouldPersist: boolean;
+};
+
+const buildSourceStepWithAddedNextStepId = ({
+ sourceStep,
+ target,
+}: {
+ sourceStep: WorkflowAction;
+ target: string;
+}): UpdatedSourceStepResult => {
+ if (sourceStep.nextStepIds?.includes(target)) {
+ return {
+ updatedSourceStep: sourceStep,
+ shouldPersist: false,
+ };
+ }
+
+ return {
+ updatedSourceStep: {
+ ...sourceStep,
+ nextStepIds: [...(sourceStep.nextStepIds ?? []), target],
+ },
+ shouldPersist: true,
+ };
+};
+
+export const buildSourceStepWithAddedEdge = ({
+ sourceStep,
+ target,
+ sourceConnectionOptions,
+}: {
+ sourceStep: WorkflowAction;
+ target: string;
+ sourceConnectionOptions?: WorkflowStepConnectionOptions;
+}): UpdatedSourceStepResult => {
+ if (!isDefined(sourceConnectionOptions)) {
+ return buildSourceStepWithAddedNextStepId({ sourceStep, target });
+ }
+
+ switch (sourceConnectionOptions.connectedStepType) {
+ case WorkflowActionType.ITERATOR:
+ if (sourceStep.type !== WorkflowActionType.ITERATOR) {
+ throw new WorkflowVersionEdgeException(
+ `Source step '${sourceStep.id}' is not an iterator`,
+ WorkflowVersionEdgeExceptionCode.INVALID_REQUEST,
+ );
+ }
+
+ if (sourceConnectionOptions.settings.isConnectedToLoop) {
+ const currentInitialLoopStepIds =
+ sourceStep.settings.input.initialLoopStepIds;
+
+ if (currentInitialLoopStepIds?.includes(target)) {
+ return {
+ updatedSourceStep: sourceStep,
+ shouldPersist: false,
+ };
+ }
+
+ return {
+ updatedSourceStep: {
+ ...sourceStep,
+ settings: {
+ ...sourceStep.settings,
+ input: {
+ ...sourceStep.settings.input,
+ initialLoopStepIds: [
+ ...(currentInitialLoopStepIds ?? []),
+ target,
+ ],
+ },
+ },
+ },
+ shouldPersist: true,
+ };
+ }
+
+ return buildSourceStepWithAddedNextStepId({ sourceStep, target });
+
+ default:
+ return buildSourceStepWithAddedNextStepId({ sourceStep, target });
+ }
+};
+
+const buildSourceStepWithRemovedNextStepId = ({
+ sourceStep,
+ target,
+}: {
+ sourceStep: WorkflowAction;
+ target: string;
+}): UpdatedSourceStepResult => ({
+ updatedSourceStep: {
+ ...sourceStep,
+ nextStepIds: sourceStep.nextStepIds?.filter(
+ (nextStepId) => nextStepId !== target,
+ ),
+ },
+ shouldPersist: true,
+});
+
+export const buildSourceStepWithRemovedEdge = ({
+ sourceStep,
+ target,
+ sourceConnectionOptions,
+}: {
+ sourceStep: WorkflowAction;
+ target: string;
+ sourceConnectionOptions?: WorkflowStepConnectionOptions;
+}): UpdatedSourceStepResult => {
+ if (!isDefined(sourceConnectionOptions)) {
+ return buildSourceStepWithRemovedNextStepId({ sourceStep, target });
+ }
+
+ switch (sourceConnectionOptions.connectedStepType) {
+ case WorkflowActionType.ITERATOR:
+ if (sourceStep.type !== WorkflowActionType.ITERATOR) {
+ throw new WorkflowVersionEdgeException(
+ `Source step '${sourceStep.id}' is not an iterator`,
+ WorkflowVersionEdgeExceptionCode.INVALID_REQUEST,
+ );
+ }
+
+ if (sourceConnectionOptions.settings.isConnectedToLoop) {
+ const currentInitialLoopStepIds =
+ sourceStep.settings.input.initialLoopStepIds;
+
+ if (!currentInitialLoopStepIds?.includes(target)) {
+ return {
+ updatedSourceStep: sourceStep,
+ shouldPersist: false,
+ };
+ }
+
+ return {
+ updatedSourceStep: {
+ ...sourceStep,
+ settings: {
+ ...sourceStep.settings,
+ input: {
+ ...sourceStep.settings.input,
+ initialLoopStepIds: currentInitialLoopStepIds.filter(
+ (id) => id !== target,
+ ),
+ },
+ },
+ },
+ shouldPersist: true,
+ };
+ }
+
+ return buildSourceStepWithRemovedNextStepId({ sourceStep, target });
+
+ default:
+ return buildSourceStepWithRemovedNextStepId({ sourceStep, target });
+ }
+};
+
+export const assertEdgeConnectionOptionsAreSupported = (
+ sourceConnectionOptions?: WorkflowStepConnectionOptions,
+): void => {
+ if (
+ sourceConnectionOptions?.connectedStepType === WorkflowActionType.IF_ELSE
+ ) {
+ throw new WorkflowVersionEdgeException(
+ 'If/Else connections must be updated through their branch settings',
+ WorkflowVersionEdgeExceptionCode.INVALID_REQUEST,
+ );
+ }
+};
diff --git a/packages/twenty-server/src/modules/workflow/workflow-builder/workflow-version-edge/workflow-version-edge.workspace-service.ts b/packages/twenty-server/src/modules/workflow/workflow-builder/workflow-version-edge/workflow-version-edge.workspace-service.ts
index 980ee5a6f69..00d4684958c 100644
--- a/packages/twenty-server/src/modules/workflow/workflow-builder/workflow-version-edge/workflow-version-edge.workspace-service.ts
+++ b/packages/twenty-server/src/modules/workflow/workflow-builder/workflow-version-edge/workflow-version-edge.workspace-service.ts
@@ -1,7 +1,7 @@
import { Injectable } from '@nestjs/common';
import { isDefined } from 'twenty-shared/utils';
-import { TRIGGER_STEP_ID, WorkflowActionType } from 'twenty-shared/workflow';
+import { TRIGGER_STEP_ID } from 'twenty-shared/workflow';
import { type WorkflowVersionStepChangesDTO } from 'src/engine/core-modules/workflow/dtos/workflow-version-step-changes.dto';
import { WorkflowVersionCoreSyncService } from 'src/engine/core-modules/workflow/services/workflow-version-core-sync.service';
@@ -15,6 +15,11 @@ import { type WorkflowVersionWorkspaceEntity } from 'src/modules/workflow/common
import { assertWorkflowVersionIsDraft } from 'src/modules/workflow/common/utils/assert-workflow-version-is-draft.util';
import { WorkflowCommonWorkspaceService } from 'src/modules/workflow/common/workspace-services/workflow-common.workspace-service';
import { computeWorkflowVersionStepChanges } from 'src/modules/workflow/workflow-builder/utils/compute-workflow-version-step-updates.util';
+import {
+ assertEdgeConnectionOptionsAreSupported,
+ buildSourceStepWithAddedEdge,
+ buildSourceStepWithRemovedEdge,
+} from 'src/modules/workflow/workflow-builder/workflow-version-edge/utils/build-updated-source-step-for-edge.util';
import { type WorkflowStepConnectionOptions } from 'src/modules/workflow/workflow-builder/workflow-version-step/types/WorkflowStepConnectionOptions';
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';
@@ -40,7 +45,7 @@ export class WorkflowVersionEdgeWorkspaceService {
workspaceId: string;
sourceConnectionOptions?: WorkflowStepConnectionOptions;
}): Promise<WorkflowVersionStepChangesDTO> {
- this.assertConnectionOptionsAreSupported(sourceConnectionOptions);
+ assertEdgeConnectionOptionsAreSupported(sourceConnectionOptions);
const authContext = buildSystemAuthContext(workspaceId);
@@ -102,7 +107,7 @@ export class WorkflowVersionEdgeWorkspaceService {
workspaceId: string;
sourceConnectionOptions?: WorkflowStepConnectionOptions;
}): Promise<WorkflowVersionStepChangesDTO> {
- this.assertConnectionOptionsAreSupported(sourceConnectionOptions);
+ assertEdgeConnectionOptionsAreSupported(sourceConnectionOptions);
const authContext = buildSystemAuthContext(workspaceId);
@@ -237,15 +242,11 @@ export class WorkflowVersionEdgeWorkspaceService {
});
}
- const { updatedSourceStep, shouldPersist } = isDefined(
+ const { updatedSourceStep, shouldPersist } = buildSourceStepWithAddedEdge({
+ sourceStep,
+ target,
sourceConnectionOptions,
- )
- ? this.buildUpdatedSourceStepWithConnectionOptions({
- sourceStep,
- target,
- sourceConnectionOptions,
- })
- : this.buildUpdatedSourceStep({ sourceStep, target });
+ });
const updatedSteps = steps.map((step) => {
if (step.id === source) {
@@ -275,97 +276,6 @@ export class WorkflowVersionEdgeWorkspaceService {
});
}
- private buildUpdatedSourceStepWithConnectionOptions({
- sourceStep,
- target,
- sourceConnectionOptions,
- }: {
- sourceStep: WorkflowAction;
- target: string;
- sourceConnectionOptions: WorkflowStepConnectionOptions;
- }): {
- updatedSourceStep: WorkflowAction;
- shouldPersist: boolean;
- } {
- switch (sourceConnectionOptions.connectedStepType) {
- case WorkflowActionType.ITERATOR:
- if (sourceStep.type !== WorkflowActionType.ITERATOR) {
- throw new WorkflowVersionEdgeException(
- `Source step '${sourceStep.id}' is not an iterator`,
- WorkflowVersionEdgeExceptionCode.INVALID_REQUEST,
- );
- }
-
- if (sourceConnectionOptions.settings.isConnectedToLoop) {
- const currentInitialLoopStepIds =
- sourceStep.settings.input.initialLoopStepIds;
-
- if (currentInitialLoopStepIds?.includes(target)) {
- return {
- updatedSourceStep: sourceStep,
- shouldPersist: false,
- };
- }
-
- return {
- updatedSourceStep: {
- ...sourceStep,
- settings: {
- ...sourceStep.settings,
- input: {
- ...sourceStep.settings.input,
- initialLoopStepIds: [
- ...(currentInitialLoopStepIds ?? []),
- target,
- ],
- },
- },
- },
- shouldPersist: true,
- };
- } else {
- return this.buildUpdatedSourceStep({
- sourceStep,
- target,
- });
- }
-
- default:
- return this.buildUpdatedSourceStep({
- sourceStep,
- target,
- });
- }
- }
-
- private buildUpdatedSourceStep({
- sourceStep,
- target,
- }: {
- sourceStep: WorkflowAction;
- target: string;
- }): {
- updatedSourceStep: WorkflowAction;
- shouldPersist: boolean;
- } {
- if (sourceStep.nextStepIds?.includes(target)) {
- return {
- updatedSourceStep: sourceStep,
- shouldPersist: false,
- };
- }
-
- const updatedSourceStep = {
- ...sourceStep,
- nextStepIds: [...(sourceStep.nextStepIds ?? []), target],
- };
-
- return {
- updatedSourceStep,
- shouldPersist: true,
- };
- }
-
private async deleteTriggerEdge({
trigger,
steps,
@@ -454,23 +364,13 @@ export class WorkflowVersionEdgeWorkspaceService {
});
}
- const { updatedSourceStep, shouldPersist } = isDefined(
- sourceConnectionOptions,
- )
- ? this.buildUpdatedSourceStepWithOptions({
- sourceStep,
- target,
- sourceConnectionOptions,
- })
- : {
- updatedSourceStep: {
- ...sourceStep,
- nextStepIds: sourceStep.nextStepIds?.filter(
- (nextStepId: string) => nextStepId !== target,
- ),
- },
- shouldPersist: true,
- };
+ const { updatedSourceStep, shouldPersist } = buildSourceStepWithRemovedEdge(
+ {
+ sourceStep,
+ target,
+ sourceConnectionOptions,
+ },
+ );
if (!shouldPersist) {
return computeWorkflowVersionStepChanges({
@@ -504,85 +404,4 @@ export class WorkflowVersionEdgeWorkspaceService {
updatedSteps,
});
}
-
- private buildUpdatedSourceStepWithOptions({
- sourceStep,
- target,
- sourceConnectionOptions,
- }: {
- sourceStep: WorkflowAction;
- target: string;
- sourceConnectionOptions: WorkflowStepConnectionOptions;
- }): {
- updatedSourceStep: WorkflowAction;
- shouldPersist: boolean;
- } {
- switch (sourceConnectionOptions.connectedStepType) {
- case WorkflowActionType.ITERATOR:
- if (sourceStep.type !== WorkflowActionType.ITERATOR) {
- throw new WorkflowVersionEdgeException(
- `Source step '${sourceStep.id}' is not an iterator`,
- WorkflowVersionEdgeExceptionCode.INVALID_REQUEST,
- );
- }
-
- if (sourceConnectionOptions.settings.isConnectedToLoop) {
- const currentInitialLoopStepIds =
- sourceStep.settings.input.initialLoopStepIds;
-
- if (!currentInitialLoopStepIds?.includes(target)) {
- return {
- updatedSourceStep: sourceStep,
- shouldPersist: false,
- };
- }
-
- return {
- updatedSourceStep: {
- ...sourceStep,
- settings: {
- ...sourceStep.settings,
- input: {
- ...sourceStep.settings.input,
- initialLoopStepIds: currentInitialLoopStepIds.filter(
- (id: string) => id !== target,
- ),
- },
- },
- },
- shouldPersist: true,
- };
- }
-
- return {
- updatedSourceStep: {
- ...sourceStep,
- nextStepIds: sourceStep.nextStepIds?.filter((id) => id !== target),
- },
- shouldPersist: true,
- };
-
- default:
- return {
- updatedSourceStep: {
- ...sourceStep,
- nextStepIds: sourceStep.nextStepIds?.filter((id) => id !== target),
- },
- shouldPersist: true,
- };
- }
- }
-
- private assertConnectionOptionsAreSupported(
- sourceConnectionOptions?: WorkflowStepConnectionOptions,
- ) {
- if (
- sourceConnectionOptions?.connectedStepType === WorkflowActionType.IF_ELSE
- ) {
- throw new WorkflowVersionEdgeException(
- 'If/Else connections must be updated through their branch settings',
- WorkflowVersionEdgeExceptionCode.INVALID_REQUEST,
- );
- }
- }
}
diff --git a/packages/twenty-server/src/modules/workflow/workflow-builder/workflow-version-step/workflow-version-step-creation.workspace-service.ts b/packages/twenty-server/src/modules/workflow/workflow-builder/workflow-version-step/workflow-version-step-creation.workspace-service.ts
index a977d3c7f0a..4a269dd9b15 100644
--- a/packages/twenty-server/src/modules/workflow/workflow-builder/workflow-version-step/workflow-version-step-creation.workspace-service.ts
+++ b/packages/twenty-server/src/modules/workflow/workflow-builder/workflow-version-step/workflow-version-step-creation.workspace-service.ts
@@ -58,7 +58,6 @@ export class WorkflowVersionStepCreationWorkspaceService {
type: stepType,
workspaceId,
position,
- workflowVersionId,
id,
defaultSettings,
},
@@ -68,7 +67,10 @@ export class WorkflowVersionStepCreationWorkspaceService {
await this.workflowSchemaWorkspaceService.enrichOutputSchema({
step: builtStep,
workspaceId,
- workflowVersionId,
+ workflowVersionContent: {
+ trigger: existingTrigger,
+ steps: existingSteps,
+ },
});
const { updatedSteps, updatedTrigger } = insertStep({
diff --git a/packages/twenty-server/src/modules/workflow/workflow-builder/workflow-version-step/workflow-version-step-operations.workspace-service.ts b/packages/twenty-server/src/modules/workflow/workflow-builder/workflow-version-step/workflow-version-step-operations.workspace-service.ts
index be8a7a76c8d..ce1c50fe0f4 100644
--- a/packages/twenty-server/src/modules/workflow/workflow-builder/workflow-version-step/workflow-version-step-operations.workspace-service.ts
+++ b/packages/twenty-server/src/modules/workflow/workflow-builder/workflow-version-step/workflow-version-step-operations.workspace-service.ts
@@ -41,7 +41,6 @@ import {
WorkflowVersionStepException,
WorkflowVersionStepExceptionCode,
} from 'src/modules/workflow/common/exceptions/workflow-version-step.exception';
-import { type WorkflowVersionWorkspaceEntity } from 'src/modules/workflow/common/standard-objects/workflow-version.workspace-entity';
import { WorkflowCommonWorkspaceService } from 'src/modules/workflow/common/workspace-services/workflow-common.workspace-service';
import { type OutputSchema } from 'src/modules/workflow/workflow-builder/workflow-schema/types/output-schema.type';
import { CodeStepBuildService } from 'src/modules/workflow/workflow-builder/workflow-version-step/code-step/services/code-step-build.service';
@@ -152,14 +151,12 @@ export class WorkflowVersionStepOperationsWorkspaceService {
async runStepCreationSideEffectsAndBuildStep({
type,
workspaceId,
- workflowVersionId,
position,
id,
defaultSettings,
}: {
type: WorkflowActionType;
workspaceId: string;
- workflowVersionId: string;
position?: WorkflowStepPositionInput;
id?: string;
defaultSettings?: Record<string, unknown>;
@@ -585,10 +582,8 @@ export class WorkflowVersionStepOperationsWorkspaceService {
};
}
case WorkflowActionType.ITERATOR: {
- const emptyNodeStep = await this.createEmptyNodeForIteratorStep({
+ const emptyNodeStep = this.buildEmptyNodeForIteratorStep({
iteratorStepId: baseStep.id,
- workflowVersionId,
- workspaceId,
iteratorPosition: position,
});
@@ -611,9 +606,7 @@ export class WorkflowVersionStepOperationsWorkspaceService {
}
case WorkflowActionType.IF_ELSE: {
const { ifEmptyNode, elseEmptyNode, ifFilterGroupId, branches } =
- await this.createEmptyNodesForIfElseStep({
- workflowVersionId,
- workspaceId,
+ this.buildEmptyNodesForIfElseStep({
ifElsePosition: position,
});
@@ -883,172 +876,92 @@ export class WorkflowVersionStepOperationsWorkspaceService {
};
}
- async createEmptyNodeForIteratorStep({
+ buildEmptyNodeForIteratorStep({
iteratorStepId,
- workflowVersionId,
- workspaceId,
iteratorPosition,
}: {
iteratorStepId: string;
- workflowVersionId: string;
- workspaceId: string;
iteratorPosition?: WorkflowStepPositionInput;
- }): Promise<WorkflowAction> {
- const authContext = buildSystemAuthContext(workspaceId);
-
- return this.workspaceOrmManager.executeInWorkspaceContext(async () => {
- const workflowVersionRepository =
- this.workspaceOrmManager.getRepository<WorkflowVersionWorkspaceEntity>(
- 'workflowVersion',
- { shouldBypassPermissionChecks: true },
- );
-
- const workflowVersion = await workflowVersionRepository.findOne({
- where: {
- id: workflowVersionId,
- },
- });
-
- if (!isDefined(workflowVersion)) {
- throw new WorkflowVersionStepException(
- 'WorkflowVersion not found',
- WorkflowVersionStepExceptionCode.NOT_FOUND,
- );
- }
-
- const existingSteps = workflowVersion.steps ?? [];
-
- const emptyNodeStep: WorkflowEmptyAction = {
- id: v4(),
- name: 'Add an Action',
- type: WorkflowActionType.EMPTY,
- valid: true,
- nextStepIds: [iteratorStepId],
- settings: {
- ...BASE_STEP_DEFINITION,
- input: {},
- },
- position: {
- x: (iteratorPosition?.x ?? 0) + ITERATOR_EMPTY_STEP_POSITION_OFFSET.x,
- y: (iteratorPosition?.y ?? 0) + ITERATOR_EMPTY_STEP_POSITION_OFFSET.y,
- },
- };
-
- await this.workflowVersionCoreSyncService.writeWorkflowVersionAndMirror(
- workspaceId,
- async (scopedRepository) => {
- await scopedRepository.update(workflowVersion.id, {
- steps: [...existingSteps, emptyNodeStep],
- });
-
- return workflowVersion.id;
- },
- );
+ }): WorkflowAction {
+ const emptyNodeStep: WorkflowEmptyAction = {
+ id: v4(),
+ name: 'Add an Action',
+ type: WorkflowActionType.EMPTY,
+ valid: true,
+ nextStepIds: [iteratorStepId],
+ settings: {
+ ...BASE_STEP_DEFINITION,
+ input: {},
+ },
+ position: {
+ x: (iteratorPosition?.x ?? 0) + ITERATOR_EMPTY_STEP_POSITION_OFFSET.x,
+ y: (iteratorPosition?.y ?? 0) + ITERATOR_EMPTY_STEP_POSITION_OFFSET.y,
+ },
+ };
- return emptyNodeStep;
- }, authContext);
+ return emptyNodeStep;
}
- async createEmptyNodesForIfElseStep({
- workflowVersionId,
- workspaceId,
+ buildEmptyNodesForIfElseStep({
ifElsePosition,
}: {
- workflowVersionId: string;
- workspaceId: string;
ifElsePosition?: WorkflowStepPositionInput;
- }): Promise<{
+ }): {
ifEmptyNode: WorkflowAction;
elseEmptyNode: WorkflowAction;
ifFilterGroupId: string;
branches: StepIfElseBranch[];
- }> {
- const authContext = buildSystemAuthContext(workspaceId);
-
- return this.workspaceOrmManager.executeInWorkspaceContext(async () => {
- const workflowVersionRepository =
- this.workspaceOrmManager.getRepository<WorkflowVersionWorkspaceEntity>(
- 'workflowVersion',
- { shouldBypassPermissionChecks: true },
- );
-
- const workflowVersion = await workflowVersionRepository.findOne({
- where: {
- id: workflowVersionId,
- },
- });
+ } {
+ const ifEmptyNode: WorkflowEmptyAction = {
+ id: v4(),
+ name: 'Add an Action',
+ type: WorkflowActionType.EMPTY,
+ valid: true,
+ settings: {
+ ...BASE_STEP_DEFINITION,
+ input: {},
+ },
+ position: {
+ x: (ifElsePosition?.x ?? 0) + IF_ELSE_BRANCH_POSITION_OFFSETS.IF.x,
+ y: (ifElsePosition?.y ?? 0) + IF_ELSE_BRANCH_POSITION_OFFSETS.IF.y,
+ },
+ };
- if (!isDefined(workflowVersion)) {
- throw new WorkflowVersionStepException(
- 'WorkflowVersion not found',
- WorkflowVersionStepExceptionCode.NOT_FOUND,
- );
- }
+ const elseEmptyNode: WorkflowEmptyAction = {
+ id: v4(),
+ name: 'Add an Action',
+ type: WorkflowActionType.EMPTY,
+ valid: true,
+ settings: {
+ ...BASE_STEP_DEFINITION,
+ input: {},
+ },
+ position: {
+ x: (ifElsePosition?.x ?? 0) + IF_ELSE_BRANCH_POSITION_OFFSETS.ELSE.x,
+ y: (ifElsePosition?.y ?? 0) + IF_ELSE_BRANCH_POSITION_OFFSETS.ELSE.y,
+ },
+ };
- const existingSteps = workflowVersion.steps ?? [];
+ const ifFilterGroupId = v4();
- const ifEmptyNode: WorkflowEmptyAction = {
+ const branches: StepIfElseBranch[] = [
+ {
id: v4(),
- name: 'Add an Action',
- type: WorkflowActionType.EMPTY,
- valid: true,
- settings: {
- ...BASE_STEP_DEFINITION,
- input: {},
- },
- position: {
- x: (ifElsePosition?.x ?? 0) + IF_ELSE_BRANCH_POSITION_OFFSETS.IF.x,
- y: (ifElsePosition?.y ?? 0) + IF_ELSE_BRANCH_POSITION_OFFSETS.IF.y,
- },
- };
-
- const elseEmptyNode: WorkflowEmptyAction = {
+ filterGroupId: ifFilterGroupId,
+ nextStepIds: [ifEmptyNode.id],
+ },
+ {
id: v4(),
- name: 'Add an Action',
- type: WorkflowActionType.EMPTY,
- valid: true,
- settings: {
- ...BASE_STEP_DEFINITION,
- input: {},
- },
- position: {
- x: (ifElsePosition?.x ?? 0) + IF_ELSE_BRANCH_POSITION_OFFSETS.ELSE.x,
- y: (ifElsePosition?.y ?? 0) + IF_ELSE_BRANCH_POSITION_OFFSETS.ELSE.y,
- },
- };
-
- await this.workflowVersionCoreSyncService.writeWorkflowVersionAndMirror(
- workspaceId,
- async (scopedRepository) => {
- await scopedRepository.update(workflowVersion.id, {
- steps: [...existingSteps, ifEmptyNode, elseEmptyNode],
- });
-
- return workflowVersion.id;
- },
- );
-
- const ifFilterGroupId = v4();
-
- const branches: StepIfElseBranch[] = [
- {
- id: v4(),
- filterGroupId: ifFilterGroupId,
- nextStepIds: [ifEmptyNode.id],
- },
- {
- id: v4(),
- nextStepIds: [elseEmptyNode.id],
- },
- ];
+ nextStepIds: [elseEmptyNode.id],
+ },
+ ];
- return {
- ifEmptyNode,
- elseEmptyNode,
- ifFilterGroupId,
- branches,
- };
- }, authContext);
+ return {
+ ifEmptyNode,
+ elseEmptyNode,
+ ifFilterGroupId,
+ branches,
+ };
}
async createDraftStep({
diff --git a/packages/twenty-server/src/modules/workflow/workflow-builder/workflow-version-step/workflow-version-step-update.workspace-service.ts b/packages/twenty-server/src/modules/workflow/workflow-builder/workflow-version-step/workflow-version-step-update.workspace-service.ts
index 7fcfb8d44c6..cb8ac9d7d85 100644
--- a/packages/twenty-server/src/modules/workflow/workflow-builder/workflow-version-step/workflow-version-step-update.workspace-service.ts
+++ b/packages/twenty-server/src/modules/workflow/workflow-builder/workflow-version-step/workflow-version-step-update.workspace-service.ts
@@ -12,6 +12,7 @@ import { getNextStepIdsForStepTypeChange } from 'src/modules/workflow/workflow-b
import { WorkflowVersionStepHelpersWorkspaceService } from 'src/modules/workflow/workflow-builder/workflow-version-step/workflow-version-step-helpers.workspace-service';
import { WorkflowVersionStepOperationsWorkspaceService } from 'src/modules/workflow/workflow-builder/workflow-version-step/workflow-version-step-operations.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';
@Injectable()
export class WorkflowVersionStepUpdateWorkspaceService {
@@ -58,18 +59,23 @@ export class WorkflowVersionStepUpdateWorkspaceService {
const isStepTypeChanged = existingStep.type !== step.type;
+ const workflowVersionContent = {
+ trigger: workflowVersion.trigger,
+ steps: workflowVersion.steps,
+ };
+
const { updatedStep, additionalCreatedSteps } = isStepTypeChanged
? await this.updateWorkflowVersionStepType({
existingStep,
newStep: step,
workspaceId,
- workflowVersionId,
+ workflowVersionContent,
})
: {
updatedStep: await this.updateWorkflowVersionStepSettings({
newStep: step,
workspaceId,
- workflowVersionId,
+ workflowVersionContent,
}),
additionalCreatedSteps: undefined,
};
@@ -101,12 +107,15 @@ export class WorkflowVersionStepUpdateWorkspaceService {
existingStep,
newStep,
workspaceId,
- workflowVersionId,
+ workflowVersionContent,
}: {
existingStep: WorkflowAction;
newStep: WorkflowAction;
workspaceId: string;
- workflowVersionId: string;
+ workflowVersionContent: {
+ trigger: WorkflowTrigger | null;
+ steps: WorkflowAction[] | null;
+ };
}): Promise<{
updatedStep: WorkflowAction;
additionalCreatedSteps?: WorkflowAction[];
@@ -124,7 +133,6 @@ export class WorkflowVersionStepUpdateWorkspaceService {
type: newStep.type,
workspaceId,
position: newStep.position,
- workflowVersionId,
defaultSettings: newStep.settings,
},
);
@@ -141,7 +149,7 @@ export class WorkflowVersionStepUpdateWorkspaceService {
position: existingStep.position,
},
workspaceId,
- workflowVersionId,
+ workflowVersionContent,
});
return { updatedStep, additionalCreatedSteps };
@@ -150,16 +158,19 @@ export class WorkflowVersionStepUpdateWorkspaceService {
private async updateWorkflowVersionStepSettings({
newStep,
workspaceId,
- workflowVersionId,
+ workflowVersionContent,
}: {
newStep: WorkflowAction;
workspaceId: string;
- workflowVersionId: string;
+ workflowVersionContent: {
+ trigger: WorkflowTrigger | null;
+ steps: WorkflowAction[] | null;
+ };
}): Promise<WorkflowAction> {
return this.workflowSchemaWorkspaceService.enrichOutputSchema({
step: newStep,
workspaceId,
- workflowVersionId,
+ workflowVersionContent,
});
}
}
diff --git a/packages/twenty-server/src/modules/workflow/workflow-builder/workflow-version/workflow-version.workspace-service.ts b/packages/twenty-server/src/modules/workflow/workflow-builder/workflow-version/workflow-version.workspace-service.ts
index c90d7619640..34e51e7dc18 100644
--- a/packages/twenty-server/src/modules/workflow/workflow-builder/workflow-version/workflow-version.workspace-service.ts
+++ b/packages/twenty-server/src/modules/workflow/workflow-builder/workflow-version/workflow-version.workspace-service.ts
@@ -6,7 +6,6 @@ import {
computeWorkflowLayout,
TRIGGER_STEP_ID,
WORKFLOW_DIAGRAM_DEFAULT_NODE_DIMENSIONS,
- WorkflowActionType,
} from 'twenty-shared/workflow';
import { WithLock } from 'src/engine/core-modules/cache-lock/with-lock.decorator';
@@ -31,6 +30,7 @@ import { assertWorkflowVersionHasSteps } from 'src/modules/workflow/common/utils
import { assertWorkflowVersionIsDraft } from 'src/modules/workflow/common/utils/assert-workflow-version-is-draft.util';
import { assertWorkflowVersionTriggerIsDefined } from 'src/modules/workflow/common/utils/assert-workflow-version-trigger-is-defined.util';
import { WorkflowCommonWorkspaceService } from 'src/modules/workflow/common/workspace-services/workflow-common.workspace-service';
+import { remapDuplicatedStepDestinations } from 'src/modules/workflow/workflow-builder/utils/remap-duplicated-step-destinations.util';
import { WorkflowVersionStepOperationsWorkspaceService } from 'src/modules/workflow/workflow-builder/workflow-version-step/workflow-version-step-operations.workspace-service';
import { WorkflowVersionStepWorkspaceService } from 'src/modules/workflow/workflow-builder/workflow-version-step/workflow-version-step.workspace-service';
import { type WorkflowAction } from 'src/modules/workflow/workflow-executor/workflow-actions/types/workflow-action.type';
@@ -263,11 +263,11 @@ export class WorkflowVersionWorkspaceService {
});
const newTrigger = sourceVersion.trigger;
- const sourceToClonedPairs: Array<{
+ const sourceToClonedPairs: {
source: WorkflowAction;
duplicated: WorkflowAction;
- }> = [];
- const oldToNewIdMap = new Map<string, string>();
+ }[] = [];
+ const clonedStepIdBySourceStepId = new Map<string, string>();
for (const step of sourceVersion.steps ?? []) {
const clonedStep =
@@ -280,47 +280,22 @@ export class WorkflowVersionWorkspaceService {
source: step,
duplicated: clonedStep,
});
- oldToNewIdMap.set(step.id, clonedStep.id);
+ clonedStepIdBySourceStepId.set(step.id, clonedStep.id);
}
- const remappedTrigger = isDefined(newTrigger)
- ? {
- ...newTrigger,
- nextStepIds: (newTrigger.nextStepIds ?? []).map(
- (oldId) => oldToNewIdMap.get(oldId) ?? oldId,
- ),
- }
- : undefined;
-
- const remappedSteps: WorkflowAction[] = sourceToClonedPairs.map(
- ({ source, duplicated }) => {
- const remappedStep = {
- ...duplicated,
- nextStepIds: (source.nextStepIds ?? []).map(
- (oldId) => oldToNewIdMap.get(oldId) ?? oldId,
- ),
+ const { trigger: remappedTrigger, steps: remappedSteps } = isDefined(
+ newTrigger,
+ )
+ ? remapDuplicatedStepDestinations({
+ trigger: newTrigger,
+ sourceToClonedPairs,
+ clonedStepIdBySourceStepId,
+ })
+ : {
+ trigger: undefined,
+ steps: sourceToClonedPairs.map(({ duplicated }) => duplicated),
};
- if (
- source.type === WorkflowActionType.ITERATOR &&
- isDefined(source.settings?.input?.initialLoopStepIds)
- ) {
- remappedStep.settings = {
- ...remappedStep.settings,
- input: {
- ...remappedStep.settings.input,
- initialLoopStepIds:
- source.settings.input.initialLoopStepIds.map(
- (oldId: string) => oldToNewIdMap.get(oldId) ?? oldId,
- ),
- },
- };
- }
-
- return remappedStep;
- },
- );
-
let newDraftVersion: WorkflowVersionWorkspaceEntity | undefined;
await this.workflowVersionCoreSyncService.writeWorkflowVersionAndMirror(
diff --git a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/compute-step-output-schema.tool.ts b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/compute-step-output-schema.tool.ts
index b5a07e7c97b..0ba3fae9385 100644
--- a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/compute-step-output-schema.tool.ts
+++ b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/compute-step-output-schema.tool.ts
@@ -22,7 +22,10 @@ const computeStepOutputSchemaSchema = z.object({
});
export const createComputeStepOutputSchemaTool = (
- deps: Pick<WorkflowToolDependencies, 'workflowSchemaService'>,
+ deps: Pick<
+ WorkflowToolDependencies,
+ 'workflowSchemaService' | 'workflowCommonService'
+ >,
context: WorkflowToolContext,
) => ({
name: 'compute_step_output_schema' as const,
@@ -34,10 +37,19 @@ export const createComputeStepOutputSchemaTool = (
workflowVersionId: string;
}) => {
try {
+ const workflowVersion =
+ await deps.workflowCommonService.getWorkflowVersionOrFail({
+ workflowVersionId: parameters.workflowVersionId,
+ workspaceId: context.workspaceId,
+ });
+
return await deps.workflowSchemaService.computeStepOutputSchema({
step: parameters.step,
workspaceId: context.workspaceId,
- workflowVersionId: parameters.workflowVersionId,
+ workflowVersionContent: {
+ trigger: workflowVersion.trigger,
+ steps: workflowVersion.steps,
+ },
});
} catch (error) {
return {
diff --git a/packages/twenty-server/src/modules/workflow/workflow-trigger/utils/assert-pick-record-load-balance-config-is-valid.util.ts b/packages/twenty-server/src/modules/workflow/workflow-trigger/utils/assert-pick-record-load-balance-config-is-valid.util.ts
new file mode 100644
index 00000000000..0e6e0cb2364
--- /dev/null
+++ b/packages/twenty-server/src/modules/workflow/workflow-trigger/utils/assert-pick-record-load-balance-config-is-valid.util.ts
@@ -0,0 +1,44 @@
+import { isDefined } from 'twenty-shared/utils';
+import { WorkflowActionType } from 'twenty-shared/workflow';
+
+import { type FlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/flat-entity-maps.type';
+import { type FlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/types/flat-field-metadata.type';
+import {
+ WorkflowTriggerException,
+ WorkflowTriggerExceptionCode,
+} from 'src/modules/workflow/workflow-trigger/exceptions/workflow-trigger.exception';
+import { getPickRecordLoadBalanceConfigError } from 'src/modules/workflow/workflow-builder/workflow-validation/utils/get-pick-record-load-balance-config-error.util';
+import {
+ type WorkflowAction,
+ type WorkflowPickRecordAction,
+} from 'src/modules/workflow/workflow-executor/workflow-actions/types/workflow-action.type';
+
+export const assertPickRecordLoadBalanceConfigIsValid = ({
+ steps,
+ objectIdByNameSingular,
+ flatFieldMetadataMaps,
+}: {
+ steps: WorkflowAction[];
+ objectIdByNameSingular: Record<string, string>;
+ flatFieldMetadataMaps: FlatEntityMaps<FlatFieldMetadata>;
+}): void => {
+ const pickRecordSteps = steps.filter(
+ (step): step is WorkflowPickRecordAction =>
+ step.type === WorkflowActionType.PICK_RECORD,
+ );
+
+ for (const step of pickRecordSteps) {
+ const loadBalanceError = getPickRecordLoadBalanceConfigError({
+ step,
+ objectIdByNameSingular,
+ flatFieldMetadataMaps,
+ });
+
+ if (isDefined(loadBalanceError)) {
+ throw new WorkflowTriggerException(
+ loadBalanceError,
+ WorkflowTriggerExceptionCode.INVALID_WORKFLOW_VERSION,
+ );
+ }
+ }
+};
diff --git a/packages/twenty-server/src/modules/workflow/workflow-trigger/utils/assert-version-can-be-activated.util.ts b/packages/twenty-server/src/modules/workflow/workflow-trigger/utils/assert-version-can-be-activated.util.ts
index 8a7a5211ec6..77c23e5b0ec 100644
--- a/packages/twenty-server/src/modules/workflow/workflow-trigger/utils/assert-version-can-be-activated.util.ts
+++ b/packages/twenty-server/src/modules/workflow/workflow-trigger/utils/assert-version-can-be-activated.util.ts
@@ -15,8 +15,11 @@ import { WorkflowTriggerType } from 'src/modules/workflow/workflow-trigger/types
import { assertFormStepIsValid } from 'src/modules/workflow/workflow-trigger/utils/assert-form-step-is-valid.util';
export function assertVersionCanBeActivated(
- workflowVersion: WorkflowVersionWorkspaceEntity,
- workflow: WorkflowWorkspaceEntity,
+ workflowVersion: Pick<
+ WorkflowVersionWorkspaceEntity,
+ 'id' | 'status' | 'trigger' | 'steps'
+ >,
+ workflow: Pick<WorkflowWorkspaceEntity, 'lastPublishedVersionId'>,
) {
assertVersionIsValid(workflowVersion);
@@ -40,7 +43,12 @@ export function assertVersionCanBeActivated(
}
}
-function assertVersionIsValid(workflowVersion: WorkflowVersionWorkspaceEntity) {
+function assertVersionIsValid(
+ workflowVersion: Pick<
+ WorkflowVersionWorkspaceEntity,
+ 'id' | 'status' | 'trigger' | 'steps'
+ >,
+) {
if (!workflowVersion.trigger) {
throw new WorkflowTriggerException(
'Workflow version does not contain trigger',
diff --git a/packages/twenty-server/src/modules/workflow/workflow-trigger/utils/build-workflow-run-trigger-context.util.ts b/packages/twenty-server/src/modules/workflow/workflow-trigger/utils/build-workflow-run-trigger-context.util.ts
new file mode 100644
index 00000000000..e796e691dd3
--- /dev/null
+++ b/packages/twenty-server/src/modules/workflow/workflow-trigger/utils/build-workflow-run-trigger-context.util.ts
@@ -0,0 +1,31 @@
+import {
+ WORKFLOW_TRIGGER_METADATA_KEY,
+ WORKFLOW_TRIGGER_METADATA_WORKSPACE_MEMBER_ID_KEY,
+ WORKFLOW_TRIGGER_PAYLOAD_KEY,
+} from 'twenty-shared/workflow';
+
+import { buildCreatedByFromFullNameMetadata } from 'src/engine/core-modules/actor/utils/build-created-by-from-full-name-metadata.util';
+import { type WorkspaceMemberWorkspaceEntity } from 'src/modules/workspace-member/standard-objects/workspace-member.workspace-entity';
+
+export const buildWorkflowRunTriggerContext = ({
+ workspaceMember,
+ payload,
+}: {
+ workspaceMember: Pick<WorkspaceMemberWorkspaceEntity, 'id' | 'name'>;
+ payload?: object | null;
+}) => ({
+ payload: {
+ ...payload,
+ [WORKFLOW_TRIGGER_PAYLOAD_KEY]: { ...payload },
+ [WORKFLOW_TRIGGER_METADATA_KEY]: {
+ [WORKFLOW_TRIGGER_METADATA_WORKSPACE_MEMBER_ID_KEY]: workspaceMember.id,
+ },
+ },
+ createdBy: buildCreatedByFromFullNameMetadata({
+ fullNameMetadata: {
+ firstName: workspaceMember.name.firstName,
+ lastName: workspaceMember.name.lastName,
+ },
+ workspaceMemberId: workspaceMember.id,
+ }),
+});
diff --git a/packages/twenty-server/test/integration/graphql/suites/workflow/core-workflow-id-mutations.integration-spec.ts b/packages/twenty-server/test/integration/graphql/suites/workflow/core-workflow-id-mutations.integration-spec.ts
new file mode 100644
index 00000000000..76f8c69dd18
--- /dev/null
+++ b/packages/twenty-server/test/integration/graphql/suites/workflow/core-workflow-id-mutations.integration-spec.ts
@@ -0,0 +1,582 @@
+import { workflowGraphqlRequest } from 'test/integration/graphql/suites/workflow/utils/workflow-graphql-request.util';
+import {
+ destroyWorkflowRun,
+ waitForWorkflowCompletion,
+} from 'test/integration/graphql/suites/workflow/utils/workflow-run-test.util';
+
+const CORE_WORKFLOW_VERSIONS = `
+ query CoreWorkflowVersionsByCoreWorkflowId($coreWorkflowId: UUID!) {
+ coreWorkflowVersionsByCoreWorkflowId(coreWorkflowId: $coreWorkflowId) {
+ id
+ status
+ }
+ }
+`;
+
+const CORE_WORKFLOW_VERSION_BY_ID = `
+ query CoreWorkflowVersionById($coreWorkflowVersionId: UUID!) {
+ coreWorkflowVersionById(coreWorkflowVersionId: $coreWorkflowVersionId) {
+ id
+ status
+ trigger
+ steps
+ }
+ }
+`;
+
+const MANUAL_TRIGGER = {
+ name: 'Manual Trigger',
+ type: 'MANUAL',
+ settings: { outputSchema: {} },
+ nextStepIds: [],
+ position: { x: 0, y: 0 },
+};
+
+describe('core workflow id mutations (e2e)', () => {
+ let coreWorkflowId: string;
+ let coreWorkflowVersionId: string;
+ const workflowRunIds: string[] = [];
+ const coreWorkflowIdsToDelete: string[] = [];
+
+ const getVersions = async (workflowId: string) => {
+ const response = await workflowGraphqlRequest(CORE_WORKFLOW_VERSIONS, {
+ coreWorkflowId: workflowId,
+ });
+
+ expect(response.body.errors).toBeUndefined();
+
+ return response.body.data.coreWorkflowVersionsByCoreWorkflowId;
+ };
+
+ const getVersionById = async (id: string) => {
+ const response = await workflowGraphqlRequest(CORE_WORKFLOW_VERSION_BY_ID, {
+ coreWorkflowVersionId: id,
+ });
+
+ expect(response.body.errors).toBeUndefined();
+
+ return response.body.data.coreWorkflowVersionById;
+ };
+
+ beforeAll(async () => {
+ const createResponse = await workflowGraphqlRequest(`
+ mutation {
+ createCoreWorkflow(input: { name: "Core Id Mutations" }) {
+ id
+ }
+ }
+ `);
+
+ expect(createResponse.body.errors).toBeUndefined();
+
+ coreWorkflowId = createResponse.body.data.createCoreWorkflow.id;
+ coreWorkflowIdsToDelete.push(coreWorkflowId);
+
+ const versions = await getVersions(coreWorkflowId);
+
+ expect(versions).toHaveLength(1);
+
+ coreWorkflowVersionId = versions[0].id;
+ });
+
+ afterAll(async () => {
+ for (const workflowRunId of workflowRunIds) {
+ await destroyWorkflowRun(workflowRunId);
+ }
+
+ await workflowGraphqlRequest(
+ `
+ mutation DeleteCoreWorkflows($input: DeleteCoreWorkflowsInput!) {
+ deleteCoreWorkflows(input: $input) {
+ id
+ }
+ }
+ `,
+ { input: { coreWorkflowIds: coreWorkflowIdsToDelete } },
+ );
+ });
+
+ it('renames the workflow by core id', async () => {
+ const response = await workflowGraphqlRequest(
+ `
+ mutation UpdateCoreWorkflow($input: UpdateCoreWorkflowInput!) {
+ updateCoreWorkflow(input: $input) {
+ id
+ name
+ }
+ }
+ `,
+ { input: { coreWorkflowId, name: 'Core Id Mutations Renamed' } },
+ );
+
+ expect(response.body.errors).toBeUndefined();
+ expect(response.body.data.updateCoreWorkflow.name).toBe(
+ 'Core Id Mutations Renamed',
+ );
+ });
+
+ it('builds the draft through core-id builder mutations', async () => {
+ const triggerResponse = await workflowGraphqlRequest(
+ `
+ mutation UpdateCoreWorkflowVersionTrigger(
+ $input: UpdateCoreWorkflowVersionTriggerInput!
+ ) {
+ updateCoreWorkflowVersionTrigger(input: $input) {
+ trigger
+ }
+ }
+ `,
+ { input: { coreWorkflowVersionId, trigger: MANUAL_TRIGGER } },
+ );
+
+ expect(triggerResponse.body.errors).toBeUndefined();
+
+ const createStepResponse = await workflowGraphqlRequest(
+ `
+ mutation CreateCoreWorkflowVersionStep(
+ $input: CreateCoreWorkflowVersionStepInput!
+ ) {
+ createCoreWorkflowVersionStep(input: $input) {
+ stepsDiff
+ }
+ }
+ `,
+ {
+ input: {
+ coreWorkflowVersionId,
+ stepType: 'CODE',
+ parentStepId: 'trigger',
+ position: { x: 200, y: 0 },
+ },
+ },
+ );
+
+ expect(createStepResponse.body.errors).toBeUndefined();
+
+ const versionAfterStepCreation = await getVersionById(
+ coreWorkflowVersionId,
+ );
+
+ expect(versionAfterStepCreation.steps).toHaveLength(1);
+
+ const stepId = versionAfterStepCreation.steps[0].id;
+
+ const positionsResponse = await workflowGraphqlRequest(
+ `
+ mutation UpdateCoreWorkflowVersionPositions(
+ $input: UpdateCoreWorkflowVersionPositionsInput!
+ ) {
+ updateCoreWorkflowVersionPositions(input: $input)
+ }
+ `,
+ {
+ input: {
+ coreWorkflowVersionId,
+ positions: [{ id: stepId, position: { x: 250, y: 50 } }],
+ },
+ },
+ );
+
+ expect(positionsResponse.body.errors).toBeUndefined();
+
+ const deleteEdgeResponse = await workflowGraphqlRequest(
+ `
+ mutation DeleteCoreWorkflowVersionEdge(
+ $input: DeleteCoreWorkflowVersionEdgeInput!
+ ) {
+ deleteCoreWorkflowVersionEdge(input: $input) {
+ triggerDiff
+ }
+ }
+ `,
+ { input: { coreWorkflowVersionId, source: 'trigger', target: stepId } },
+ );
+
+ expect(deleteEdgeResponse.body.errors).toBeUndefined();
+
+ const createEdgeResponse = await workflowGraphqlRequest(
+ `
+ mutation CreateCoreWorkflowVersionEdge(
+ $input: CreateCoreWorkflowVersionEdgeInput!
+ ) {
+ createCoreWorkflowVersionEdge(input: $input) {
+ triggerDiff
+ }
+ }
+ `,
+ { input: { coreWorkflowVersionId, source: 'trigger', target: stepId } },
+ );
+
+ expect(createEdgeResponse.body.errors).toBeUndefined();
+
+ const version = await getVersionById(coreWorkflowVersionId);
+
+ expect(version.trigger.type).toBe('MANUAL');
+ expect(version.trigger.nextStepIds).toEqual([stepId]);
+ expect(version.steps).toHaveLength(1);
+ });
+
+ it('activates, runs and deactivates by core ids', async () => {
+ const validateResponse = await workflowGraphqlRequest(
+ `
+ mutation ValidateCoreWorkflowVersion($coreWorkflowVersionId: UUID!) {
+ validateCoreWorkflowVersion(
+ coreWorkflowVersionId: $coreWorkflowVersionId
+ )
+ }
+ `,
+ { coreWorkflowVersionId },
+ );
+
+ expect(validateResponse.body.errors).toBeUndefined();
+ expect(validateResponse.body.data.validateCoreWorkflowVersion).toBe(true);
+
+ const activateResponse = await workflowGraphqlRequest(
+ `
+ mutation ActivateCoreWorkflowVersion($coreWorkflowVersionId: UUID!) {
+ activateCoreWorkflowVersion(
+ coreWorkflowVersionId: $coreWorkflowVersionId
+ )
+ }
+ `,
+ { coreWorkflowVersionId },
+ );
+
+ expect(activateResponse.body.errors).toBeUndefined();
+ expect(activateResponse.body.data.activateCoreWorkflowVersion).toBe(true);
+
+ const activatedVersion = await getVersionById(coreWorkflowVersionId);
+
+ expect(activatedVersion.status).toBe('ACTIVE');
+
+ const runResponse = await workflowGraphqlRequest(
+ `
+ mutation RunCoreWorkflowVersion($input: RunCoreWorkflowVersionInput!) {
+ runCoreWorkflowVersion(input: $input) {
+ workflowRunId
+ }
+ }
+ `,
+ { input: { coreWorkflowVersionId } },
+ );
+
+ expect(runResponse.body.errors).toBeUndefined();
+
+ const workflowRunId =
+ runResponse.body.data.runCoreWorkflowVersion.workflowRunId;
+
+ workflowRunIds.push(workflowRunId);
+
+ const completedRun = await waitForWorkflowCompletion(workflowRunId);
+
+ expect(completedRun?.status).toBe('COMPLETED');
+
+ const deactivateResponse = await workflowGraphqlRequest(
+ `
+ mutation DeactivateCoreWorkflowVersion($coreWorkflowVersionId: UUID!) {
+ deactivateCoreWorkflowVersion(
+ coreWorkflowVersionId: $coreWorkflowVersionId
+ )
+ }
+ `,
+ { coreWorkflowVersionId },
+ );
+
+ expect(deactivateResponse.body.errors).toBeUndefined();
+
+ const deactivatedVersion = await getVersionById(coreWorkflowVersionId);
+
+ expect(deactivatedVersion.status).toBe('DEACTIVATED');
+ });
+
+ it('archives the previously published version when publishing after a deactivation', async () => {
+ const createResponse = await workflowGraphqlRequest(`
+ mutation {
+ createCoreWorkflow(input: { name: "Core Republish After Deactivation" }) {
+ id
+ }
+ }
+ `);
+
+ expect(createResponse.body.errors).toBeUndefined();
+
+ const republishedCoreWorkflowId =
+ createResponse.body.data.createCoreWorkflow.id;
+
+ coreWorkflowIdsToDelete.push(republishedCoreWorkflowId);
+
+ const [firstVersion] = await getVersions(republishedCoreWorkflowId);
+
+ const triggerResponse = await workflowGraphqlRequest(
+ `
+ mutation UpdateCoreWorkflowVersionTrigger(
+ $input: UpdateCoreWorkflowVersionTriggerInput!
+ ) {
+ updateCoreWorkflowVersionTrigger(input: $input) {
+ trigger
+ }
+ }
+ `,
+ {
+ input: {
+ coreWorkflowVersionId: firstVersion.id,
+ trigger: MANUAL_TRIGGER,
+ },
+ },
+ );
+
+ expect(triggerResponse.body.errors).toBeUndefined();
+
+ const createStepResponse = await workflowGraphqlRequest(
+ `
+ mutation CreateCoreWorkflowVersionStep(
+ $input: CreateCoreWorkflowVersionStepInput!
+ ) {
+ createCoreWorkflowVersionStep(input: $input) {
+ stepsDiff
+ }
+ }
+ `,
+ {
+ input: {
+ coreWorkflowVersionId: firstVersion.id,
+ stepType: 'CODE',
+ parentStepId: 'trigger',
+ position: { x: 200, y: 0 },
+ },
+ },
+ );
+
+ expect(createStepResponse.body.errors).toBeUndefined();
+
+ const activateMutation = `
+ mutation ActivateCoreWorkflowVersion($coreWorkflowVersionId: UUID!) {
+ activateCoreWorkflowVersion(coreWorkflowVersionId: $coreWorkflowVersionId)
+ }
+ `;
+
+ const firstActivationResponse = await workflowGraphqlRequest(
+ activateMutation,
+ { coreWorkflowVersionId: firstVersion.id },
+ );
+
+ expect(firstActivationResponse.body.errors).toBeUndefined();
+
+ const deactivationResponse = await workflowGraphqlRequest(
+ `
+ mutation DeactivateCoreWorkflowVersion($coreWorkflowVersionId: UUID!) {
+ deactivateCoreWorkflowVersion(
+ coreWorkflowVersionId: $coreWorkflowVersionId
+ )
+ }
+ `,
+ { coreWorkflowVersionId: firstVersion.id },
+ );
+
+ expect(deactivationResponse.body.errors).toBeUndefined();
+
+ const draftResponse = await workflowGraphqlRequest(
+ `
+ mutation CreateDraftFromCoreWorkflowVersion(
+ $input: CreateDraftFromCoreWorkflowVersionInput!
+ ) {
+ createDraftFromCoreWorkflowVersion(input: $input) {
+ id
+ }
+ }
+ `,
+ {
+ input: {
+ coreWorkflowId: republishedCoreWorkflowId,
+ coreWorkflowVersionIdToCopy: firstVersion.id,
+ },
+ },
+ );
+
+ expect(draftResponse.body.errors).toBeUndefined();
+
+ const secondVersionId =
+ draftResponse.body.data.createDraftFromCoreWorkflowVersion.id;
+
+ const secondActivationResponse = await workflowGraphqlRequest(
+ activateMutation,
+ { coreWorkflowVersionId: secondVersionId },
+ );
+
+ expect(secondActivationResponse.body.errors).toBeUndefined();
+
+ const firstVersionAfterRepublish = await getVersionById(firstVersion.id);
+ const secondVersionAfterRepublish = await getVersionById(secondVersionId);
+
+ expect(firstVersionAfterRepublish.status).toBe('ARCHIVED');
+ expect(secondVersionAfterRepublish.status).toBe('ACTIVE');
+
+ await workflowGraphqlRequest(
+ `
+ mutation DeactivateCoreWorkflowVersion($coreWorkflowVersionId: UUID!) {
+ deactivateCoreWorkflowVersion(
+ coreWorkflowVersionId: $coreWorkflowVersionId
+ )
+ }
+ `,
+ { coreWorkflowVersionId: secondVersionId },
+ );
+ });
+
+ it('creates a draft from a core version, edits it and discards it by core id', async () => {
+ const draftResponse = await workflowGraphqlRequest(
+ `
+ mutation CreateDraftFromCoreWorkflowVersion(
+ $input: CreateDraftFromCoreWorkflowVersionInput!
+ ) {
+ createDraftFromCoreWorkflowVersion(input: $input) {
+ id
+ status
+ }
+ }
+ `,
+ {
+ input: {
+ coreWorkflowId,
+ coreWorkflowVersionIdToCopy: coreWorkflowVersionId,
+ },
+ },
+ );
+
+ expect(draftResponse.body.errors).toBeUndefined();
+
+ const draft = draftResponse.body.data.createDraftFromCoreWorkflowVersion;
+
+ expect(draft.status).toBe('DRAFT');
+ expect(draft.id).not.toBe(coreWorkflowVersionId);
+
+ const draftContent = await getVersionById(draft.id);
+ const copiedStepId = draftContent.steps[0].id;
+
+ const duplicateStepResponse = await workflowGraphqlRequest(
+ `
+ mutation DuplicateCoreWorkflowVersionStep(
+ $input: DuplicateCoreWorkflowVersionStepInput!
+ ) {
+ duplicateCoreWorkflowVersionStep(input: $input) {
+ stepsDiff
+ }
+ }
+ `,
+ { input: { coreWorkflowVersionId: draft.id, stepId: copiedStepId } },
+ );
+
+ expect(duplicateStepResponse.body.errors).toBeUndefined();
+
+ const draftAfterDuplication = await getVersionById(draft.id);
+
+ expect(draftAfterDuplication.steps).toHaveLength(2);
+
+ const duplicatedStepId = draftAfterDuplication.steps.find(
+ (step: { id: string }) => step.id !== copiedStepId,
+ ).id;
+
+ const deleteStepResponse = await workflowGraphqlRequest(
+ `
+ mutation DeleteCoreWorkflowVersionStep(
+ $input: DeleteCoreWorkflowVersionStepInput!
+ ) {
+ deleteCoreWorkflowVersionStep(input: $input) {
+ stepsDiff
+ }
+ }
+ `,
+ { input: { coreWorkflowVersionId: draft.id, stepId: duplicatedStepId } },
+ );
+
+ expect(deleteStepResponse.body.errors).toBeUndefined();
+
+ const discardResponse = await workflowGraphqlRequest(
+ `
+ mutation DiscardCoreWorkflowDraft($input: DiscardCoreWorkflowDraftInput!) {
+ discardCoreWorkflowDraft(input: $input) {
+ id
+ }
+ }
+ `,
+ { input: { coreWorkflowVersionId: draft.id } },
+ );
+
+ expect(discardResponse.body.errors).toBeUndefined();
+ expect(discardResponse.body.data.discardCoreWorkflowDraft.id).toBe(
+ coreWorkflowId,
+ );
+
+ expect(await getVersionById(draft.id)).toBeNull();
+ });
+
+ it('duplicates the workflow by core ids', async () => {
+ const response = await workflowGraphqlRequest(
+ `
+ mutation DuplicateCoreWorkflow($input: DuplicateCoreWorkflowInput!) {
+ duplicateCoreWorkflow(input: $input) {
+ id
+ name
+ }
+ }
+ `,
+ {
+ input: {
+ coreWorkflowIdToDuplicate: coreWorkflowId,
+ coreWorkflowVersionIdToCopy: coreWorkflowVersionId,
+ },
+ },
+ );
+
+ expect(response.body.errors).toBeUndefined();
+
+ const duplicated = response.body.data.duplicateCoreWorkflow;
+
+ expect(duplicated.id).not.toBe(coreWorkflowId);
+
+ coreWorkflowIdsToDelete.push(duplicated.id);
+
+ const duplicatedVersions = await getVersions(duplicated.id);
+
+ expect(duplicatedVersions).toHaveLength(1);
+ });
+
+ it('rejects core ids that do not exist', async () => {
+ const absentId = '00000000-0000-4000-8000-000000000000';
+
+ const response = await workflowGraphqlRequest(
+ `
+ mutation ActivateCoreWorkflowVersion($coreWorkflowVersionId: UUID!) {
+ activateCoreWorkflowVersion(
+ coreWorkflowVersionId: $coreWorkflowVersionId
+ )
+ }
+ `,
+ { coreWorkflowVersionId: absentId },
+ );
+
+ expect(response.body.errors).toBeDefined();
+ expect(response.body.errors[0].message).toContain('not found');
+ });
+
+ it('rejects a discard carrying both transitional ids', async () => {
+ const response = await workflowGraphqlRequest(
+ `
+ mutation DiscardCoreWorkflowDraft($input: DiscardCoreWorkflowDraftInput!) {
+ discardCoreWorkflowDraft(input: $input) {
+ id
+ }
+ }
+ `,
+ {
+ input: {
+ coreWorkflowVersionId: coreWorkflowVersionId,
+ workspaceWorkflowVersionId: coreWorkflowVersionId,
+ },
+ },
+ );
+
+ expect(response.body.errors).toBeDefined();
+ expect(response.body.errors[0].message).toContain('Only one');
+ });
+});
diff --git a/packages/twenty-server/test/integration/graphql/suites/workflow/core-workflow-id-native-queries.integration-spec.ts b/packages/twenty-server/test/integration/graphql/suites/workflow/core-workflow-id-native-queries.integration-spec.ts
new file mode 100644
index 00000000000..9a041997f28
--- /dev/null
+++ b/packages/twenty-server/test/integration/graphql/suites/workflow/core-workflow-id-native-queries.integration-spec.ts
@@ -0,0 +1,161 @@
+import { workflowGraphqlRequest } from 'test/integration/graphql/suites/workflow/utils/workflow-graphql-request.util';
+
+const CORE_WORKFLOW_VERSIONS_BY_CORE_WORKFLOW_ID = `
+ query CoreWorkflowVersionsByCoreWorkflowId($coreWorkflowId: UUID!) {
+ coreWorkflowVersionsByCoreWorkflowId(coreWorkflowId: $coreWorkflowId) {
+ id
+ label
+ status
+ workspaceWorkflowId
+ workspaceWorkflowVersionId
+ }
+ }
+`;
+
+const CORE_WORKFLOW_VERSION_BY_ID = `
+ query CoreWorkflowVersionById($coreWorkflowVersionId: UUID!) {
+ coreWorkflowVersionById(coreWorkflowVersionId: $coreWorkflowVersionId) {
+ id
+ label
+ status
+ trigger
+ steps
+ }
+ }
+`;
+
+const CORE_WORKFLOW_VERSIONS_LEGACY = `
+ query CoreWorkflowVersions($workspaceWorkflowId: UUID!) {
+ coreWorkflowVersions(workspaceWorkflowId: $workspaceWorkflowId) {
+ id
+ label
+ status
+ workspaceWorkflowVersionId
+ }
+ }
+`;
+
+const ABSENT_ID = '00000000-0000-4000-8000-000000000000';
+
+describe('core workflow id native queries (e2e)', () => {
+ let coreWorkflowId: string;
+ let workspaceWorkflowId: string;
+
+ beforeAll(async () => {
+ const createResponse = await workflowGraphqlRequest(`
+ mutation {
+ createCoreWorkflow(input: { name: "Core Id Native Queries" }) {
+ id
+ workspaceWorkflowId
+ }
+ }
+ `);
+
+ expect(createResponse.body.errors).toBeUndefined();
+
+ coreWorkflowId = createResponse.body.data.createCoreWorkflow.id;
+ workspaceWorkflowId =
+ createResponse.body.data.createCoreWorkflow.workspaceWorkflowId;
+ });
+
+ afterAll(async () => {
+ await workflowGraphqlRequest(
+ `
+ mutation DestroyWorkflow($id: ID!) {
+ destroyWorkflow(id: $id) {
+ id
+ }
+ }
+ `,
+ { id: workspaceWorkflowId },
+ );
+ });
+
+ it('lists the versions by core workflow id, mirror ids included', async () => {
+ const response = await workflowGraphqlRequest(
+ CORE_WORKFLOW_VERSIONS_BY_CORE_WORKFLOW_ID,
+ { coreWorkflowId },
+ );
+
+ expect(response.body.errors).toBeUndefined();
+
+ const versions = response.body.data.coreWorkflowVersionsByCoreWorkflowId;
+
+ expect(versions).toHaveLength(1);
+ expect(versions[0].status).toBe('DRAFT');
+ expect(versions[0].label).toBe('v1');
+ expect(versions[0].workspaceWorkflowId).toBe(workspaceWorkflowId);
+ expect(versions[0].workspaceWorkflowVersionId).not.toBeNull();
+ });
+
+ it('resolves a version by its core id, with its content', async () => {
+ const versionsResponse = await workflowGraphqlRequest(
+ CORE_WORKFLOW_VERSIONS_BY_CORE_WORKFLOW_ID,
+ { coreWorkflowId },
+ );
+
+ const coreWorkflowVersionId =
+ versionsResponse.body.data.coreWorkflowVersionsByCoreWorkflowId[0].id;
+
+ const response = await workflowGraphqlRequest(CORE_WORKFLOW_VERSION_BY_ID, {
+ coreWorkflowVersionId,
+ });
+
+ expect(response.body.errors).toBeUndefined();
+ expect(response.body.data.coreWorkflowVersionById.id).toBe(
+ coreWorkflowVersionId,
+ );
+ expect(response.body.data.coreWorkflowVersionById.label).toBe('v1');
+ });
+
+ it('agrees with the workspace-keyed query on the version list, labels included', async () => {
+ const [byCoreId, byWorkspaceId] = await Promise.all([
+ workflowGraphqlRequest(CORE_WORKFLOW_VERSIONS_BY_CORE_WORKFLOW_ID, {
+ coreWorkflowId,
+ }),
+ workflowGraphqlRequest(CORE_WORKFLOW_VERSIONS_LEGACY, {
+ workspaceWorkflowId,
+ }),
+ ]);
+
+ expect(byCoreId.body.errors).toBeUndefined();
+ expect(byWorkspaceId.body.errors).toBeUndefined();
+
+ const normalise = (
+ versions: {
+ id: string;
+ label: string;
+ status: string;
+ workspaceWorkflowVersionId: string | null;
+ }[],
+ ) =>
+ versions.map(({ id, label, status, workspaceWorkflowVersionId }) => ({
+ id,
+ label,
+ status,
+ workspaceWorkflowVersionId,
+ }));
+
+ expect(
+ normalise(byCoreId.body.data.coreWorkflowVersionsByCoreWorkflowId),
+ ).toEqual(normalise(byWorkspaceId.body.data.coreWorkflowVersions));
+ });
+
+ it('returns nothing for ids that exist in neither table', async () => {
+ const versionResponse = await workflowGraphqlRequest(
+ CORE_WORKFLOW_VERSION_BY_ID,
+ { coreWorkflowVersionId: ABSENT_ID },
+ );
+
+ expect(versionResponse.body.data.coreWorkflowVersionById).toBeNull();
+
+ const versionsResponse = await workflowGraphqlRequest(
+ CORE_WORKFLOW_VERSIONS_BY_CORE_WORKFLOW_ID,
+ { coreWorkflowId: ABSENT_ID },
+ );
+
+ expect(
+ versionsResponse.body.data.coreWorkflowVersionsByCoreWorkflowId,
+ ).toEqual([]);
+ });
+});
diff --git a/packages/twenty-server/test/integration/graphql/suites/workflow/core-workflow-read.integration-spec.ts b/packages/twenty-server/test/integration/graphql/suites/workflow/core-workflow-read.integration-spec.ts
index 60fea596aac..aad8ebcc570 100644
--- a/packages/twenty-server/test/integration/graphql/suites/workflow/core-workflow-read.integration-spec.ts
+++ b/packages/twenty-server/test/integration/graphql/suites/workflow/core-workflow-read.integration-spec.ts
@@ -16,6 +16,19 @@ const CORE_WORKFLOW_QUERY = `
}
`;
+const CORE_WORKFLOW_BY_ID_QUERY = `
+ query CoreWorkflowById($coreWorkflowId: UUID!) {
+ coreWorkflowById(coreWorkflowId: $coreWorkflowId) {
+ id
+ name
+ statuses
+ lastPublishedVersionId
+ workspaceWorkflowId
+ updatedAt
+ }
+ }
+`;
+
const CORE_WORKFLOW_VERSIONS_QUERY = `
query CoreWorkflowVersions($workspaceWorkflowId: UUID!) {
coreWorkflowVersions(workspaceWorkflowId: $workspaceWorkflowId) {
@@ -128,6 +141,41 @@ describe('coreWorkflow (e2e)', () => {
expect(response.body.data.coreWorkflow).toBeNull();
});
+ it('should read one workflow by its core id', async () => {
+ const coreWorkflow = await pollWorkflowGraphqlRequest<
+ { coreWorkflow: CoreWorkflowResult | null },
+ CoreWorkflowResult | null | undefined
+ >({
+ query: CORE_WORKFLOW_QUERY,
+ variables: { workspaceWorkflowId },
+ extract: (data) => data?.coreWorkflow,
+ until: isDefined,
+ });
+
+ const response = await workflowGraphqlRequest(CORE_WORKFLOW_BY_ID_QUERY, {
+ coreWorkflowId: coreWorkflow?.id,
+ });
+
+ expect(response.body.errors).toBeUndefined();
+ expect(response.body.data.coreWorkflowById).toEqual({
+ id: coreWorkflow?.id,
+ name: 'Core Workflow Read',
+ statuses: ['DRAFT'],
+ lastPublishedVersionId: null,
+ workspaceWorkflowId,
+ updatedAt: expect.any(String),
+ });
+ });
+
+ it('should return null for a core id that does not exist', async () => {
+ const response = await workflowGraphqlRequest(CORE_WORKFLOW_BY_ID_QUERY, {
+ coreWorkflowId: '00000000-0000-4000-8000-000000000000',
+ });
+
+ expect(response.body.errors).toBeUndefined();
+ expect(response.body.data.coreWorkflowById).toBeNull();
+ });
+
it('should expose the version content the show page renders', async () => {
const versions = await pollWorkflowGraphqlRequest<
{ coreWorkflowVersions: CoreWorkflowVersionResult[] },