Skip to content

The open alternative to Salesforce, designed for AI.

Delete a core workflow's definition with it (#27359)

Thomas Trompettec993288bfdf8
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 100f263a981..78bcd09ea46 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
@@ -975,12 +975,5 @@ export class CoreWorkflowMutationWorkspaceService {
await this.workflowCoreSyncService.deleteFromCore(workspaceId, [
coreWorkflowId,
]);
-
- if (isDefined(workspaceWorkflowId)) {
- await this.workflowVersionCoreSyncService.deleteCoreVersionsByWorkflowIds(
- workspaceId,
- [workspaceWorkflowId],
- );
- }
}
}
diff --git a/packages/twenty-server/src/engine/core-modules/workflow/services/workflow-core-sync.service.ts b/packages/twenty-server/src/engine/core-modules/workflow/services/workflow-core-sync.service.ts
index 2e729cd3380..6ed62733e21 100644
--- a/packages/twenty-server/src/engine/core-modules/workflow/services/workflow-core-sync.service.ts
+++ b/packages/twenty-server/src/engine/core-modules/workflow/services/workflow-core-sync.service.ts
@@ -10,6 +10,8 @@ import { v4 as uuidv4 } from 'uuid';
import { WorkflowEntity } from 'src/engine/core-modules/workflow/entities/workflow.entity';
import { ApplicationService } from 'src/engine/core-modules/application/application.service';
+import { CacheLockService } from 'src/engine/core-modules/cache-lock/cache-lock.service';
+import { WorkflowVersionCoreSyncService } from 'src/engine/core-modules/workflow/services/workflow-version-core-sync.service';
import {
CoreWorkflowMetadataException,
CoreWorkflowMetadataExceptionCode,
@@ -30,6 +32,9 @@ import { WorkspaceCacheService } from 'src/engine/workspace-cache/services/works
import { type WorkflowVersionWorkspaceEntity } from 'src/modules/workflow/common/standard-objects/workflow-version.workspace-entity';
import { type WorkflowWorkspaceEntity } from 'src/modules/workflow/common/standard-objects/workflow.workspace-entity';
+const CORE_WORKFLOW_DELETION_LOCK_TTL_MS = 30_000;
+const CORE_WORKFLOW_DELETION_LOCK_RETRY_INTERVAL_MS = 100;
+
@Injectable()
export class WorkflowCoreSyncService {
private readonly logger = new Logger(WorkflowCoreSyncService.name);
@@ -44,6 +49,8 @@ export class WorkflowCoreSyncService {
private readonly workspaceMigrationValidateBuildAndRunService: WorkspaceMigrationValidateBuildAndRunService,
private readonly applicationService: ApplicationService,
private readonly flatEntityMapsCacheService: WorkspaceManyOrAllFlatEntityMapsCacheService,
+ private readonly cacheLockService: CacheLockService,
+ private readonly workflowVersionCoreSyncService: WorkflowVersionCoreSyncService,
) {}
private async runCoreWorkflowMigration({
@@ -490,43 +497,61 @@ export class WorkflowCoreSyncService {
return;
}
+ await this.cacheLockService.withLock(
+ () => this.deleteFromCoreUnderLock(workspaceId, coreWorkflowIds),
+ `core-workflow-deletion:${workspaceId}`,
+ {
+ ttl: CORE_WORKFLOW_DELETION_LOCK_TTL_MS,
+ maxRetries:
+ CORE_WORKFLOW_DELETION_LOCK_TTL_MS /
+ CORE_WORKFLOW_DELETION_LOCK_RETRY_INTERVAL_MS,
+ ms: CORE_WORKFLOW_DELETION_LOCK_RETRY_INTERVAL_MS,
+ },
+ );
+ }
+
+ private async deleteFromCoreUnderLock(
+ workspaceId: string,
+ coreWorkflowIds: string[],
+ ): Promise<void> {
+ const persistedCoreWorkflowIds = (
+ await this.coreWorkflowRepository.find(workspaceId, {
+ where: { id: In(coreWorkflowIds) },
+ select: { id: true },
+ })
+ ).map(({ id }) => id);
+
+ if (persistedCoreWorkflowIds.length === 0) {
+ return;
+ }
+
const { flatWorkflowMaps } =
await this.flatEntityMapsCacheService.getOrRecomputeManyOrAllFlatEntityMaps(
{ workspaceId, flatMapsKeys: ['flatWorkflowMaps'] },
);
- const resolvedFlatWorkflows = coreWorkflowIds.map((coreWorkflowId) =>
- findFlatEntityByIdInFlatEntityMaps({
- flatEntityId: coreWorkflowId,
- flatEntityMaps: flatWorkflowMaps,
- }),
+ const resolvedFlatWorkflows = persistedCoreWorkflowIds.map(
+ (coreWorkflowId) =>
+ findFlatEntityByIdInFlatEntityMaps({
+ flatEntityId: coreWorkflowId,
+ flatEntityMaps: flatWorkflowMaps,
+ }),
);
- const missingCoreWorkflowIds = coreWorkflowIds.filter(
+ const unresolvedCoreWorkflowIds = persistedCoreWorkflowIds.filter(
(_, index) => !isDefined(resolvedFlatWorkflows[index]),
);
- // gone from the table means the dual-write listener already deleted it; still there means a stale cache, so fail rather than orphan it
- if (missingCoreWorkflowIds.length > 0) {
- const stillPersisted = await this.coreWorkflowRepository.find(
- workspaceId,
- { where: { id: In(missingCoreWorkflowIds) }, select: { id: true } },
+ // still persisted but missing from the maps means a stale cache, so fail rather than orphan it
+ if (unresolvedCoreWorkflowIds.length > 0) {
+ throw new CoreWorkflowMetadataException(
+ `Core workflows ${unresolvedCoreWorkflowIds.join(', ')} are persisted but missing from the flat entity maps`,
+ CoreWorkflowMetadataExceptionCode.WORKFLOW_NOT_FOUND,
);
-
- if (stillPersisted.length > 0) {
- throw new CoreWorkflowMetadataException(
- `Core workflows ${stillPersisted.map(({ id }) => id).join(', ')} are persisted but missing from the flat entity maps`,
- CoreWorkflowMetadataExceptionCode.WORKFLOW_NOT_FOUND,
- );
- }
}
const flatWorkflowsToDelete = resolvedFlatWorkflows.filter(isDefined);
- if (flatWorkflowsToDelete.length === 0) {
- return;
- }
-
await this.runCoreWorkflowMigration({
workspaceId,
failureMessage:
@@ -539,6 +564,10 @@ export class WorkflowCoreSyncService {
},
},
});
+
+ await this.workflowVersionCoreSyncService.invalidateAutomatedTriggerMaps(
+ workspaceId,
+ );
}
async findCoreWorkflowById(
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 ccc113542f3..4b928baf81c 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
@@ -841,31 +841,6 @@ export class WorkflowVersionCoreSyncService {
await this.invalidateAutomatedTriggerMaps(workspaceId);
}
- async deleteCoreVersionsByWorkflowIds(
- workspaceId: string,
- workflowIds: string[],
- ): Promise<void> {
- if (workflowIds.length === 0) {
- return;
- }
-
- const deletedVersions = await this.coreWorkflowVersionRepository.find(
- workspaceId,
- {
- where: { workflowId: In(workflowIds) },
- select: { id: true, coreWorkflowId: true, status: true },
- },
- );
-
- await this.deleteCoreVersionsThroughMigration({
- workspaceId,
- coreWorkflowVersionIds: deletedVersions.map(({ id }) => id),
- });
-
- await this.invalidateAutomatedTriggerMaps(workspaceId);
- await this.evictCronTriggerCacheEntries(deletedVersions);
- }
-
async deleteCoreVersionsByWorkspaceVersionIds(
workspaceId: string,
workflowVersionIds: string[],
diff --git a/packages/twenty-server/src/engine/core-modules/workflow/workflow-core.module.ts b/packages/twenty-server/src/engine/core-modules/workflow/workflow-core.module.ts
index 47625ca30ff..3c9a4ccdca4 100644
--- a/packages/twenty-server/src/engine/core-modules/workflow/workflow-core.module.ts
+++ b/packages/twenty-server/src/engine/core-modules/workflow/workflow-core.module.ts
@@ -1,6 +1,7 @@
import { Module } from '@nestjs/common';
import { ApplicationModule } from 'src/engine/core-modules/application/application.module';
+import { CacheLockModule } from 'src/engine/core-modules/cache-lock/cache-lock.module';
import { WorkspaceManyOrAllFlatEntityMapsCacheModule } from 'src/engine/metadata-modules/flat-entity/services/workspace-many-or-all-flat-entity-maps-cache.module';
import { WorkspaceMigrationModule } from 'src/engine/workspace-manager/workspace-migration/workspace-migration.module';
import { TypeOrmModule } from '@nestjs/typeorm';
@@ -8,6 +9,7 @@ import { TypeOrmModule } from '@nestjs/typeorm';
import { WorkflowEntity } from 'src/engine/core-modules/workflow/entities/workflow.entity';
import { FlatWorkflowModule } from 'src/engine/metadata-modules/flat-workflow/flat-workflow.module';
import { WorkflowCoreSyncService } from 'src/engine/core-modules/workflow/services/workflow-core-sync.service';
+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 { WorkspaceCacheModule } from 'src/engine/workspace-cache/workspace-cache.module';
@@ -15,11 +17,13 @@ import { WorkspaceCacheModule } from 'src/engine/workspace-cache/workspace-cache
@Module({
imports: [
ApplicationModule,
+ CacheLockModule,
WorkspaceMigrationModule,
WorkspaceManyOrAllFlatEntityMapsCacheModule,
TypeOrmModule.forFeature([WorkflowEntity, WorkspaceEntity]),
WorkspaceCacheModule,
FlatWorkflowModule,
+ WorkflowVersionCoreModule,
],
providers: [
WorkflowCoreSyncService,
diff --git a/packages/twenty-server/src/engine/metadata-modules/flat-entity/constant/all-metadata-side-effect-companion-metadata-names.constant.ts b/packages/twenty-server/src/engine/metadata-modules/flat-entity/constant/all-metadata-side-effect-companion-metadata-names.constant.ts
index aa3dde0a3d4..6ba2fa1e4a1 100644
--- a/packages/twenty-server/src/engine/metadata-modules/flat-entity/constant/all-metadata-side-effect-companion-metadata-names.constant.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/flat-entity/constant/all-metadata-side-effect-companion-metadata-names.constant.ts
@@ -1,7 +1,8 @@
import { type AllMetadataName } from 'twenty-shared/metadata';
export const ALL_METADATA_SIDE_EFFECT_COMPANION_METADATA_NAMES = {
- workflow: ['workflowVersion'],
+ workflow: ['workflowVersion', 'commandMenuItem', 'logicFunction'],
+ workflowVersion: ['workflow', 'commandMenuItem', 'logicFunction'],
fieldMetadata: [
'index',
'searchFieldMetadata',
diff --git a/packages/twenty-server/src/engine/metadata-modules/metadata-side-effect/handlers/metadata-side-effect-handlers.module.ts b/packages/twenty-server/src/engine/metadata-modules/metadata-side-effect/handlers/metadata-side-effect-handlers.module.ts
index 1f84b3d9a3a..1f4d59f4e9d 100644
--- a/packages/twenty-server/src/engine/metadata-modules/metadata-side-effect/handlers/metadata-side-effect-handlers.module.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/metadata-side-effect/handlers/metadata-side-effect-handlers.module.ts
@@ -1,6 +1,7 @@
import { WorkflowVersionOnUpdateSideEffectHandlerService } from 'src/engine/metadata-modules/metadata-side-effect/handlers/workflow/services/workflow-version-on-update-side-effect-handler.service';
import { WorkflowVersionOnCreateSideEffectHandlerService } from 'src/engine/metadata-modules/metadata-side-effect/handlers/workflow/services/workflow-version-on-create-side-effect-handler.service';
import { WorkflowVersionOnDeleteSideEffectHandlerService } from 'src/engine/metadata-modules/metadata-side-effect/handlers/workflow/services/workflow-version-on-delete-side-effect-handler.service';
+import { WorkflowVersionDependenciesOnDeleteSideEffectHandlerService } from 'src/engine/metadata-modules/metadata-side-effect/handlers/workflow-version/services/workflow-version-dependencies-on-delete-side-effect-handler.service';
import { Module } from '@nestjs/common';
import { FieldSearchFieldMetadataOnCreateSideEffectHandlerService } from 'src/engine/metadata-modules/metadata-side-effect/handlers/field-metadata/services/field-search-field-metadata-on-create-side-effect-handler.service';
@@ -37,6 +38,7 @@ import { ObjectValidationRulesOnDeleteSideEffectHandlerService } from 'src/engin
WorkflowVersionOnUpdateSideEffectHandlerService,
WorkflowVersionOnCreateSideEffectHandlerService,
WorkflowVersionOnDeleteSideEffectHandlerService,
+ WorkflowVersionDependenciesOnDeleteSideEffectHandlerService,
FieldUniqueBackingIndexOnCreateSideEffectHandlerService,
FieldUniqueBackingIndexOnUpdateSideEffectHandlerService,
FieldUniqueBackingIndexOnDeleteSideEffectHandlerService,
diff --git a/packages/twenty-server/src/engine/metadata-modules/metadata-side-effect/handlers/workflow-version/services/workflow-version-dependencies-on-delete-side-effect-handler.service.ts b/packages/twenty-server/src/engine/metadata-modules/metadata-side-effect/handlers/workflow-version/services/workflow-version-dependencies-on-delete-side-effect-handler.service.ts
new file mode 100644
index 00000000000..dd82440b512
--- /dev/null
+++ b/packages/twenty-server/src/engine/metadata-modules/metadata-side-effect/handlers/workflow-version/services/workflow-version-dependencies-on-delete-side-effect-handler.service.ts
@@ -0,0 +1,25 @@
+import { Injectable } from '@nestjs/common';
+
+import { buildWorkflowVersionDependenciesDeleteSideEffects } from 'src/engine/metadata-modules/metadata-side-effect/handlers/workflow-version/utils/build-workflow-version-dependencies-delete-side-effects.util';
+import {
+ type BuildSideEffectsArgs,
+ MetadataSideEffectHandler,
+} from 'src/engine/metadata-modules/metadata-side-effect/interfaces/base-metadata-side-effect-handler.service';
+import { type MetadataSideEffectResult } from 'src/engine/metadata-modules/metadata-side-effect/types/metadata-side-effect-result.type';
+
+@Injectable()
+export class WorkflowVersionDependenciesOnDeleteSideEffectHandlerService extends MetadataSideEffectHandler(
+ {
+ operation: 'delete',
+ metadataName: 'workflowVersion',
+ name: 'workflowVersionDependenciesOnDelete',
+ description:
+ 'Delete the command menu items of a deleted workflow version and the CODE step logic functions only it uses, unless its workflow is deleted too.',
+ },
+) {
+ buildSideEffects(
+ args: BuildSideEffectsArgs<'workflowVersion'>,
+ ): MetadataSideEffectResult {
+ return buildWorkflowVersionDependenciesDeleteSideEffects(args);
+ }
+}
diff --git a/packages/twenty-server/src/engine/metadata-modules/metadata-side-effect/handlers/workflow-version/utils/__tests__/build-workflow-version-dependencies-delete-side-effects.util.spec.ts b/packages/twenty-server/src/engine/metadata-modules/metadata-side-effect/handlers/workflow-version/utils/__tests__/build-workflow-version-dependencies-delete-side-effects.util.spec.ts
new file mode 100644
index 00000000000..5fea282925a
--- /dev/null
+++ b/packages/twenty-server/src/engine/metadata-modules/metadata-side-effect/handlers/workflow-version/utils/__tests__/build-workflow-version-dependencies-delete-side-effects.util.spec.ts
@@ -0,0 +1,194 @@
+import { WorkflowActionType } from 'twenty-shared/workflow';
+
+import { createEmptyAllFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/constant/create-empty-all-flat-entity-maps.constant';
+import { type AllFlatEntityOperationRecordByMetadataName } from 'src/engine/metadata-modules/flat-entity/types/all-flat-entity-operation-record-by-metadata-name.type';
+import { type FlatCommandMenuItem } from 'src/engine/metadata-modules/flat-command-menu-item/types/flat-command-menu-item.type';
+import { type FlatWorkflow } from 'src/engine/metadata-modules/flat-workflow/types/flat-workflow.type';
+import { type FlatWorkflowVersion } from 'src/engine/metadata-modules/flat-workflow-version/types/flat-workflow-version.type';
+import { type FlatLogicFunction } from 'src/engine/metadata-modules/logic-function/types/flat-logic-function.type';
+import { buildWorkflowVersionDependenciesDeleteSideEffects } from 'src/engine/metadata-modules/metadata-side-effect/handlers/workflow-version/utils/build-workflow-version-dependencies-delete-side-effects.util';
+import { type UniversalFlatWorkflow } from 'src/engine/workspace-manager/workspace-migration/universal-flat-entity/types/universal-flat-workflow.type';
+import { type UniversalFlatWorkflowVersion } from 'src/engine/workspace-manager/workspace-migration/universal-flat-entity/types/universal-flat-workflow-version.type';
+
+const DRAFT_FUNCTION_ID = '11111111-1111-4111-8111-111111111111';
+const ACTIVE_FUNCTION_ID = '22222222-2222-4222-8222-222222222222';
+const SIBLING_FUNCTION_ID = '33333333-3333-4333-8333-333333333333';
+const APPLICATION_FUNCTION_ID = '44444444-4444-4444-8444-444444444444';
+
+const step = (
+ type: WorkflowActionType.CODE | WorkflowActionType.LOGIC_FUNCTION,
+ logicFunctionId: string,
+) => ({
+ id: `step-${type}-${logicFunctionId}`,
+ name: 'Step',
+ type,
+ valid: true,
+ nextStepIds: [],
+ settings: { input: { logicFunctionId } },
+});
+
+const buildMaps = () => {
+ const maps = createEmptyAllFlatEntityMaps();
+
+ maps.flatWorkflowMaps.byUniversalIdentifier['workflow'] = {
+ id: 'workflow-id',
+ universalIdentifier: 'workflow',
+ } as FlatWorkflow;
+
+ const versions = [
+ {
+ id: 'draft-version-id',
+ universalIdentifier: 'draft-version',
+ coreWorkflowId: 'workflow-id',
+ workspaceWorkflowVersionId: 'mirror-draft-version-id',
+ steps: [
+ step(WorkflowActionType.CODE, DRAFT_FUNCTION_ID),
+ step(WorkflowActionType.CODE, ACTIVE_FUNCTION_ID),
+ step(WorkflowActionType.CODE, SIBLING_FUNCTION_ID),
+ step(WorkflowActionType.LOGIC_FUNCTION, APPLICATION_FUNCTION_ID),
+ ],
+ },
+ {
+ id: 'active-version-id',
+ universalIdentifier: 'active-version',
+ coreWorkflowId: 'workflow-id',
+ workspaceWorkflowVersionId: null,
+ steps: [step(WorkflowActionType.CODE, ACTIVE_FUNCTION_ID)],
+ },
+ {
+ id: 'sibling-version-id',
+ universalIdentifier: 'sibling-version',
+ coreWorkflowId: 'workflow-id',
+ workspaceWorkflowVersionId: null,
+ steps: [step(WorkflowActionType.CODE, SIBLING_FUNCTION_ID)],
+ },
+ ];
+
+ for (const version of versions) {
+ maps.flatWorkflowVersionMaps.byUniversalIdentifier[
+ version.universalIdentifier
+ ] = version as unknown as FlatWorkflowVersion;
+ }
+
+ const commandMenuItems = [
+ {
+ universalIdentifier: 'draft-item',
+ coreWorkflowVersionId: 'draft-version-id',
+ workflowVersionId: null,
+ },
+ {
+ universalIdentifier: 'mirror-draft-item',
+ coreWorkflowVersionId: null,
+ workflowVersionId: 'mirror-draft-version-id',
+ },
+ {
+ universalIdentifier: 'active-item',
+ coreWorkflowVersionId: 'active-version-id',
+ workflowVersionId: null,
+ },
+ ];
+
+ for (const commandMenuItem of commandMenuItems) {
+ maps.flatCommandMenuItemMaps.byUniversalIdentifier[
+ commandMenuItem.universalIdentifier
+ ] = commandMenuItem as FlatCommandMenuItem;
+ }
+
+ for (const logicFunctionId of [
+ DRAFT_FUNCTION_ID,
+ ACTIVE_FUNCTION_ID,
+ SIBLING_FUNCTION_ID,
+ APPLICATION_FUNCTION_ID,
+ ]) {
+ maps.flatLogicFunctionMaps.byUniversalIdentifier[logicFunctionId] = {
+ id: logicFunctionId,
+ universalIdentifier: logicFunctionId,
+ } as FlatLogicFunction;
+ }
+
+ return maps;
+};
+
+const deleteDraftVersion = (
+ allFlatEntityOperationRecordByMetadataName: AllFlatEntityOperationRecordByMetadataName,
+) =>
+ buildWorkflowVersionDependenciesDeleteSideEffects({
+ flatEntity: {
+ universalIdentifier: 'draft-version',
+ } as UniversalFlatWorkflowVersion,
+ allFlatEntityOperationRecordByMetadataName,
+ relatedFlatEntityMaps: buildMaps(),
+ context: {
+ buildOptions: {
+ isSystemBuild: false,
+ applicationUniversalIdentifier: 'application',
+ },
+ },
+ });
+
+const getDeletedUniversalIdentifiers = (
+ result: ReturnType<typeof deleteDraftVersion>,
+) => {
+ if (result.status !== 'success') {
+ throw new Error(`Expected success, got ${result.status}`);
+ }
+
+ return {
+ commandMenuItem: Object.keys(
+ result.operations.commandMenuItem?.flatEntityToDelete ?? {},
+ ),
+ logicFunction: Object.keys(
+ result.operations.logicFunction?.flatEntityToDelete ?? {},
+ ),
+ };
+};
+
+describe('buildWorkflowVersionDependenciesDeleteSideEffects', () => {
+ it('deletes the command menu items of a deleted version and the CODE functions no surviving version uses', () => {
+ expect(
+ getDeletedUniversalIdentifiers(
+ deleteDraftVersion({
+ workflowVersion: {
+ flatEntityToCreate: {},
+ flatEntityToUpdate: {},
+ flatEntityToDelete: {
+ 'draft-version': {} as UniversalFlatWorkflowVersion,
+ },
+ },
+ }),
+ ),
+ ).toEqual({
+ commandMenuItem: ['draft-item', 'mirror-draft-item'],
+ logicFunction: [DRAFT_FUNCTION_ID],
+ });
+ });
+
+ it('deletes CODE functions shared with versions deleted in the same migration', () => {
+ expect(
+ getDeletedUniversalIdentifiers(
+ deleteDraftVersion({
+ workflowVersion: {
+ flatEntityToCreate: {},
+ flatEntityToUpdate: {},
+ flatEntityToDelete: {
+ 'draft-version': {} as UniversalFlatWorkflowVersion,
+ 'sibling-version': {} as UniversalFlatWorkflowVersion,
+ },
+ },
+ }),
+ ).logicFunction,
+ ).toEqual([DRAFT_FUNCTION_ID, SIBLING_FUNCTION_ID]);
+ });
+
+ it('leaves the cleanup to the workflow when the workflow is deleted in the same migration', () => {
+ expect(
+ deleteDraftVersion({
+ workflow: {
+ flatEntityToCreate: {},
+ flatEntityToUpdate: {},
+ flatEntityToDelete: { workflow: {} as UniversalFlatWorkflow },
+ },
+ }),
+ ).toEqual({ status: 'noop' });
+ });
+});
diff --git a/packages/twenty-server/src/engine/metadata-modules/metadata-side-effect/handlers/workflow-version/utils/build-workflow-version-dependencies-delete-operations.util.ts b/packages/twenty-server/src/engine/metadata-modules/metadata-side-effect/handlers/workflow-version/utils/build-workflow-version-dependencies-delete-operations.util.ts
new file mode 100644
index 00000000000..663c09b9ee1
--- /dev/null
+++ b/packages/twenty-server/src/engine/metadata-modules/metadata-side-effect/handlers/workflow-version/utils/build-workflow-version-dependencies-delete-operations.util.ts
@@ -0,0 +1,104 @@
+import { fromArrayToUniqueKeyRecord, isDefined } from 'twenty-shared/utils';
+
+import { type AllFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/all-flat-entity-maps.type';
+import { type AllFlatEntityOperationRecordByMetadataName } from 'src/engine/metadata-modules/flat-entity/types/all-flat-entity-operation-record-by-metadata-name.type';
+import { type FlatWorkflowVersion } from 'src/engine/metadata-modules/flat-workflow-version/types/flat-workflow-version.type';
+import { getWorkflowIdsDeletedInMigration } from 'src/engine/metadata-modules/metadata-side-effect/handlers/workflow-version/utils/get-workflow-ids-deleted-in-migration.util';
+import { getExclusivelyOwnedCodeStepLogicFunctionIds } from 'src/engine/metadata-modules/metadata-side-effect/handlers/workflow/utils/get-exclusively-owned-code-step-logic-function-ids.util';
+import { type MetadataSideEffectOperationsByMetadataName } from 'src/engine/metadata-modules/metadata-side-effect/types/metadata-side-effect-operations-by-metadata-name.type';
+
+export const buildWorkflowVersionDependenciesDeleteOperations = ({
+ deletedWorkflowVersions,
+ allFlatEntityOperationRecordByMetadataName,
+ flatWorkflowMaps,
+ flatWorkflowVersionMaps,
+ flatCommandMenuItemMaps,
+ flatLogicFunctionMaps,
+}: {
+ deletedWorkflowVersions: FlatWorkflowVersion[];
+ allFlatEntityOperationRecordByMetadataName: AllFlatEntityOperationRecordByMetadataName;
+} & Pick<
+ AllFlatEntityMaps,
+ | 'flatWorkflowMaps'
+ | 'flatWorkflowVersionMaps'
+ | 'flatCommandMenuItemMaps'
+ | 'flatLogicFunctionMaps'
+>): Pick<
+ MetadataSideEffectOperationsByMetadataName,
+ 'commandMenuItem' | 'logicFunction'
+> => {
+ const deletedCoreVersionIds = new Set(
+ deletedWorkflowVersions.map(({ id }) => id),
+ );
+ const deletedWorkspaceVersionIds = new Set(
+ deletedWorkflowVersions
+ .map(({ workspaceWorkflowVersionId }) => workspaceWorkflowVersionId)
+ .filter(isDefined),
+ );
+
+ const deletedCommandMenuItems = Object.values(
+ flatCommandMenuItemMaps.byUniversalIdentifier,
+ )
+ .filter(isDefined)
+ .filter(
+ ({ coreWorkflowVersionId, workflowVersionId }) =>
+ (isDefined(coreWorkflowVersionId) &&
+ deletedCoreVersionIds.has(coreWorkflowVersionId)) ||
+ (isDefined(workflowVersionId) &&
+ deletedWorkspaceVersionIds.has(workflowVersionId)),
+ );
+
+ const workflowVersionUniversalIdentifiersDeletedInMigration = new Set(
+ Object.keys(
+ allFlatEntityOperationRecordByMetadataName.workflowVersion
+ ?.flatEntityToDelete ?? {},
+ ),
+ );
+ const workflowIdsDeletedInMigration = getWorkflowIdsDeletedInMigration({
+ allFlatEntityOperationRecordByMetadataName,
+ flatWorkflowMaps,
+ });
+
+ const remainingWorkflowVersions = Object.values(
+ flatWorkflowVersionMaps.byUniversalIdentifier,
+ )
+ .filter(isDefined)
+ .filter(
+ ({ id, universalIdentifier, coreWorkflowId }) =>
+ !deletedCoreVersionIds.has(id) &&
+ !workflowVersionUniversalIdentifiersDeletedInMigration.has(
+ universalIdentifier,
+ ) &&
+ !(
+ isDefined(coreWorkflowId) &&
+ workflowIdsDeletedInMigration.has(coreWorkflowId)
+ ),
+ );
+
+ const deletedLogicFunctionIds = new Set(
+ getExclusivelyOwnedCodeStepLogicFunctionIds({
+ deletedWorkflowVersions,
+ remainingWorkflowVersions,
+ }),
+ );
+ const deletedLogicFunctions = Object.values(
+ flatLogicFunctionMaps.byUniversalIdentifier,
+ )
+ .filter(isDefined)
+ .filter(({ id }) => deletedLogicFunctionIds.has(id));
+
+ return {
+ commandMenuItem: {
+ flatEntityToDelete: fromArrayToUniqueKeyRecord({
+ array: deletedCommandMenuItems,
+ uniqueKey: 'universalIdentifier',
+ }),
+ },
+ logicFunction: {
+ flatEntityToDelete: fromArrayToUniqueKeyRecord({
+ array: deletedLogicFunctions,
+ uniqueKey: 'universalIdentifier',
+ }),
+ },
+ };
+};
diff --git a/packages/twenty-server/src/engine/metadata-modules/metadata-side-effect/handlers/workflow-version/utils/build-workflow-version-dependencies-delete-side-effects.util.ts b/packages/twenty-server/src/engine/metadata-modules/metadata-side-effect/handlers/workflow-version/utils/build-workflow-version-dependencies-delete-side-effects.util.ts
new file mode 100644
index 00000000000..d32146bf085
--- /dev/null
+++ b/packages/twenty-server/src/engine/metadata-modules/metadata-side-effect/handlers/workflow-version/utils/build-workflow-version-dependencies-delete-side-effects.util.ts
@@ -0,0 +1,45 @@
+import { isDefined } from 'twenty-shared/utils';
+
+import { buildWorkflowVersionDependenciesDeleteOperations } from 'src/engine/metadata-modules/metadata-side-effect/handlers/workflow-version/utils/build-workflow-version-dependencies-delete-operations.util';
+import { getWorkflowIdsDeletedInMigration } from 'src/engine/metadata-modules/metadata-side-effect/handlers/workflow-version/utils/get-workflow-ids-deleted-in-migration.util';
+import { type BuildSideEffectsArgs } from 'src/engine/metadata-modules/metadata-side-effect/interfaces/base-metadata-side-effect-handler.service';
+import { type MetadataSideEffectResult } from 'src/engine/metadata-modules/metadata-side-effect/types/metadata-side-effect-result.type';
+
+export const buildWorkflowVersionDependenciesDeleteSideEffects = ({
+ flatEntity,
+ allFlatEntityOperationRecordByMetadataName,
+ relatedFlatEntityMaps: {
+ flatWorkflowMaps,
+ flatWorkflowVersionMaps,
+ flatCommandMenuItemMaps,
+ flatLogicFunctionMaps,
+ },
+}: BuildSideEffectsArgs<'workflowVersion'>): MetadataSideEffectResult => {
+ const deletedWorkflowVersion =
+ flatWorkflowVersionMaps.byUniversalIdentifier[
+ flatEntity.universalIdentifier
+ ];
+
+ if (
+ !isDefined(deletedWorkflowVersion) ||
+ (isDefined(deletedWorkflowVersion.coreWorkflowId) &&
+ getWorkflowIdsDeletedInMigration({
+ allFlatEntityOperationRecordByMetadataName,
+ flatWorkflowMaps,
+ }).has(deletedWorkflowVersion.coreWorkflowId))
+ ) {
+ return { status: 'noop' };
+ }
+
+ return {
+ status: 'success',
+ operations: buildWorkflowVersionDependenciesDeleteOperations({
+ deletedWorkflowVersions: [deletedWorkflowVersion],
+ allFlatEntityOperationRecordByMetadataName,
+ flatWorkflowMaps,
+ flatWorkflowVersionMaps,
+ flatCommandMenuItemMaps,
+ flatLogicFunctionMaps,
+ }),
+ };
+};
diff --git a/packages/twenty-server/src/engine/metadata-modules/metadata-side-effect/handlers/workflow-version/utils/get-workflow-ids-deleted-in-migration.util.ts b/packages/twenty-server/src/engine/metadata-modules/metadata-side-effect/handlers/workflow-version/utils/get-workflow-ids-deleted-in-migration.util.ts
new file mode 100644
index 00000000000..3a632ede36b
--- /dev/null
+++ b/packages/twenty-server/src/engine/metadata-modules/metadata-side-effect/handlers/workflow-version/utils/get-workflow-ids-deleted-in-migration.util.ts
@@ -0,0 +1,22 @@
+import { isDefined } from 'twenty-shared/utils';
+
+import { type AllFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/all-flat-entity-maps.type';
+import { type AllFlatEntityOperationRecordByMetadataName } from 'src/engine/metadata-modules/flat-entity/types/all-flat-entity-operation-record-by-metadata-name.type';
+
+export const getWorkflowIdsDeletedInMigration = ({
+ allFlatEntityOperationRecordByMetadataName,
+ flatWorkflowMaps,
+}: {
+ allFlatEntityOperationRecordByMetadataName: AllFlatEntityOperationRecordByMetadataName;
+} & Pick<AllFlatEntityMaps, 'flatWorkflowMaps'>): Set<string> =>
+ new Set(
+ Object.keys(
+ allFlatEntityOperationRecordByMetadataName.workflow?.flatEntityToDelete ??
+ {},
+ )
+ .map(
+ (universalIdentifier) =>
+ flatWorkflowMaps.byUniversalIdentifier[universalIdentifier]?.id,
+ )
+ .filter(isDefined),
+ );
diff --git a/packages/twenty-server/src/engine/metadata-modules/metadata-side-effect/handlers/workflow/services/workflow-version-on-delete-side-effect-handler.service.ts b/packages/twenty-server/src/engine/metadata-modules/metadata-side-effect/handlers/workflow/services/workflow-version-on-delete-side-effect-handler.service.ts
index a2abbd226ae..128f5149625 100644
--- a/packages/twenty-server/src/engine/metadata-modules/metadata-side-effect/handlers/workflow/services/workflow-version-on-delete-side-effect-handler.service.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/metadata-side-effect/handlers/workflow/services/workflow-version-on-delete-side-effect-handler.service.ts
@@ -14,7 +14,7 @@ export class WorkflowVersionOnDeleteSideEffectHandlerService extends MetadataSid
metadataName: 'workflow',
name: 'workflowVersionOnDelete',
description:
- 'Delete the managed version of an application workflow when the workflow is deleted.',
+ 'Delete the versions of a deleted workflow, with their command menu items and the CODE step logic functions only they use.',
},
) {
buildSideEffects(
diff --git a/packages/twenty-server/src/engine/metadata-modules/metadata-side-effect/handlers/workflow/utils/__tests__/build-workflow-version-delete-side-effects.util.spec.ts b/packages/twenty-server/src/engine/metadata-modules/metadata-side-effect/handlers/workflow/utils/__tests__/build-workflow-version-delete-side-effects.util.spec.ts
index 860f45a511e..3ea144713b9 100644
--- a/packages/twenty-server/src/engine/metadata-modules/metadata-side-effect/handlers/workflow/utils/__tests__/build-workflow-version-delete-side-effects.util.spec.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/metadata-side-effect/handlers/workflow/utils/__tests__/build-workflow-version-delete-side-effects.util.spec.ts
@@ -1,34 +1,37 @@
import { getWorkflowVersionUniversalIdentifier } from 'twenty-shared/application';
-import { isDefined } from 'twenty-shared/utils';
+import { WorkflowActionType } from 'twenty-shared/workflow';
import { buildWorkflowVersionDeleteSideEffects } from 'src/engine/metadata-modules/metadata-side-effect/handlers/workflow/utils/build-workflow-version-delete-side-effects.util';
import { createEmptyAllFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/constant/create-empty-all-flat-entity-maps.constant';
+import { type FlatCommandMenuItem } from 'src/engine/metadata-modules/flat-command-menu-item/types/flat-command-menu-item.type';
+import { type FlatLogicFunction } from 'src/engine/metadata-modules/logic-function/types/flat-logic-function.type';
+import { type FlatWorkflow } from 'src/engine/metadata-modules/flat-workflow/types/flat-workflow.type';
import { type FlatWorkflowVersion } from 'src/engine/metadata-modules/flat-workflow-version/types/flat-workflow-version.type';
import { type UniversalFlatWorkflow } from 'src/engine/workspace-manager/workspace-migration/universal-flat-entity/types/universal-flat-workflow.type';
const APPLICATION_ID = '11111111-1111-4111-8111-111111111111';
const WORKFLOW_ID = '22222222-2222-4222-8222-222222222222';
-const VERSION_ID = getWorkflowVersionUniversalIdentifier({
+const MANAGED_VERSION_ID = getWorkflowVersionUniversalIdentifier({
applicationUniversalIdentifier: APPLICATION_ID,
workflowUniversalIdentifier: WORKFLOW_ID,
});
+const OWNED_FUNCTION_ID = '33333333-3333-4333-8333-333333333333';
+const SHARED_FUNCTION_ID = '44444444-4444-4444-8444-444444444444';
+
const deletedWorkflow = {
universalIdentifier: WORKFLOW_ID,
applicationUniversalIdentifier: APPLICATION_ID,
} as UniversalFlatWorkflow;
-const buildDeleteSideEffects = (isSystemSideEffect: boolean | undefined) => {
+const buildDeleteSideEffects = (
+ fillMaps: (
+ relatedFlatEntityMaps: ReturnType<typeof createEmptyAllFlatEntityMaps>,
+ ) => void,
+) => {
const relatedFlatEntityMaps = createEmptyAllFlatEntityMaps();
- if (isDefined(isSystemSideEffect)) {
- relatedFlatEntityMaps.flatWorkflowVersionMaps.byUniversalIdentifier[
- VERSION_ID
- ] = {
- universalIdentifier: VERSION_ID,
- isSystemSideEffect,
- } as FlatWorkflowVersion;
- }
+ fillMaps(relatedFlatEntityMaps);
return buildWorkflowVersionDeleteSideEffects({
flatEntity: deletedWorkflow,
@@ -43,22 +46,137 @@ const buildDeleteSideEffects = (isSystemSideEffect: boolean | undefined) => {
});
};
+const codeStep = (logicFunctionId: string) => ({
+ id: `step-${logicFunctionId}`,
+ name: 'Code',
+ type: WorkflowActionType.CODE,
+ valid: true,
+ nextStepIds: [],
+ settings: { input: { logicFunctionId } },
+});
+
describe('buildWorkflowVersionDeleteSideEffects', () => {
it('deletes the managed version of a deleted application workflow', () => {
- expect(buildDeleteSideEffects(true)).toMatchObject({
+ expect(
+ buildDeleteSideEffects((maps) => {
+ maps.flatWorkflowVersionMaps.byUniversalIdentifier[MANAGED_VERSION_ID] =
+ {
+ universalIdentifier: MANAGED_VERSION_ID,
+ isSystemSideEffect: true,
+ } as FlatWorkflowVersion;
+ }),
+ ).toMatchObject({
status: 'success',
operations: {
workflowVersion: {
flatEntityToDelete: {
- [VERSION_ID]: { universalIdentifier: VERSION_ID },
+ [MANAGED_VERSION_ID]: { universalIdentifier: MANAGED_VERSION_ID },
},
},
},
});
});
- it('leaves workflows without a managed version alone', () => {
- expect(buildDeleteSideEffects(undefined)).toEqual({ status: 'noop' });
- expect(buildDeleteSideEffects(false)).toEqual({ status: 'noop' });
+ it('returns noop when no version is deletable', () => {
+ expect(buildDeleteSideEffects(() => undefined)).toEqual({
+ status: 'noop',
+ });
+ expect(
+ buildDeleteSideEffects((maps) => {
+ maps.flatWorkflowVersionMaps.byUniversalIdentifier[MANAGED_VERSION_ID] =
+ {
+ universalIdentifier: MANAGED_VERSION_ID,
+ isSystemSideEffect: false,
+ } as FlatWorkflowVersion;
+ }),
+ ).toEqual({ status: 'noop' });
+ });
+
+ it('deletes every version of the workflow with its command menu items and the CODE functions only it uses', () => {
+ const result = buildDeleteSideEffects((maps) => {
+ maps.flatWorkflowMaps.byUniversalIdentifier[WORKFLOW_ID] = {
+ id: 'core-workflow-id',
+ universalIdentifier: WORKFLOW_ID,
+ } as FlatWorkflow;
+
+ const versions = [
+ {
+ id: 'active-version-id',
+ universalIdentifier: 'active-version',
+ coreWorkflowId: 'core-workflow-id',
+ workspaceWorkflowVersionId: 'mirror-active-version-id',
+ steps: [codeStep(OWNED_FUNCTION_ID)],
+ },
+ {
+ id: 'draft-version-id',
+ universalIdentifier: 'draft-version',
+ coreWorkflowId: 'core-workflow-id',
+ workspaceWorkflowVersionId: null,
+ steps: [codeStep(SHARED_FUNCTION_ID)],
+ },
+ {
+ id: 'other-version-id',
+ universalIdentifier: 'other-version',
+ coreWorkflowId: 'other-core-workflow-id',
+ workspaceWorkflowVersionId: null,
+ steps: [codeStep(SHARED_FUNCTION_ID)],
+ },
+ ];
+
+ for (const version of versions) {
+ maps.flatWorkflowVersionMaps.byUniversalIdentifier[
+ version.universalIdentifier
+ ] = version as unknown as FlatWorkflowVersion;
+ }
+
+ const commandMenuItems = [
+ {
+ universalIdentifier: 'core-version-item',
+ coreWorkflowVersionId: 'active-version-id',
+ workflowVersionId: null,
+ },
+ {
+ universalIdentifier: 'mirror-version-item',
+ coreWorkflowVersionId: null,
+ workflowVersionId: 'mirror-active-version-id',
+ },
+ {
+ universalIdentifier: 'other-version-item',
+ coreWorkflowVersionId: 'other-version-id',
+ workflowVersionId: null,
+ },
+ ];
+
+ for (const commandMenuItem of commandMenuItems) {
+ maps.flatCommandMenuItemMaps.byUniversalIdentifier[
+ commandMenuItem.universalIdentifier
+ ] = commandMenuItem as FlatCommandMenuItem;
+ }
+
+ for (const logicFunctionId of [OWNED_FUNCTION_ID, SHARED_FUNCTION_ID]) {
+ maps.flatLogicFunctionMaps.byUniversalIdentifier[
+ `${logicFunctionId}-universal`
+ ] = {
+ id: logicFunctionId,
+ universalIdentifier: `${logicFunctionId}-universal`,
+ } as FlatLogicFunction;
+ }
+ });
+
+ expect(result.status).toBe('success');
+
+ if (result.status !== 'success') {
+ return;
+ }
+
+ expect(
+ Object.keys(result.operations.workflowVersion?.flatEntityToDelete ?? {}),
+ ).toEqual(['active-version', 'draft-version']);
+ expect(
+ Object.keys(result.operations.commandMenuItem?.flatEntityToDelete ?? {}),
+ ).toEqual(['core-version-item', 'mirror-version-item']);
+ expect(
+ Object.keys(result.operations.logicFunction?.flatEntityToDelete ?? {}),
+ ).toEqual([`${OWNED_FUNCTION_ID}-universal`]);
});
});
diff --git a/packages/twenty-server/src/engine/metadata-modules/metadata-side-effect/handlers/workflow/utils/__tests__/get-exclusively-owned-code-step-logic-function-ids.util.spec.ts b/packages/twenty-server/src/engine/metadata-modules/metadata-side-effect/handlers/workflow/utils/__tests__/get-exclusively-owned-code-step-logic-function-ids.util.spec.ts
new file mode 100644
index 00000000000..93d77fc4c89
--- /dev/null
+++ b/packages/twenty-server/src/engine/metadata-modules/metadata-side-effect/handlers/workflow/utils/__tests__/get-exclusively-owned-code-step-logic-function-ids.util.spec.ts
@@ -0,0 +1,86 @@
+import { WorkflowActionType } from 'twenty-shared/workflow';
+
+import { type WorkflowAction } from 'src/modules/workflow/workflow-executor/workflow-actions/types/workflow-action.type';
+import { getExclusivelyOwnedCodeStepLogicFunctionIds } from 'src/engine/metadata-modules/metadata-side-effect/handlers/workflow/utils/get-exclusively-owned-code-step-logic-function-ids.util';
+
+const DELETED_CODE_FUNCTION_ID = '11111111-1111-4111-8111-111111111111';
+const SHARED_CODE_FUNCTION_ID = '22222222-2222-4222-8222-222222222222';
+const APPLICATION_FUNCTION_ID = '33333333-3333-4333-8333-333333333333';
+const SHARED_BY_CODE_FUNCTION_ID = '44444444-4444-4444-8444-444444444444';
+
+const buildStep = (
+ type: WorkflowActionType.CODE | WorkflowActionType.LOGIC_FUNCTION,
+ logicFunctionId: string | undefined,
+) =>
+ ({
+ id: `${type}-${logicFunctionId}`,
+ name: type,
+ type,
+ valid: true,
+ nextStepIds: [],
+ settings: { input: { logicFunctionId } },
+ }) as unknown as WorkflowAction;
+
+describe('getExclusivelyOwnedCodeStepLogicFunctionIds', () => {
+ it('returns the CODE functions that no remaining version references', () => {
+ expect(
+ getExclusivelyOwnedCodeStepLogicFunctionIds({
+ deletedWorkflowVersions: [
+ {
+ steps: [
+ buildStep(WorkflowActionType.CODE, DELETED_CODE_FUNCTION_ID),
+ buildStep(WorkflowActionType.CODE, SHARED_CODE_FUNCTION_ID),
+ ],
+ },
+ {
+ steps: [
+ buildStep(WorkflowActionType.CODE, DELETED_CODE_FUNCTION_ID),
+ buildStep(WorkflowActionType.CODE, SHARED_BY_CODE_FUNCTION_ID),
+ ],
+ },
+ ],
+ remainingWorkflowVersions: [
+ {
+ steps: [
+ buildStep(
+ WorkflowActionType.LOGIC_FUNCTION,
+ SHARED_CODE_FUNCTION_ID,
+ ),
+ buildStep(WorkflowActionType.CODE, SHARED_BY_CODE_FUNCTION_ID),
+ ],
+ },
+ ],
+ }),
+ ).toEqual([DELETED_CODE_FUNCTION_ID]);
+ });
+
+ it('keeps functions referenced by LOGIC_FUNCTION steps of the deleted workflow', () => {
+ expect(
+ getExclusivelyOwnedCodeStepLogicFunctionIds({
+ deletedWorkflowVersions: [
+ {
+ steps: [
+ buildStep(
+ WorkflowActionType.LOGIC_FUNCTION,
+ APPLICATION_FUNCTION_ID,
+ ),
+ ],
+ },
+ ],
+ remainingWorkflowVersions: [],
+ }),
+ ).toEqual([]);
+ });
+
+ it('ignores steps without a valid function id and versions without steps', () => {
+ expect(
+ getExclusivelyOwnedCodeStepLogicFunctionIds({
+ deletedWorkflowVersions: [
+ { steps: null },
+ { steps: [buildStep(WorkflowActionType.CODE, undefined)] },
+ ],
+ remainingWorkflowVersions: [{ steps: null }],
+ }),
+ ).toEqual([]);
+ });
+});
diff --git a/packages/twenty-server/src/engine/metadata-modules/metadata-side-effect/handlers/workflow/utils/build-workflow-version-delete-side-effects.util.ts b/packages/twenty-server/src/engine/metadata-modules/metadata-side-effect/handlers/workflow/utils/build-workflow-version-delete-side-effects.util.ts
index de8241dae71..22236d8245f 100644
--- a/packages/twenty-server/src/engine/metadata-modules/metadata-side-effect/handlers/workflow/utils/build-workflow-version-delete-side-effects.util.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/metadata-side-effect/handlers/workflow/utils/build-workflow-version-delete-side-effects.util.ts
@@ -1,24 +1,43 @@
import { getWorkflowVersionUniversalIdentifier } from 'twenty-shared/application';
-import { isDefined } from 'twenty-shared/utils';
+import { fromArrayToUniqueKeyRecord, isDefined } from 'twenty-shared/utils';
+import { type FlatWorkflowVersion } from 'src/engine/metadata-modules/flat-workflow-version/types/flat-workflow-version.type';
+import { buildWorkflowVersionDependenciesDeleteOperations } from 'src/engine/metadata-modules/metadata-side-effect/handlers/workflow-version/utils/build-workflow-version-dependencies-delete-operations.util';
import { type BuildSideEffectsArgs } from 'src/engine/metadata-modules/metadata-side-effect/interfaces/base-metadata-side-effect-handler.service';
import { type MetadataSideEffectResult } from 'src/engine/metadata-modules/metadata-side-effect/types/metadata-side-effect-result.type';
export const buildWorkflowVersionDeleteSideEffects = ({
flatEntity,
- relatedFlatEntityMaps,
+ allFlatEntityOperationRecordByMetadataName,
+ relatedFlatEntityMaps: {
+ flatWorkflowMaps,
+ flatWorkflowVersionMaps,
+ flatCommandMenuItemMaps,
+ flatLogicFunctionMaps,
+ },
}: BuildSideEffectsArgs<'workflow'>): MetadataSideEffectResult => {
- const universalIdentifier = getWorkflowVersionUniversalIdentifier({
- applicationUniversalIdentifier: flatEntity.applicationUniversalIdentifier,
- workflowUniversalIdentifier: flatEntity.universalIdentifier,
- });
+ const managedVersionUniversalIdentifier =
+ getWorkflowVersionUniversalIdentifier({
+ applicationUniversalIdentifier: flatEntity.applicationUniversalIdentifier,
+ workflowUniversalIdentifier: flatEntity.universalIdentifier,
+ });
+ const workflowId =
+ flatWorkflowMaps.byUniversalIdentifier[flatEntity.universalIdentifier]?.id;
- const managedVersion =
- relatedFlatEntityMaps.flatWorkflowVersionMaps.byUniversalIdentifier[
- universalIdentifier
- ];
+ const workflowVersions = Object.values(
+ flatWorkflowVersionMaps.byUniversalIdentifier,
+ ).filter(isDefined);
+ const isDeletedWorkflowVersion = (workflowVersion: FlatWorkflowVersion) =>
+ (workflowVersion.universalIdentifier ===
+ managedVersionUniversalIdentifier &&
+ workflowVersion.isSystemSideEffect) ||
+ (isDefined(workflowId) && workflowVersion.coreWorkflowId === workflowId);
- if (!isDefined(managedVersion) || !managedVersion.isSystemSideEffect) {
+ const deletedWorkflowVersions = workflowVersions.filter(
+ isDeletedWorkflowVersion,
+ );
+
+ if (deletedWorkflowVersions.length === 0) {
return { status: 'noop' };
}
@@ -26,8 +45,19 @@ export const buildWorkflowVersionDeleteSideEffects = ({
status: 'success',
operations: {
workflowVersion: {
- flatEntityToDelete: { [universalIdentifier]: managedVersion },
+ flatEntityToDelete: fromArrayToUniqueKeyRecord({
+ array: deletedWorkflowVersions,
+ uniqueKey: 'universalIdentifier',
+ }),
},
+ ...buildWorkflowVersionDependenciesDeleteOperations({
+ deletedWorkflowVersions,
+ allFlatEntityOperationRecordByMetadataName,
+ flatWorkflowMaps,
+ flatWorkflowVersionMaps,
+ flatCommandMenuItemMaps,
+ flatLogicFunctionMaps,
+ }),
},
};
};
diff --git a/packages/twenty-server/src/engine/metadata-modules/metadata-side-effect/handlers/workflow/utils/get-exclusively-owned-code-step-logic-function-ids.util.ts b/packages/twenty-server/src/engine/metadata-modules/metadata-side-effect/handlers/workflow/utils/get-exclusively-owned-code-step-logic-function-ids.util.ts
new file mode 100644
index 00000000000..f41fc10ddae
--- /dev/null
+++ b/packages/twenty-server/src/engine/metadata-modules/metadata-side-effect/handlers/workflow/utils/get-exclusively-owned-code-step-logic-function-ids.util.ts
@@ -0,0 +1,51 @@
+import { isNonEmptyString } from '@sniptt/guards';
+import { isValidUuid } from 'twenty-shared/utils';
+
+import { type FlatWorkflowVersion } from 'src/engine/metadata-modules/flat-workflow-version/types/flat-workflow-version.type';
+import { isWorkflowCodeAction } from 'src/modules/workflow/workflow-executor/workflow-actions/code/guards/is-workflow-code-action.guard';
+import { isWorkflowLogicFunctionAction } from 'src/modules/workflow/workflow-executor/workflow-actions/logic-function/guards/is-workflow-logic-function-action.guard';
+
+type WorkflowVersionSteps = Pick<FlatWorkflowVersion, 'steps'>;
+
+const isLogicFunctionId = (
+ logicFunctionId: string | undefined,
+): logicFunctionId is string =>
+ isNonEmptyString(logicFunctionId) && isValidUuid(logicFunctionId);
+
+type StepWithLogicFunction = {
+ settings: { input: { logicFunctionId?: string } };
+};
+
+const getSteps = (workflowVersions: WorkflowVersionSteps[]) =>
+ workflowVersions.flatMap(({ steps }) => steps ?? []);
+
+const getLogicFunctionIds = (steps: StepWithLogicFunction[]): string[] =>
+ steps
+ .map((step) => step.settings.input.logicFunctionId)
+ .filter(isLogicFunctionId);
+
+export const getExclusivelyOwnedCodeStepLogicFunctionIds = ({
+ deletedWorkflowVersions,
+ remainingWorkflowVersions,
+}: {
+ deletedWorkflowVersions: WorkflowVersionSteps[];
+ remainingWorkflowVersions: WorkflowVersionSteps[];
+}): string[] => {
+ const remainingSteps = getSteps(remainingWorkflowVersions);
+ const stillReferencedLogicFunctionIds = new Set(
+ getLogicFunctionIds([
+ ...remainingSteps.filter(isWorkflowCodeAction),
+ ...remainingSteps.filter(isWorkflowLogicFunctionAction),
+ ]),
+ );
+
+ return [
+ ...new Set(
+ getLogicFunctionIds(
+ getSteps(deletedWorkflowVersions).filter(isWorkflowCodeAction),
+ ),
+ ),
+ ].filter(
+ (logicFunctionId) => !stillReferencedLogicFunctionIds.has(logicFunctionId),
+ );
+};
diff --git a/packages/twenty-server/src/modules/workflow/common/query-hooks/workflow-destroy-many.post-query.hook.ts b/packages/twenty-server/src/modules/workflow/common/query-hooks/workflow-destroy-many.post-query.hook.ts
index 21f65e1b721..169035b6363 100644
--- a/packages/twenty-server/src/modules/workflow/common/query-hooks/workflow-destroy-many.post-query.hook.ts
+++ b/packages/twenty-server/src/modules/workflow/common/query-hooks/workflow-destroy-many.post-query.hook.ts
@@ -6,7 +6,6 @@ import { type WorkspacePostQueryHookInstance } from 'src/engine/api/graphql/work
import { WorkspaceQueryHook } from 'src/engine/api/graphql/workspace-query-runner/workspace-query-hook/decorators/workspace-query-hook.decorator';
import { WorkspaceQueryHookType } from 'src/engine/api/graphql/workspace-query-runner/workspace-query-hook/types/workspace-query-hook.type';
import { type WorkspaceAuthContext } from 'src/engine/core-modules/auth/types/workspace-auth-context.type';
-import { WorkflowVersionCoreSyncService } from 'src/engine/core-modules/workflow/services/workflow-version-core-sync.service';
import { WorkspaceNotFoundDefaultError } from 'src/engine/core-modules/workspace/workspace.exception';
import { type WorkflowWorkspaceEntity } from 'src/modules/workflow/common/standard-objects/workflow.workspace-entity';
@@ -17,7 +16,6 @@ import { type WorkflowWorkspaceEntity } from 'src/modules/workflow/common/standa
export class WorkflowDestroyManyPostQueryHook implements WorkspacePostQueryHookInstance {
constructor(
private readonly workflowCoreSyncService: WorkflowCoreSyncService,
- private readonly workflowVersionCoreSyncService: WorkflowVersionCoreSyncService,
) {}
async execute(
@@ -29,10 +27,6 @@ export class WorkflowDestroyManyPostQueryHook implements WorkspacePostQueryHookI
assertIsDefinedOrThrow(workspace, WorkspaceNotFoundDefaultError);
- await this.workflowVersionCoreSyncService.deleteCoreVersionsByWorkflowIds(
- workspace.id,
- payload.map((workflow) => workflow.id),
- );
await this.workflowCoreSyncService.reconcileWorkspaceWorkflows(
authContext.workspace.id,
payload.map((workflow) => workflow.id),
diff --git a/packages/twenty-server/src/modules/workflow/common/query-hooks/workflow-destroy-one.post-query.hook.ts b/packages/twenty-server/src/modules/workflow/common/query-hooks/workflow-destroy-one.post-query.hook.ts
index c0a76ab9dbc..6ee9a3b1737 100644
--- a/packages/twenty-server/src/modules/workflow/common/query-hooks/workflow-destroy-one.post-query.hook.ts
+++ b/packages/twenty-server/src/modules/workflow/common/query-hooks/workflow-destroy-one.post-query.hook.ts
@@ -6,7 +6,6 @@ import { type WorkspacePostQueryHookInstance } from 'src/engine/api/graphql/work
import { WorkspaceQueryHook } from 'src/engine/api/graphql/workspace-query-runner/workspace-query-hook/decorators/workspace-query-hook.decorator';
import { WorkspaceQueryHookType } from 'src/engine/api/graphql/workspace-query-runner/workspace-query-hook/types/workspace-query-hook.type';
import { type WorkspaceAuthContext } from 'src/engine/core-modules/auth/types/workspace-auth-context.type';
-import { WorkflowVersionCoreSyncService } from 'src/engine/core-modules/workflow/services/workflow-version-core-sync.service';
import { WorkspaceNotFoundDefaultError } from 'src/engine/core-modules/workspace/workspace.exception';
import { type WorkflowWorkspaceEntity } from 'src/modules/workflow/common/standard-objects/workflow.workspace-entity';
@@ -17,7 +16,6 @@ import { type WorkflowWorkspaceEntity } from 'src/modules/workflow/common/standa
export class WorkflowDestroyOnePostQueryHook implements WorkspacePostQueryHookInstance {
constructor(
private readonly workflowCoreSyncService: WorkflowCoreSyncService,
- private readonly workflowVersionCoreSyncService: WorkflowVersionCoreSyncService,
) {}
async execute(
@@ -29,10 +27,6 @@ export class WorkflowDestroyOnePostQueryHook implements WorkspacePostQueryHookIn
assertIsDefinedOrThrow(workspace, WorkspaceNotFoundDefaultError);
- await this.workflowVersionCoreSyncService.deleteCoreVersionsByWorkflowIds(
- workspace.id,
- payload.map((workflow) => workflow.id),
- );
await this.workflowCoreSyncService.reconcileWorkspaceWorkflows(
authContext.workspace.id,
payload.map((workflow) => workflow.id),
diff --git a/packages/twenty-server/src/modules/workflow/common/workspace-services/workflow-common.workspace-service.ts b/packages/twenty-server/src/modules/workflow/common/workspace-services/workflow-common.workspace-service.ts
index 4434dc1f874..bc517efc5bc 100644
--- a/packages/twenty-server/src/modules/workflow/common/workspace-services/workflow-common.workspace-service.ts
+++ b/packages/twenty-server/src/modules/workflow/common/workspace-services/workflow-common.workspace-service.ts
@@ -1,9 +1,9 @@
import { WorkflowCoreSyncService } from 'src/engine/core-modules/workflow/services/workflow-core-sync.service';
-import { Injectable, Logger } from '@nestjs/common';
+import { Injectable } from '@nestjs/common';
import { isNonEmptyString } from '@sniptt/guards';
-import { isDefined, isValidUuid } from 'twenty-shared/utils';
+import { isDefined } from 'twenty-shared/utils';
import { In } from 'typeorm';
import { type WorkspaceAuthContext } from 'src/engine/core-modules/auth/types/workspace-auth-context.type';
@@ -12,11 +12,6 @@ import { CommandMenuItemService } from 'src/engine/metadata-modules/command-menu
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 { type FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';
-import {
- LogicFunctionException,
- LogicFunctionExceptionCode,
-} from 'src/engine/metadata-modules/logic-function/logic-function.exception';
-import { LogicFunctionFromSourceService } from 'src/engine/metadata-modules/logic-function/services/logic-function-from-source.service';
import { type FlatLogicFunction } from 'src/engine/metadata-modules/logic-function/types/flat-logic-function.type';
import { WorkspaceOrmManager } from 'src/engine/twenty-orm/workspace-orm.manager';
import { type WorkspaceRepository } from 'src/engine/twenty-orm/repository/workspace-repository';
@@ -40,18 +35,14 @@ import {
WorkflowTriggerExceptionCode,
} from 'src/modules/workflow/workflow-trigger/exceptions/workflow-trigger.exception';
import { getWorkflowCommandMenuItemLabel } from 'src/modules/workflow/workflow-trigger/utils/get-workflow-command-menu-item-label.util';
-import { WorkflowActionType } from 'twenty-shared/workflow';
export type { ObjectMetadataInfo };
@Injectable()
export class WorkflowCommonWorkspaceService {
- private readonly logger = new Logger(WorkflowCommonWorkspaceService.name);
-
constructor(
private readonly workflowCoreSyncService: WorkflowCoreSyncService,
private readonly workspaceOrmManager: WorkspaceOrmManager,
- private readonly logicFunctionFromSourceService: LogicFunctionFromSourceService,
private readonly workflowMetadataReadService: WorkflowMetadataReadService,
private readonly commandMenuItemService: CommandMenuItemService,
private readonly workflowVersionCoreSyncService: WorkflowVersionCoreSyncService,
@@ -306,11 +297,6 @@ export class WorkflowCommonWorkspaceService {
workflowId,
});
- await this.workflowVersionCoreSyncService.deleteCoreVersionsByWorkflowIds(
- workspaceId,
- [workflowId],
- );
-
break;
case 'restore':
await this.workflowCoreSyncService.upsertToCore(workspaceId, [
@@ -384,7 +370,6 @@ export class WorkflowCommonWorkspaceService {
await this.deactivateVersionOnDelete({
workflowVersionRepository,
workflowId,
- workspaceId,
operation,
});
@@ -394,13 +379,6 @@ export class WorkflowCommonWorkspaceService {
[workflowId],
);
}
-
- await this.handleLogicFunctionSubEntities({
- workflowVersionRepository,
- workflowId,
- workspaceId,
- operation,
- });
}
}, authContext);
}
@@ -408,11 +386,9 @@ export class WorkflowCommonWorkspaceService {
private async deactivateVersionOnDelete({
workflowVersionRepository,
workflowId,
- workspaceId,
operation,
}: {
workflowVersionRepository: WorkspaceRepository<WorkflowVersionWorkspaceEntity>;
- workspaceId: string;
workflowId: string;
operation: 'restore' | 'delete' | 'destroy';
}) {
@@ -464,100 +440,5 @@ export class WorkflowCommonWorkspaceService {
}
},
);
-
- for (const workflowVersion of workflowVersions) {
- if (workflowVersion.status === WorkflowVersionStatus.ACTIVE) {
- await this.cleanupCommandMenuItemForVersion(
- workflowVersion.id,
- workspaceId,
- workflowVersion.coreWorkflowVersionId,
- );
- }
- }
-
- await this.workflowVersionCoreSyncService.invalidateAutomatedTriggerMaps(
- workspaceId,
- );
- }
-
- private async cleanupCommandMenuItemForVersion(
- workflowVersionId: string,
- workspaceId: string,
- coreWorkflowVersionId: string | null,
- ) {
- const existingCommandMenuItem =
- (isDefined(coreWorkflowVersionId)
- ? await this.commandMenuItemService.findByCoreWorkflowVersionId(
- coreWorkflowVersionId,
- workspaceId,
- )
- : null) ??
- (await this.commandMenuItemService.findByWorkflowVersionId(
- workflowVersionId,
- workspaceId,
- ));
-
- if (isDefined(existingCommandMenuItem)) {
- await this.commandMenuItemService.delete(
- existingCommandMenuItem.id,
- workspaceId,
- );
- }
- }
-
- async handleLogicFunctionSubEntities({
- workflowVersionRepository,
- workflowId,
- workspaceId,
- operation,
- }: {
- workflowVersionRepository: WorkspaceRepository<WorkflowVersionWorkspaceEntity>;
- workflowId: string;
- workspaceId: string;
- operation: 'restore' | 'delete' | 'destroy';
- }) {
- // Only handle destroy operation - soft delete/restore is no longer supported
- if (operation !== 'destroy') {
- return;
- }
-
- const workflowVersions = await workflowVersionRepository.find({
- where: {
- workflowId,
- },
- withDeleted: true,
- });
-
- for (const workflowVersion of workflowVersions) {
- for (const step of workflowVersion.steps ?? []) {
- if (step.type === WorkflowActionType.CODE) {
- const logicFunctionId = step.settings.input.logicFunctionId;
-
- if (!isValidUuid(logicFunctionId)) {
- this.logger.warn(
- `Skipping destroy for CODE step with undefined logicFunctionId in workflow ${workflowId}`,
- );
- continue;
- }
-
- await this.logicFunctionFromSourceService
- .deleteOneWithSource({
- id: logicFunctionId,
- workspaceId,
- })
- .catch((error) => {
- if (
- error instanceof LogicFunctionException &&
- error.code ===
- LogicFunctionExceptionCode.LOGIC_FUNCTION_NOT_FOUND
- ) {
- return;
- }
-
- throw error;
- });
- }
- }
- }
}
}
diff --git a/packages/twenty-server/test/integration/graphql/suites/workflow/workflow-deletion-cleanup.integration-spec.ts b/packages/twenty-server/test/integration/graphql/suites/workflow/workflow-deletion-cleanup.integration-spec.ts
new file mode 100644
index 00000000000..4b1ead66e12
--- /dev/null
+++ b/packages/twenty-server/test/integration/graphql/suites/workflow/workflow-deletion-cleanup.integration-spec.ts
@@ -0,0 +1,365 @@
+import { randomUUID } from 'node:crypto';
+
+import { updateWorkflowVersionTrigger } from 'test/integration/graphql/suites/workflow/utils/update-workflow-version-trigger.util';
+import { workflowGraphqlRequest } from 'test/integration/graphql/suites/workflow/utils/workflow-graphql-request.util';
+
+import { getWorkspaceSchemaName } from 'src/engine/workspace-datasource/utils/get-workspace-schema-name.util';
+import { SEED_APPLE_WORKSPACE_ID } from 'src/engine/workspace-manager/dev-seeder/core/constants/seeder-workspaces.constant';
+
+const SCHEMA = getWorkspaceSchemaName(SEED_APPLE_WORKSPACE_ID);
+const PREFIX = `Workflow deletion cleanup ${randomUUID()}`;
+
+type WorkflowVersionStep = {
+ id: string;
+ type: string;
+ settings: { input: Record<string, unknown> };
+};
+
+const graphql = async (query: string, variables?: object) => {
+ const response = await workflowGraphqlRequest(query, variables);
+
+ expect(response.body.errors).toBeUndefined();
+
+ return response.body.data;
+};
+
+const countRows = async (query: string, parameters: unknown[]) => {
+ const [{ count }] = await globalThis.testDataSource.query(
+ `SELECT COUNT(*)::int AS count FROM ${query}`,
+ parameters,
+ );
+
+ return count;
+};
+
+describe('workflow deletion cleanup', () => {
+ beforeAll(() => {
+ jest.useRealTimers();
+ });
+
+ afterAll(() => {
+ jest.useFakeTimers();
+ });
+
+ describe('deleting a workspace workflow', () => {
+ type WorkspaceWorkflow = {
+ workflowId: string;
+ workflowVersionId: string;
+ coreWorkflowId: string;
+ coreWorkflowVersionId: string;
+ };
+
+ let deletedWorkflow: WorkspaceWorkflow;
+ let keptWorkflow: WorkspaceWorkflow;
+ let codeLogicFunctionId: string;
+ let keptCodeLogicFunctionId: string;
+
+ const waitForCoreLink = async ({
+ workflowId,
+ workflowVersionId,
+ }: {
+ workflowId: string;
+ workflowVersionId: string;
+ }): Promise<
+ Pick<WorkspaceWorkflow, 'coreWorkflowId' | 'coreWorkflowVersionId'>
+ > => {
+ for (let attempt = 0; attempt < 40; attempt++) {
+ const [mirror] = await globalThis.testDataSource.query(
+ `SELECT w."coreWorkflowId", v."coreWorkflowVersionId"
+ FROM "${SCHEMA}".workflow w
+ JOIN "${SCHEMA}"."workflowVersion" v ON v."workflowId" = w.id
+ WHERE w.id = $1 AND v.id = $2`,
+ [workflowId, workflowVersionId],
+ );
+
+ if (mirror?.coreWorkflowId && mirror?.coreWorkflowVersionId) {
+ return {
+ coreWorkflowId: mirror.coreWorkflowId,
+ coreWorkflowVersionId: mirror.coreWorkflowVersionId,
+ };
+ }
+
+ await new Promise((resolve) => setTimeout(resolve, 250));
+ }
+
+ throw new Error(
+ `${workflowVersionId} was never linked to its core version`,
+ );
+ };
+
+ const createWorkspaceWorkflow = async (
+ name: string,
+ ): Promise<WorkspaceWorkflow> => {
+ const { createWorkflow } = await graphql(
+ 'mutation CreateWorkflow($name: String!) { createWorkflow(data: { name: $name }) { id } }',
+ { name },
+ );
+ const { workflowVersions } = await graphql(
+ `
+ query FindDraftVersion($workflowId: UUID!) {
+ workflowVersions(filter: { workflowId: { eq: $workflowId } }) {
+ edges {
+ node {
+ id
+ }
+ }
+ }
+ }
+ `,
+ { workflowId: createWorkflow.id },
+ );
+ const workflowVersionId = workflowVersions.edges[0].node.id;
+
+ await updateWorkflowVersionTrigger({
+ workflowVersionId,
+ trigger: {
+ name: 'Manual Trigger',
+ type: 'MANUAL',
+ settings: { outputSchema: {} },
+ nextStepIds: [],
+ position: { x: 0, y: 0 },
+ },
+ });
+
+ return {
+ workflowId: createWorkflow.id,
+ workflowVersionId,
+ ...(await waitForCoreLink({
+ workflowId: createWorkflow.id,
+ workflowVersionId,
+ })),
+ };
+ };
+
+ const createStep = async ({
+ workflowVersionId,
+ stepType,
+ parentStepId,
+ }: {
+ workflowVersionId: string;
+ stepType: 'CODE' | 'FORM';
+ parentStepId: string;
+ }): Promise<WorkflowVersionStep> => {
+ await graphql(
+ `
+ mutation CreateStep($input: CreateWorkflowVersionStepInput!) {
+ createWorkflowVersionStep(input: $input) {
+ stepsDiff
+ }
+ }
+ `,
+ {
+ input: {
+ workflowVersionId,
+ stepType,
+ parentStepId,
+ position: { x: 200, y: 0 },
+ },
+ },
+ );
+
+ const { workflowVersion } = await graphql(
+ 'query FindSteps($id: UUID!) { workflowVersion(filter: { id: { eq: $id } }) { steps } }',
+ { id: workflowVersionId },
+ );
+
+ return workflowVersion.steps.find(
+ (step: WorkflowVersionStep) => step.type === stepType,
+ );
+ };
+
+ beforeAll(async () => {
+ deletedWorkflow = await createWorkspaceWorkflow(`${PREFIX} deleted`);
+ keptWorkflow = await createWorkspaceWorkflow(`${PREFIX} kept`);
+
+ const codeStep = await createStep({
+ workflowVersionId: deletedWorkflow.workflowVersionId,
+ stepType: 'CODE',
+ parentStepId: 'trigger',
+ });
+ const formStep = await createStep({
+ workflowVersionId: deletedWorkflow.workflowVersionId,
+ stepType: 'FORM',
+ parentStepId: codeStep.id,
+ });
+
+ codeLogicFunctionId = codeStep.settings.input.logicFunctionId as string;
+
+ await graphql(
+ `
+ mutation UpdateStep($input: UpdateWorkflowVersionStepInput!) {
+ updateWorkflowVersionStep(input: $input) {
+ id
+ }
+ }
+ `,
+ {
+ input: {
+ workflowVersionId: deletedWorkflow.workflowVersionId,
+ step: {
+ ...formStep,
+ settings: {
+ ...formStep.settings,
+ input: [
+ {
+ id: randomUUID(),
+ name: 'note',
+ label: 'Note',
+ type: 'TEXT',
+ },
+ ],
+ },
+ },
+ },
+ },
+ );
+
+ await graphql(
+ 'mutation Activate($workflowVersionId: UUID!) { activateWorkflowVersion(workflowVersionId: $workflowVersionId) }',
+ { workflowVersionId: deletedWorkflow.workflowVersionId },
+ );
+
+ const keptCodeStep = await createStep({
+ workflowVersionId: keptWorkflow.workflowVersionId,
+ stepType: 'CODE',
+ parentStepId: 'trigger',
+ });
+
+ keptCodeLogicFunctionId = keptCodeStep.settings.input
+ .logicFunctionId as string;
+ }, 180000);
+
+ afterAll(async () => {
+ for (const { workflowId } of [deletedWorkflow, keptWorkflow]) {
+ await workflowGraphqlRequest(
+ 'mutation Destroy($id: ID!) { destroyWorkflow(id: $id) { id } }',
+ { id: workflowId },
+ );
+ }
+ });
+
+ it('discarding a draft deletes its core version and the CODE functions only it uses', async () => {
+ const { createDraftFromWorkflowVersion } = await graphql(
+ `
+ mutation CreateDraft($input: CreateDraftFromWorkflowVersionInput!) {
+ createDraftFromWorkflowVersion(input: $input) {
+ id
+ steps
+ }
+ }
+ `,
+ {
+ input: {
+ workflowId: deletedWorkflow.workflowId,
+ workflowVersionIdToCopy: deletedWorkflow.workflowVersionId,
+ },
+ },
+ );
+ const draftCodeLogicFunctionId =
+ createDraftFromWorkflowVersion.steps.find(
+ (step: WorkflowVersionStep) => step.type === 'CODE',
+ ).settings.input.logicFunctionId;
+ const { coreWorkflowVersionId: draftCoreWorkflowVersionId } =
+ await waitForCoreLink({
+ workflowId: deletedWorkflow.workflowId,
+ workflowVersionId: createDraftFromWorkflowVersion.id,
+ });
+
+ expect(draftCodeLogicFunctionId).not.toBe(codeLogicFunctionId);
+
+ await graphql(
+ `
+ mutation Discard($input: DiscardCoreWorkflowDraftInput!) {
+ discardCoreWorkflowDraft(input: $input) {
+ id
+ }
+ }
+ `,
+ { input: { coreWorkflowVersionId: draftCoreWorkflowVersionId } },
+ );
+
+ expect(
+ await countRows(`core."workflowVersion" WHERE id = $1`, [
+ draftCoreWorkflowVersionId,
+ ]),
+ ).toBe(0);
+ expect(
+ await countRows(`core."logicFunction" WHERE id = $1`, [
+ draftCodeLogicFunctionId,
+ ]),
+ ).toBe(0);
+ expect(
+ await countRows(`core."logicFunction" WHERE id = $1`, [
+ codeLogicFunctionId,
+ ]),
+ ).toBe(1);
+ }, 120000);
+
+ it('deletes the versions, command menu item and CODE functions of the deleted workflow only', async () => {
+ expect(
+ await countRows(
+ `core."commandMenuItem" WHERE "coreWorkflowVersionId" = $1 OR "workflowVersionId" = $2`,
+ [
+ deletedWorkflow.coreWorkflowVersionId,
+ deletedWorkflow.workflowVersionId,
+ ],
+ ),
+ ).toBe(1);
+
+ const { deleteCoreWorkflows } = await graphql(
+ `
+ mutation Delete($input: DeleteCoreWorkflowsInput!) {
+ deleteCoreWorkflows(input: $input) {
+ id
+ }
+ }
+ `,
+ { input: { coreWorkflowIds: [deletedWorkflow.coreWorkflowId] } },
+ );
+
+ expect(deleteCoreWorkflows).toEqual([
+ { id: deletedWorkflow.coreWorkflowId },
+ ]);
+ expect(
+ await countRows(`core.workflow WHERE id = $1`, [
+ deletedWorkflow.coreWorkflowId,
+ ]),
+ ).toBe(0);
+ expect(
+ await countRows(`core."workflowVersion" WHERE "coreWorkflowId" = $1`, [
+ deletedWorkflow.coreWorkflowId,
+ ]),
+ ).toBe(0);
+ expect(
+ await countRows(
+ `core."commandMenuItem" WHERE "coreWorkflowVersionId" = $1 OR "workflowVersionId" = $2`,
+ [
+ deletedWorkflow.coreWorkflowVersionId,
+ deletedWorkflow.workflowVersionId,
+ ],
+ ),
+ ).toBe(0);
+ expect(
+ await countRows(`core."logicFunction" WHERE id = $1`, [
+ codeLogicFunctionId,
+ ]),
+ ).toBe(0);
+
+ expect(
+ await countRows(`core.workflow WHERE id = $1`, [
+ keptWorkflow.coreWorkflowId,
+ ]),
+ ).toBe(1);
+ expect(
+ await countRows(`core."workflowVersion" WHERE id = $1`, [
+ keptWorkflow.coreWorkflowVersionId,
+ ]),
+ ).toBe(1);
+ expect(
+ await countRows(`core."logicFunction" WHERE id = $1`, [
+ keptCodeLogicFunctionId,
+ ]),
+ ).toBe(1);
+ }, 120000);
+ });
+});