Skip to content

The open alternative to Salesforce, designed for AI.

feat(workflow): make core workflow and workflow version syncable so definition changes broadcast (#26158)

Thomas Trompette5cc456df5cae
diff --git a/packages/twenty-client-sdk/src/metadata/generated/schema.graphql b/packages/twenty-client-sdk/src/metadata/generated/schema.graphql
index b19738c9094..c0fa1bb2eff 100644
--- a/packages/twenty-client-sdk/src/metadata/generated/schema.graphql
+++ b/packages/twenty-client-sdk/src/metadata/generated/schema.graphql
@@ -3632,6 +3632,8 @@ enum AllMetadataName {
connectionProvider
searchFieldMetadata
timelineActivityType
+ workflow
+ workflowVersion
}
type MinimalObjectMetadata {
diff --git a/packages/twenty-client-sdk/src/metadata/generated/schema.ts b/packages/twenty-client-sdk/src/metadata/generated/schema.ts
index 9c044f48a6a..fd6896893db 100644
--- a/packages/twenty-client-sdk/src/metadata/generated/schema.ts
+++ b/packages/twenty-client-sdk/src/metadata/generated/schema.ts
@@ -3185,7 +3185,7 @@ export interface CollectionHash {
__typename: 'CollectionHash'
}
-export type AllMetadataName = 'fieldMetadata' | 'objectMetadata' | 'view' | 'viewField' | 'viewFieldGroup' | 'viewGroup' | 'viewSort' | 'rowLevelPermissionPredicate' | 'rowLevelPermissionPredicateGroup' | 'viewFilterGroup' | 'index' | 'logicFunction' | 'viewFilter' | 'role' | 'roleTarget' | 'agent' | 'skill' | 'pageLayout' | 'pageLayoutWidget' | 'pageLayoutTab' | 'commandMenuItem' | 'navigationMenuItem' | 'rolePermissionFlag' | 'permissionFlag' | 'objectPermission' | 'fieldPermission' | 'frontComponent' | 'webhook' | 'applicationVariable' | 'connectionProvider' | 'searchFieldMetadata' | 'timelineActivityType'
+export type AllMetadataName = 'fieldMetadata' | 'objectMetadata' | 'view' | 'viewField' | 'viewFieldGroup' | 'viewGroup' | 'viewSort' | 'rowLevelPermissionPredicate' | 'rowLevelPermissionPredicateGroup' | 'viewFilterGroup' | 'index' | 'logicFunction' | 'viewFilter' | 'role' | 'roleTarget' | 'agent' | 'skill' | 'pageLayout' | 'pageLayoutWidget' | 'pageLayoutTab' | 'commandMenuItem' | 'navigationMenuItem' | 'rolePermissionFlag' | 'permissionFlag' | 'objectPermission' | 'fieldPermission' | 'frontComponent' | 'webhook' | 'applicationVariable' | 'connectionProvider' | 'searchFieldMetadata' | 'timelineActivityType' | 'workflow' | 'workflowVersion'
export interface MinimalObjectMetadata {
id: Scalars['UUID']
@@ -11135,7 +11135,9 @@ export const enumAllMetadataName = {
applicationVariable: 'applicationVariable' as const,
connectionProvider: 'connectionProvider' as const,
searchFieldMetadata: 'searchFieldMetadata' as const,
- timelineActivityType: 'timelineActivityType' as const
+ timelineActivityType: 'timelineActivityType' as const,
+ workflow: 'workflow' as const,
+ workflowVersion: 'workflowVersion' as const
}
export const enumEventLogTable = {
diff --git a/packages/twenty-front/src/generated-metadata/graphql.ts b/packages/twenty-front/src/generated-metadata/graphql.ts
index 91814defbfd..784664098c7 100644
--- a/packages/twenty-front/src/generated-metadata/graphql.ts
+++ b/packages/twenty-front/src/generated-metadata/graphql.ts
@@ -241,7 +241,9 @@ export enum AllMetadataName {
viewFilterGroup = 'viewFilterGroup',
viewGroup = 'viewGroup',
viewSort = 'viewSort',
- webhook = 'webhook'
+ webhook = 'webhook',
+ workflow = 'workflow',
+ workflowVersion = 'workflowVersion'
}
export type Analytics = {
diff --git a/packages/twenty-front/src/modules/metadata-error-handler/hooks/useMetadataErrorHandler.ts b/packages/twenty-front/src/modules/metadata-error-handler/hooks/useMetadataErrorHandler.ts
index 5ce6ec47a6c..da65ad89666 100644
--- a/packages/twenty-front/src/modules/metadata-error-handler/hooks/useMetadataErrorHandler.ts
+++ b/packages/twenty-front/src/modules/metadata-error-handler/hooks/useMetadataErrorHandler.ts
@@ -54,6 +54,8 @@ export const useMetadataErrorHandler = () => {
connectionProvider: t`connection provider`,
searchFieldMetadata: t`search field metadata`,
timelineActivityType: t`timeline activity type`,
+ workflow: t`workflow`,
+ workflowVersion: t`workflow version`,
} as const satisfies Record<AllMetadataName, string>;
const handleMetadataError = (
diff --git a/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/find-manifest-entity-descriptor-by-universal-identifier.util.ts b/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/find-manifest-entity-descriptor-by-universal-identifier.util.ts
index a06bf90357d..ca0468ec0d6 100644
--- a/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/find-manifest-entity-descriptor-by-universal-identifier.util.ts
+++ b/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/find-manifest-entity-descriptor-by-universal-identifier.util.ts
@@ -267,6 +267,14 @@ export const MANIFEST_ENTITY_REGISTRY: Record<
entityKind: 'search field',
getCandidates: () => NO_MANIFEST_CANDIDATES,
},
+ workflow: {
+ entityKind: 'workflow',
+ getCandidates: () => NO_MANIFEST_CANDIDATES,
+ },
+ workflowVersion: {
+ entityKind: 'workflow version',
+ getCandidates: () => NO_MANIFEST_CANDIDATES,
+ },
};
const MANIFEST_ENTITY_REGISTRY_ENTRIES = Object.values(
diff --git a/packages/twenty-server/src/engine/core-modules/workflow/core-workflow-services.module.ts b/packages/twenty-server/src/engine/core-modules/workflow/core-workflow-services.module.ts
index 19b2d06baa6..4bb67c3629d 100644
--- a/packages/twenty-server/src/engine/core-modules/workflow/core-workflow-services.module.ts
+++ b/packages/twenty-server/src/engine/core-modules/workflow/core-workflow-services.module.ts
@@ -1,6 +1,7 @@
import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
+import { ApplicationModule } from 'src/engine/core-modules/application/application.module';
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 { RecordPositionModule } from 'src/engine/core-modules/record-position/record-position.module';
@@ -18,6 +19,8 @@ import { WorkflowCoreModule } from 'src/engine/core-modules/workflow/workflow-co
import { WorkflowVersionCoreModule } from 'src/engine/core-modules/workflow/workflow-version-core.module';
import { WorkspaceEntity } from 'src/engine/core-modules/workspace/workspace.entity';
import { CommandMenuItemModule } from 'src/engine/metadata-modules/command-menu-item/command-menu-item.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 { provideWorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/provide-workspace-scoped-repository';
import { WorkflowCommonModule } from 'src/modules/workflow/common/workflow-common.module';
import { WorkflowMetadataReadModule } from 'src/modules/workflow/common/workspace-services/workflow-metadata-read.module';
@@ -29,6 +32,7 @@ import { AutomatedTriggerModule } from 'src/modules/workflow/workflow-trigger/au
@Module({
imports: [
+ ApplicationModule,
CoreWorkflowAccessModule,
TypeOrmModule.forFeature([WorkspaceEntity, WorkflowVersionEntity]),
AutomatedTriggerModule,
@@ -44,6 +48,8 @@ import { AutomatedTriggerModule } from 'src/modules/workflow/workflow-trigger/au
WorkflowRunnerModule,
WorkflowVersionCoreModule,
WorkflowVersionValidationModule,
+ WorkspaceManyOrAllFlatEntityMapsCacheModule,
+ WorkspaceMigrationModule,
],
providers: [
CoreWorkflowIdResolutionService,
diff --git a/packages/twenty-server/src/engine/core-modules/workflow/exceptions/core-workflow-metadata.exception.ts b/packages/twenty-server/src/engine/core-modules/workflow/exceptions/core-workflow-metadata.exception.ts
new file mode 100644
index 00000000000..34277194e17
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/workflow/exceptions/core-workflow-metadata.exception.ts
@@ -0,0 +1,40 @@
+import { msg } from '@lingui/core/macro';
+import { assertUnreachable } from 'twenty-shared/utils';
+
+import { CustomException } from 'src/utils/custom-exception';
+
+export enum CoreWorkflowMetadataExceptionCode {
+ WORKFLOW_NOT_FOUND = 'WORKFLOW_NOT_FOUND',
+ WORKFLOW_ALREADY_EXISTS = 'WORKFLOW_ALREADY_EXISTS',
+ WORKFLOW_VERSION_NOT_FOUND = 'WORKFLOW_VERSION_NOT_FOUND',
+ WORKFLOW_VERSION_ALREADY_EXISTS = 'WORKFLOW_VERSION_ALREADY_EXISTS',
+ WORKFLOW_VERSION_MISSING_WORKFLOW = 'WORKFLOW_VERSION_MISSING_WORKFLOW',
+}
+
+const getCoreWorkflowMetadataExceptionUserFriendlyMessage = (
+ code: CoreWorkflowMetadataExceptionCode,
+) => {
+ switch (code) {
+ case CoreWorkflowMetadataExceptionCode.WORKFLOW_NOT_FOUND:
+ return msg`Workflow not found.`;
+ case CoreWorkflowMetadataExceptionCode.WORKFLOW_ALREADY_EXISTS:
+ return msg`This workflow already exists.`;
+ case CoreWorkflowMetadataExceptionCode.WORKFLOW_VERSION_NOT_FOUND:
+ return msg`Workflow version not found.`;
+ case CoreWorkflowMetadataExceptionCode.WORKFLOW_VERSION_ALREADY_EXISTS:
+ return msg`This workflow version already exists.`;
+ case CoreWorkflowMetadataExceptionCode.WORKFLOW_VERSION_MISSING_WORKFLOW:
+ return msg`This workflow version is not attached to a workflow.`;
+ default:
+ assertUnreachable(code);
+ }
+};
+
+export class CoreWorkflowMetadataException extends CustomException {
+ constructor(message: string, code: CoreWorkflowMetadataExceptionCode) {
+ super(message, code, {
+ userFriendlyMessage:
+ getCoreWorkflowMetadataExceptionUserFriendlyMessage(code),
+ });
+ }
+}
diff --git a/packages/twenty-server/src/engine/core-modules/workflow/services/__tests__/core-workflow-version-write.service.spec.ts b/packages/twenty-server/src/engine/core-modules/workflow/services/__tests__/core-workflow-version-write.service.spec.ts
deleted file mode 100644
index f1f1886d2f4..00000000000
--- a/packages/twenty-server/src/engine/core-modules/workflow/services/__tests__/core-workflow-version-write.service.spec.ts
+++ /dev/null
@@ -1,64 +0,0 @@
-import {
- CoreWorkflowVersionPostCommitError,
- CoreWorkflowVersionWriteService,
-} from 'src/engine/core-modules/workflow/services/core-workflow-version-write.service';
-
-const workspaceId = '20202020-0000-0000-0000-000000000001';
-const coreWorkflowVersionId = '20202020-0000-0000-0000-000000000002';
-
-describe('CoreWorkflowVersionWriteService', () => {
- it('reports cache invalidation failures as post-commit errors', async () => {
- const cacheError = new Error('Cache unavailable');
- const invalidateAutomatedTriggerMaps = jest
- .fn()
- .mockRejectedValue(cacheError);
- const update = jest.fn().mockResolvedValue({ affected: 1 });
- const executeRawQuery = jest
- .fn()
- .mockResolvedValue([{ id: coreWorkflowVersionId }]);
- const runInWorkspaceTransaction = jest
- .fn()
- .mockImplementation(async (callback) =>
- callback({
- getRepository: () => ({ update }),
- executeRawQuery,
- }),
- );
- const executeInWorkspaceContext = jest
- .fn()
- .mockImplementation(async (callback) => callback());
-
- const service = new CoreWorkflowVersionWriteService(
- {} as never,
- { invalidateAutomatedTriggerMaps } as never,
- {
- assertCoreWorkflowVersionsAreAccessibleOrThrow: jest.fn(),
- } as never,
- {
- getFlatEntityMaps: jest.fn().mockResolvedValue({
- flatObjectMetadataMaps: {},
- flatFieldMetadataMaps: {},
- objectIdByNameSingular: {},
- }),
- } as never,
- { executeInWorkspaceContext, runInWorkspaceTransaction } as never,
- {} as never,
- );
-
- const writePromise = service.writeContentAndMirror({
- workspaceId,
- coreWorkflowVersionId,
- expectedVersion: { triggers: null, steps: null },
- trigger: null,
- steps: null,
- });
-
- const writeError = await writePromise.catch((error) => error);
-
- expect(writeError).toBeInstanceOf(CoreWorkflowVersionPostCommitError);
- expect(writeError).toMatchObject({ cause: cacheError });
- expect(update).toHaveBeenCalledTimes(1);
- expect(executeRawQuery).toHaveBeenCalledTimes(1);
- expect(invalidateAutomatedTriggerMaps).toHaveBeenCalledWith(workspaceId);
- });
-});
diff --git a/packages/twenty-server/src/engine/core-modules/workflow/services/core-workflow-lifecycle.workspace-service.ts b/packages/twenty-server/src/engine/core-modules/workflow/services/core-workflow-lifecycle.workspace-service.ts
index 23a22d472d3..5b4c9783144 100644
--- a/packages/twenty-server/src/engine/core-modules/workflow/services/core-workflow-lifecycle.workspace-service.ts
+++ b/packages/twenty-server/src/engine/core-modules/workflow/services/core-workflow-lifecycle.workspace-service.ts
@@ -1,5 +1,17 @@
import { Injectable, Logger } from '@nestjs/common';
+import { ApplicationService } from 'src/engine/core-modules/application/application.service';
+import { ExceptionHandlerService } from 'src/engine/core-modules/exception-handler/exception-handler.service';
+import {
+ toCoreWorkflowVersionStatus,
+ toWorkspaceWorkflowVersionStatus,
+} from 'src/engine/core-modules/workflow/utils/workflow-version-status.util';
+import { WorkspaceManyOrAllFlatEntityMapsCacheService } from 'src/engine/metadata-modules/flat-entity/services/workspace-many-or-all-flat-entity-maps-cache.service';
+import { type AllFlatEntityOperationByMetadataName } from 'src/engine/metadata-modules/flat-entity/types/flat-entity-to-create-delete-update.type';
+import { findFlatEntityByIdInFlatEntityMapsOrThrow } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-id-in-flat-entity-maps-or-throw.util';
+import { WorkspaceMigrationBuilderException } from 'src/engine/workspace-manager/workspace-migration/exceptions/workspace-migration-builder-exception';
+import { WorkspaceMigrationValidateBuildAndRunService } from 'src/engine/workspace-manager/workspace-migration/services/workspace-migration-validate-build-and-run-service';
+
import { msg } from '@lingui/core/macro';
import {
CommandMenuItemAvailabilityType,
@@ -70,6 +82,11 @@ type ResolvedCoreVersion = {
workspaceWorkflowId: string;
};
+type TriggerToRestore = {
+ resolved: ResolvedCoreVersion;
+ action: 'enable' | 'disable';
+};
+
@Injectable()
export class CoreWorkflowLifecycleWorkspaceService {
private readonly logger = new Logger(
@@ -92,6 +109,10 @@ export class CoreWorkflowLifecycleWorkspaceService {
private readonly workspaceOrmManager: WorkspaceOrmManager,
@InjectCacheStorage(CacheStorageNamespace.ModuleWorkflow)
private readonly cacheStorageService: CacheStorageService,
+ private readonly workspaceMigrationValidateBuildAndRunService: WorkspaceMigrationValidateBuildAndRunService,
+ private readonly flatEntityMapsCacheService: WorkspaceManyOrAllFlatEntityMapsCacheService,
+ private readonly applicationService: ApplicationService,
+ private readonly exceptionHandlerService: ExceptionHandlerService,
) {}
async validateCoreWorkflowVersion({
@@ -205,6 +226,21 @@ export class CoreWorkflowLifecycleWorkspaceService {
let previousResolved: ResolvedCoreVersion | undefined;
+ // The workspace side keeps its transaction, locks and checks. The core side
+ // is collected here and applied by the migration runner once that
+ // transaction has committed, then reverted if it did not.
+ const pendingCoreStatuses = new Map<string, WorkflowVersionStatus>();
+ const triggersToRestore: TriggerToRestore[] = [];
+ const statusesToRestore = new Map<string, WorkflowVersionStatus>();
+ let pendingCoreWorkflowUpdate:
+ | {
+ coreWorkflowId: string;
+ lastPublishedCoreWorkflowVersionId: string | null;
+ lastPublishedVersionId: string | null;
+ }
+ | undefined;
+ let coreWorkflowUpdateToRestore: typeof pendingCoreWorkflowUpdate;
+
await this.workspaceOrmManager.executeInWorkspaceContext(async () => {
await this.workspaceOrmManager.runInWorkspaceTransaction(
async (transactionScope) => {
@@ -289,13 +325,26 @@ export class CoreWorkflowLifecycleWorkspaceService {
resolved: previousResolved,
transactionScope,
});
+
+ triggersToRestore.push({
+ resolved: previousResolved,
+ action: 'enable',
+ });
}
await this.writeVersionStatusInTransaction({
transactionScope,
workspaceId,
coreWorkflowVersionId: previousResolved.coreWorkflowVersion.id,
status: WorkflowVersionStatus.ARCHIVED,
+ pendingCoreStatuses,
});
+
+ statusesToRestore.set(
+ previousResolved.coreWorkflowVersion.id,
+ toWorkspaceWorkflowVersionStatus(
+ previousResolved.coreWorkflowVersion.status,
+ ),
+ );
}
await transactionScope
@@ -309,33 +358,61 @@ export class CoreWorkflowLifecycleWorkspaceService {
},
);
- 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,
- ],
- );
+ pendingCoreWorkflowUpdate = {
+ coreWorkflowId: coreWorkflow.id,
+ lastPublishedCoreWorkflowVersionId: coreWorkflowVersion.id,
+ lastPublishedVersionId: resolved.workspaceWorkflowVersionId,
+ };
+
+ coreWorkflowUpdateToRestore = {
+ coreWorkflowId: coreWorkflow.id,
+ lastPublishedCoreWorkflowVersionId:
+ coreWorkflow.lastPublishedCoreWorkflowVersionId,
+ lastPublishedVersionId: coreWorkflow.lastPublishedVersionId,
+ };
await this.writeVersionStatusInTransaction({
transactionScope,
workspaceId,
coreWorkflowVersionId: coreWorkflowVersion.id,
status: WorkflowVersionStatus.ACTIVE,
+ pendingCoreStatuses,
});
+ statusesToRestore.set(
+ coreWorkflowVersion.id,
+ toWorkspaceWorkflowVersionStatus(coreWorkflowVersion.status),
+ );
+
await this.enableAutomatedTrigger({
resolved,
transactionScope,
});
+
+ triggersToRestore.push({ resolved, action: 'disable' });
},
);
}, buildSystemAuthContext(workspaceId));
+ try {
+ await this.applyCoreVersionStatuses({
+ workspaceId,
+ statusByCoreWorkflowVersionId: pendingCoreStatuses,
+ coreWorkflowUpdate: pendingCoreWorkflowUpdate,
+ });
+ } catch (error) {
+ await this.revertMirrorStatusesAfterCoreFailure({
+ workspaceId,
+ statusByCoreWorkflowVersionId: statusesToRestore,
+ workspaceWorkflowId: resolved.workspaceWorkflowId,
+ lastPublishedVersionId:
+ coreWorkflowUpdateToRestore?.lastPublishedVersionId ?? null,
+ triggersToRestore,
+ });
+
+ throw error;
+ }
+
if (isDefined(previousResolved)) {
await this.deleteCommandMenuItem({
workspaceId,
@@ -389,6 +466,9 @@ export class CoreWorkflowLifecycleWorkspaceService {
return true;
}
+ const pendingCoreStatuses = new Map<string, WorkflowVersionStatus>();
+ const triggersToRestore: TriggerToRestore[] = [];
+
await this.workspaceOrmManager.executeInWorkspaceContext(async () => {
await this.workspaceOrmManager.runInWorkspaceTransaction(
async (transactionScope) => {
@@ -397,16 +477,36 @@ export class CoreWorkflowLifecycleWorkspaceService {
workspaceId,
coreWorkflowVersionId: resolved.coreWorkflowVersion.id,
status: WorkflowVersionStatus.DEACTIVATED,
+ pendingCoreStatuses,
});
await this.disableAutomatedTrigger({
resolved,
transactionScope,
});
+
+ triggersToRestore.push({ resolved, action: 'enable' });
},
);
}, buildSystemAuthContext(workspaceId));
+ try {
+ await this.applyCoreVersionStatuses({
+ workspaceId,
+ statusByCoreWorkflowVersionId: pendingCoreStatuses,
+ });
+ } catch (error) {
+ await this.revertMirrorStatusesAfterCoreFailure({
+ workspaceId,
+ statusByCoreWorkflowVersionId: new Map([
+ [resolved.coreWorkflowVersion.id, WorkflowVersionStatus.ACTIVE],
+ ]),
+ triggersToRestore,
+ });
+
+ throw error;
+ }
+
await this.deleteCommandMenuItem({ workspaceId, resolved });
await this.workflowVersionCoreSyncService.invalidateAutomatedTriggerMaps(
@@ -532,16 +632,20 @@ export class CoreWorkflowLifecycleWorkspaceService {
return currentlyActiveCoreVersion?.id ?? null;
}
+ // The core half of this write is collected and applied by the migration runner
+ // after the transaction, because the runner owns its own transaction and the
+ // events the surfaces listen to are derived from its actions.
private async writeVersionStatusInTransaction({
transactionScope,
- workspaceId,
coreWorkflowVersionId,
status,
+ pendingCoreStatuses,
}: {
transactionScope: WorkspaceTransactionScope;
workspaceId: string;
coreWorkflowVersionId: string;
status: WorkflowVersionStatus;
+ pendingCoreStatuses: Map<string, WorkflowVersionStatus>;
}): Promise<void> {
const mirrorUpdateResult = await transactionScope
.getRepository<WorkflowVersionWorkspaceEntity>('workflowVersion', {
@@ -554,12 +658,204 @@ export class CoreWorkflowLifecycleWorkspaceService {
coreWorkflowVersionId,
});
- await transactionScope.executeRawQuery(
- `UPDATE core."workflowVersion"
- SET "status" = $3, "updatedAt" = now()
- WHERE "id" = $1 AND "workspaceId" = $2`,
- [coreWorkflowVersionId, workspaceId, status],
- );
+ pendingCoreStatuses.set(coreWorkflowVersionId, status);
+ }
+
+ private async applyCoreVersionStatuses({
+ workspaceId,
+ statusByCoreWorkflowVersionId,
+ coreWorkflowUpdate,
+ }: {
+ workspaceId: string;
+ statusByCoreWorkflowVersionId: Map<string, WorkflowVersionStatus>;
+ coreWorkflowUpdate?: {
+ coreWorkflowId: string;
+ lastPublishedCoreWorkflowVersionId: string | null;
+ lastPublishedVersionId: string | null;
+ };
+ }): Promise<void> {
+ if (
+ statusByCoreWorkflowVersionId.size === 0 &&
+ !isDefined(coreWorkflowUpdate)
+ ) {
+ return;
+ }
+
+ const { flatWorkflowVersionMaps, flatWorkflowMaps } =
+ await this.flatEntityMapsCacheService.getOrRecomputeManyOrAllFlatEntityMaps(
+ {
+ workspaceId,
+ flatMapsKeys: ['flatWorkflowVersionMaps', 'flatWorkflowMaps'],
+ },
+ );
+
+ const flatWorkflowVersionsToUpdate = [
+ ...statusByCoreWorkflowVersionId.entries(),
+ ].map(([coreWorkflowVersionId, status]) => ({
+ ...findFlatEntityByIdInFlatEntityMapsOrThrow({
+ flatEntityId: coreWorkflowVersionId,
+ flatEntityMaps: flatWorkflowVersionMaps,
+ }),
+ status: toCoreWorkflowVersionStatus(status),
+ }));
+
+ const flatWorkflowsToUpdate = isDefined(coreWorkflowUpdate)
+ ? [
+ {
+ ...findFlatEntityByIdInFlatEntityMapsOrThrow({
+ flatEntityId: coreWorkflowUpdate.coreWorkflowId,
+ flatEntityMaps: flatWorkflowMaps,
+ }),
+ lastPublishedCoreWorkflowVersionId:
+ coreWorkflowUpdate.lastPublishedCoreWorkflowVersionId,
+ lastPublishedVersionId: coreWorkflowUpdate.lastPublishedVersionId,
+ },
+ ]
+ : [];
+
+ await this.runCoreWorkflowMigration({
+ workspaceId,
+ failureMessage:
+ 'Multiple validation errors occurred while writing workflow version status',
+ operations: {
+ ...(flatWorkflowVersionsToUpdate.length > 0
+ ? {
+ workflowVersion: {
+ flatEntityToCreate: [],
+ flatEntityToDelete: [],
+ flatEntityToUpdate: flatWorkflowVersionsToUpdate,
+ },
+ }
+ : {}),
+ ...(flatWorkflowsToUpdate.length > 0
+ ? {
+ workflow: {
+ flatEntityToCreate: [],
+ flatEntityToDelete: [],
+ flatEntityToUpdate: flatWorkflowsToUpdate,
+ },
+ }
+ : {}),
+ },
+ });
+ }
+
+ private async revertMirrorStatusesAfterCoreFailure({
+ workspaceId,
+ statusByCoreWorkflowVersionId,
+ workspaceWorkflowId,
+ lastPublishedVersionId,
+ triggersToRestore = [],
+ }: {
+ workspaceId: string;
+ statusByCoreWorkflowVersionId: Map<string, WorkflowVersionStatus>;
+ workspaceWorkflowId?: string;
+ lastPublishedVersionId?: string | null;
+ triggersToRestore?: TriggerToRestore[];
+ }): Promise<void> {
+ try {
+ await this.workspaceOrmManager.executeInWorkspaceContext(async () => {
+ await this.workspaceOrmManager.runInWorkspaceTransaction(
+ async (transactionScope) => {
+ for (const [
+ coreWorkflowVersionId,
+ status,
+ ] of statusByCoreWorkflowVersionId.entries()) {
+ await transactionScope
+ .getRepository<WorkflowVersionWorkspaceEntity>(
+ 'workflowVersion',
+ { shouldBypassPermissionChecks: true },
+ )
+ .update({ coreWorkflowVersionId }, { status });
+ }
+
+ if (isDefined(workspaceWorkflowId)) {
+ await transactionScope
+ .getRepository<WorkflowWorkspaceEntity>('workflow', {
+ shouldBypassPermissionChecks: true,
+ })
+ .update(
+ { id: workspaceWorkflowId },
+ { lastPublishedVersionId: lastPublishedVersionId ?? null },
+ );
+ }
+
+ // The trigger work committed with the mirror transaction, so leaving it
+ // would arm an automation on a version that is no longer active.
+ for (const { resolved, action } of [
+ ...triggersToRestore,
+ ].reverse()) {
+ if (action === 'enable') {
+ await this.enableAutomatedTrigger({
+ resolved,
+ transactionScope,
+ });
+ } else {
+ await this.disableAutomatedTrigger({
+ resolved,
+ transactionScope,
+ });
+ }
+ }
+ },
+ );
+ }, buildSystemAuthContext(workspaceId));
+
+ // The forward disable dropped the cron cache entry after its commit, so a
+ // re-armed cron version would stay invisible to the scheduler without this.
+ for (const { resolved, action } of triggersToRestore) {
+ if (action === 'enable') {
+ await this.writeCronTriggerCacheEntryAfterCommit({ resolved });
+ }
+ }
+ } catch (revertError) {
+ this.exceptionHandlerService.captureExceptions([revertError], {
+ additionalData: {
+ workspaceId,
+ coreWorkflowVersionIds: [...statusByCoreWorkflowVersionId.keys()],
+ },
+ });
+ this.logger.error(
+ `Failed to revert mirror statuses after a core write failure in workspace ${workspaceId}`,
+ );
+ }
+ }
+
+ private async runCoreWorkflowMigration({
+ workspaceId,
+ failureMessage,
+ operations,
+ applicationUniversalIdentifier,
+ }: {
+ workspaceId: string;
+ failureMessage: string;
+ operations: AllFlatEntityOperationByMetadataName;
+ applicationUniversalIdentifier?: string;
+ }): Promise<void> {
+ const universalIdentifier =
+ applicationUniversalIdentifier ??
+ (
+ await this.applicationService.findWorkspaceTwentyStandardAndCustomApplicationOrThrow(
+ { workspaceId },
+ )
+ ).workspaceCustomFlatApplication.universalIdentifier;
+
+ const validateAndBuildResult =
+ await this.workspaceMigrationValidateBuildAndRunService.validateBuildAndRunWorkspaceMigration(
+ {
+ allFlatEntityOperationByMetadataName: operations,
+ workspaceId,
+ isSystemBuild: false,
+ applicationUniversalIdentifier: universalIdentifier,
+ },
+ );
+
+ if (validateAndBuildResult.status === 'fail') {
+ throw new WorkspaceMigrationBuilderException(
+ validateAndBuildResult,
+ failureMessage,
+ );
+ }
}
private async enableAutomatedTrigger({
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 6fa117186b6..cab93b341a5 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,5 +1,12 @@
import { Injectable, Logger } from '@nestjs/common';
+import { ApplicationService } from 'src/engine/core-modules/application/application.service';
+import { WorkspaceManyOrAllFlatEntityMapsCacheService } from 'src/engine/metadata-modules/flat-entity/services/workspace-many-or-all-flat-entity-maps-cache.service';
+import { type AllFlatEntityOperationByMetadataName } from 'src/engine/metadata-modules/flat-entity/types/flat-entity-to-create-delete-update.type';
+import { findFlatEntityByIdInFlatEntityMapsOrThrow } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-id-in-flat-entity-maps-or-throw.util';
+import { WorkspaceMigrationBuilderException } from 'src/engine/workspace-manager/workspace-migration/exceptions/workspace-migration-builder-exception';
+import { WorkspaceMigrationValidateBuildAndRunService } from 'src/engine/workspace-manager/workspace-migration/services/workspace-migration-validate-build-and-run-service';
+
import { Equal, In, IsNull, Or } from 'typeorm';
import { msg } from '@lingui/core/macro';
import { type ActorMetadata, WorkflowVisibility } from 'twenty-shared/types';
@@ -65,8 +72,48 @@ export class CoreWorkflowMutationWorkspaceService {
private readonly coreWorkflowVersionRepository: WorkspaceScopedRepository<WorkflowVersionEntity>,
private readonly workspaceOrmManager: WorkspaceOrmManager,
private readonly recordPositionService: RecordPositionService,
+ private readonly workspaceMigrationValidateBuildAndRunService: WorkspaceMigrationValidateBuildAndRunService,
+ private readonly flatEntityMapsCacheService: WorkspaceManyOrAllFlatEntityMapsCacheService,
+ private readonly applicationService: ApplicationService,
) {}
+ private async runCoreWorkflowMigration({
+ workspaceId,
+ failureMessage,
+ operations,
+ applicationUniversalIdentifier,
+ }: {
+ workspaceId: string;
+ failureMessage: string;
+ operations: AllFlatEntityOperationByMetadataName;
+ applicationUniversalIdentifier?: string;
+ }): Promise<void> {
+ const universalIdentifier =
+ applicationUniversalIdentifier ??
+ (
+ await this.applicationService.findWorkspaceTwentyStandardAndCustomApplicationOrThrow(
+ { workspaceId },
+ )
+ ).workspaceCustomFlatApplication.universalIdentifier;
+
+ const validateAndBuildResult =
+ await this.workspaceMigrationValidateBuildAndRunService.validateBuildAndRunWorkspaceMigration(
+ {
+ allFlatEntityOperationByMetadataName: operations,
+ workspaceId,
+ isSystemBuild: false,
+ applicationUniversalIdentifier: universalIdentifier,
+ },
+ );
+
+ if (validateAndBuildResult.status === 'fail') {
+ throw new WorkspaceMigrationBuilderException(
+ validateAndBuildResult,
+ failureMessage,
+ );
+ }
+ }
+
async duplicateWorkflow({
workspaceId,
createdBy,
@@ -276,21 +323,35 @@ export class CoreWorkflowMutationWorkspaceService {
{ workspaceId, userWorkspaceId, coreWorkflowId },
);
- await this.workspaceOrmManager.executeInWorkspaceContext(async () => {
- await this.workspaceOrmManager.runInWorkspaceTransaction(
- async (transactionScope) => {
- await transactionScope
- .getRepository<WorkflowWorkspaceEntity>('workflow', {
- shouldBypassPermissionChecks: true,
- })
- .update({ id: workspaceWorkflowId }, { name });
+ const { flatWorkflowMaps } =
+ await this.flatEntityMapsCacheService.getOrRecomputeManyOrAllFlatEntityMaps(
+ { workspaceId, flatMapsKeys: ['flatWorkflowMaps'] },
+ );
- await transactionScope.executeRawQuery(
- `UPDATE core."workflow" SET "name" = $1, "updatedAt" = now() WHERE "id" = $2 AND "workspaceId" = $3`,
- [name, coreWorkflowId, workspaceId],
- );
+ const flatWorkflow = findFlatEntityByIdInFlatEntityMapsOrThrow({
+ flatEntityId: coreWorkflowId,
+ flatEntityMaps: flatWorkflowMaps,
+ });
+
+ await this.runCoreWorkflowMigration({
+ workspaceId,
+ failureMessage:
+ 'Multiple validation errors occurred while renaming workflow',
+ operations: {
+ workflow: {
+ flatEntityToCreate: [],
+ flatEntityToDelete: [],
+ flatEntityToUpdate: [{ ...flatWorkflow, name }],
},
- );
+ },
+ });
+
+ await this.workspaceOrmManager.executeInWorkspaceContext(async () => {
+ await this.workspaceOrmManager
+ .getRepository<WorkflowWorkspaceEntity>('workflow', {
+ shouldBypassPermissionChecks: true,
+ })
+ .update({ id: workspaceWorkflowId }, { name });
}, buildSystemAuthContext(workspaceId));
await this.syncCommandMenuItemLabelFromCore({
@@ -371,18 +432,46 @@ export class CoreWorkflowMutationWorkspaceService {
const workspaceWorkflowId = uuidv4();
- const coreWorkflow = await this.coreWorkflowRepository.insertAndReturnOne(
+ const createdAt = new Date().toISOString();
+
+ const coreWorkflow = {
+ id: uuidv4(),
+ name: name ?? null,
+ universalIdentifier: uuidv4(),
+ workspaceWorkflowId,
+ visibility: visibility ?? WorkflowVisibility.WORKSPACE,
+ createdByUserWorkspaceId: userWorkspaceId ?? null,
+ lastPublishedVersionId: null,
+ lastPublishedCoreWorkflowVersionId: null,
+ createdAt,
+ updatedAt: createdAt,
+ };
+
+ const { workspaceCustomFlatApplication } =
+ await this.applicationService.findWorkspaceTwentyStandardAndCustomApplicationOrThrow(
+ { workspaceId },
+ );
+
+ await this.runCoreWorkflowMigration({
workspaceId,
- {
- id: uuidv4(),
- name: name ?? null,
- universalIdentifier: uuidv4(),
- applicationId,
- workspaceWorkflowId,
- visibility: visibility ?? WorkflowVisibility.WORKSPACE,
- createdByUserWorkspaceId: userWorkspaceId,
+ applicationUniversalIdentifier:
+ workspaceCustomFlatApplication.universalIdentifier,
+ failureMessage:
+ 'Multiple validation errors occurred while creating workflow',
+ operations: {
+ workflow: {
+ flatEntityToCreate: [
+ {
+ ...coreWorkflow,
+ applicationUniversalIdentifier:
+ workspaceCustomFlatApplication.universalIdentifier,
+ },
+ ],
+ flatEntityToDelete: [],
+ flatEntityToUpdate: [],
+ },
},
- );
+ });
try {
await this.workspaceOrmManager.executeInWorkspaceContext(async () => {
@@ -437,8 +526,8 @@ export class CoreWorkflowMutationWorkspaceService {
workspaceWorkflowId,
visibility: coreWorkflow.visibility,
canChangeVisibility: true,
- createdAt: coreWorkflow.createdAt.toISOString(),
- updatedAt: coreWorkflow.updatedAt.toISOString(),
+ createdAt: coreWorkflow.createdAt,
+ updatedAt: coreWorkflow.updatedAt,
};
}
@@ -628,14 +717,21 @@ export class CoreWorkflowMutationWorkspaceService {
);
}
+ const { flatWorkflowVersionMaps } =
+ await this.flatEntityMapsCacheService.getOrRecomputeManyOrAllFlatEntityMaps(
+ { workspaceId, flatMapsKeys: ['flatWorkflowVersionMaps'] },
+ );
+
+ const flatCoreVersionToDelete = findFlatEntityByIdInFlatEntityMapsOrThrow({
+ flatEntityId: coreVersion.id,
+ flatEntityMaps: flatWorkflowVersionMaps,
+ });
+
+ // The mirror goes first: the other order committed the core delete before the
+ // assert could veto it, which destroyed the version's triggers and steps.
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],
- );
-
const mirrorDeleteResult = await transactionScope
.getRepository<WorkflowVersionWorkspaceEntity>('workflowVersion', {
shouldBypassPermissionChecks: true,
@@ -650,6 +746,28 @@ export class CoreWorkflowMutationWorkspaceService {
);
}, buildSystemAuthContext(workspaceId));
+ try {
+ await this.runCoreWorkflowMigration({
+ workspaceId,
+ failureMessage:
+ 'Multiple validation errors occurred while discarding workflow draft',
+ operations: {
+ workflowVersion: {
+ flatEntityToCreate: [],
+ flatEntityToDelete: [flatCoreVersionToDelete],
+ flatEntityToUpdate: [],
+ },
+ },
+ });
+ } catch (error) {
+ await this.restoreDiscardedMirrorVersion({
+ workspaceId,
+ coreWorkflowVersionId: coreVersion.id,
+ });
+
+ throw error;
+ }
+
await this.workflowVersionCoreSyncService.invalidateAutomatedTriggerMaps(
workspaceId,
);
@@ -657,6 +775,28 @@ export class CoreWorkflowMutationWorkspaceService {
return coreVersion.coreWorkflowId;
}
+ private async restoreDiscardedMirrorVersion({
+ workspaceId,
+ coreWorkflowVersionId,
+ }: {
+ workspaceId: string;
+ coreWorkflowVersionId: string;
+ }): Promise<void> {
+ try {
+ await this.workspaceOrmManager.executeInWorkspaceContext(async () => {
+ await this.workspaceOrmManager
+ .getRepository<WorkflowVersionWorkspaceEntity>('workflowVersion', {
+ shouldBypassPermissionChecks: true,
+ })
+ .restore({ coreWorkflowVersionId });
+ }, buildSystemAuthContext(workspaceId));
+ } catch (restoreError) {
+ this.logger.error(
+ `Failed to restore the mirror version for core version ${coreWorkflowVersionId} in workspace ${workspaceId}: ${restoreError}`,
+ );
+ }
+ }
+
private async resolveDiscardTargetCoreVersionId(
workspaceId: string,
{
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
index ec8fee45d29..2397b38285b 100644
--- a/packages/twenty-server/src/engine/core-modules/workflow/services/core-workflow-version-mutation.workspace-service.ts
+++ b/packages/twenty-server/src/engine/core-modules/workflow/services/core-workflow-version-mutation.workspace-service.ts
@@ -757,18 +757,12 @@ export class CoreWorkflowVersionMutationWorkspaceService {
});
}
- const applicationId =
- await this.workflowCoreSyncService.getCustomApplicationIdOrThrow(
- workspaceId,
- );
-
const { coreWorkflowVersionId } =
await this.coreWorkflowVersionWriteService.createDraftCoreWorkflowVersionAndMirror(
{
workspaceId,
coreWorkflowId: coreWorkflow.id,
workspaceWorkflowId,
- applicationId,
trigger: triggerToCopy,
steps: copiedSteps,
},
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
index 460c7f04571..da44d809d46 100644
--- a/packages/twenty-server/src/engine/core-modules/workflow/services/core-workflow-version-write.service.ts
+++ b/packages/twenty-server/src/engine/core-modules/workflow/services/core-workflow-version-write.service.ts
@@ -1,7 +1,10 @@
import { Injectable } from '@nestjs/common';
+import { InjectDataSource } from '@nestjs/typeorm';
import { msg } from '@lingui/core/macro';
import { isDefined } from 'twenty-shared/utils';
+import isEqual from 'lodash.isequal';
+import { DataSource } from 'typeorm';
import { v4 as uuidv4 } from 'uuid';
import { RecordPositionService } from 'src/engine/core-modules/record-position/services/record-position.service';
@@ -11,7 +14,13 @@ import {
} 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 { ApplicationService } from 'src/engine/core-modules/application/application.service';
import { CoreWorkflowAccessService } from 'src/engine/core-modules/workflow/services/core-workflow-access.service';
+import { type AllFlatEntityOperationByMetadataName } from 'src/engine/metadata-modules/flat-entity/types/flat-entity-to-create-delete-update.type';
+import { WorkspaceMigrationBuilderException } from 'src/engine/workspace-manager/workspace-migration/exceptions/workspace-migration-builder-exception';
+import { WorkspaceMigrationValidateBuildAndRunService } from 'src/engine/workspace-manager/workspace-migration/services/workspace-migration-validate-build-and-run-service';
+import { WorkspaceManyOrAllFlatEntityMapsCacheService } from 'src/engine/metadata-modules/flat-entity/services/workspace-many-or-all-flat-entity-maps-cache.service';
+import { findFlatEntityByIdInFlatEntityMapsOrThrow } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-id-in-flat-entity-maps-or-throw.util';
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';
@@ -47,15 +56,57 @@ export class CoreWorkflowVersionPostCommitError extends Error {
@Injectable()
export class CoreWorkflowVersionWriteService {
constructor(
+ @InjectDataSource()
+ private readonly coreDataSource: DataSource,
@InjectWorkspaceScopedRepository(WorkflowVersionEntity)
private readonly coreWorkflowVersionRepository: WorkspaceScopedRepository<WorkflowVersionEntity>,
private readonly workflowVersionCoreSyncService: WorkflowVersionCoreSyncService,
+ private readonly workspaceMigrationValidateBuildAndRunService: WorkspaceMigrationValidateBuildAndRunService,
+ private readonly applicationService: ApplicationService,
+ private readonly flatEntityMapsCacheService: WorkspaceManyOrAllFlatEntityMapsCacheService,
private readonly coreWorkflowAccessService: CoreWorkflowAccessService,
private readonly workflowMetadataReadService: WorkflowMetadataReadService,
private readonly workspaceOrmManager: WorkspaceOrmManager,
private readonly recordPositionService: RecordPositionService,
) {}
+ private async runCoreWorkflowMigration({
+ workspaceId,
+ failureMessage,
+ operations,
+ applicationUniversalIdentifier,
+ }: {
+ workspaceId: string;
+ failureMessage: string;
+ operations: AllFlatEntityOperationByMetadataName;
+ applicationUniversalIdentifier?: string;
+ }): Promise<void> {
+ const universalIdentifier =
+ applicationUniversalIdentifier ??
+ (
+ await this.applicationService.findWorkspaceTwentyStandardAndCustomApplicationOrThrow(
+ { workspaceId },
+ )
+ ).workspaceCustomFlatApplication.universalIdentifier;
+
+ const validateAndBuildResult =
+ await this.workspaceMigrationValidateBuildAndRunService.validateBuildAndRunWorkspaceMigration(
+ {
+ allFlatEntityOperationByMetadataName: operations,
+ workspaceId,
+ isSystemBuild: false,
+ applicationUniversalIdentifier: universalIdentifier,
+ },
+ );
+
+ if (validateAndBuildResult.status === 'fail') {
+ throw new WorkspaceMigrationBuilderException(
+ validateAndBuildResult,
+ failureMessage,
+ );
+ }
+ }
+
async getValidatedDraftCoreWorkflowVersion({
workspaceId,
userWorkspaceId,
@@ -125,53 +176,89 @@ export class CoreWorkflowVersionWriteService {
steps,
});
- await this.workspaceOrmManager.executeInWorkspaceContext(async () => {
- await this.workspaceOrmManager.runInWorkspaceTransaction(
- async (transactionScope) => {
- const mirrorUpdateResult = await transactionScope
- .getRepository<WorkflowVersionWorkspaceEntity>('workflowVersion', {
- shouldBypassPermissionChecks: true,
- })
- .update({ coreWorkflowVersionId }, { trigger, steps });
-
- assertExactlyOneMirrorRowWasWritten({
- affected: mirrorUpdateResult.affected,
- coreWorkflowVersionId,
+ // main compared the previous content inside the UPDATE itself to catch two
+ // people editing the same draft. The runner cannot express that condition,
+ // so the comparison and the write it guards are serialized on this lock.
+ await this.withCoreWorkflowVersionEditLock(
+ coreWorkflowVersionId,
+ async () => {
+ const persistedVersion =
+ await this.coreWorkflowVersionRepository.findOne(workspaceId, {
+ where: { id: coreWorkflowVersionId },
+ select: { id: true, triggers: true, steps: true, status: true },
});
- const updatedVersions = await transactionScope.executeRawQuery(
- `UPDATE core."workflowVersion"
- SET "triggers" = $3, "steps" = $4, "updatedAt" = now()
- WHERE "id" = $1 AND "workspaceId" = $2 AND "status" = 'DRAFT'
- AND "triggers" IS NOT DISTINCT FROM $5::jsonb
- AND "steps" IS NOT DISTINCT FROM $6::jsonb
- RETURNING "id"`,
- [
- coreWorkflowVersionId,
- workspaceId,
- isDefined(trigger) ? JSON.stringify([trigger]) : null,
- isDefined(steps) ? JSON.stringify(steps) : null,
- isDefined(expectedVersion.triggers)
- ? JSON.stringify(expectedVersion.triggers)
- : null,
- isDefined(expectedVersion.steps)
- ? JSON.stringify(expectedVersion.steps)
- : null,
- ],
+ if (
+ !isDefined(persistedVersion) ||
+ persistedVersion.status !== CoreWorkflowVersionStatus.DRAFT ||
+ !isEqual(
+ persistedVersion.triggers ?? null,
+ expectedVersion.triggers ?? null,
+ ) ||
+ !isEqual(
+ persistedVersion.steps ?? null,
+ expectedVersion.steps ?? null,
+ )
+ ) {
+ throw new WorkflowQueryValidationException(
+ `Core workflow version '${coreWorkflowVersionId}' changed during this edit`,
+ WorkflowQueryValidationExceptionCode.FORBIDDEN,
+ {
+ userFriendlyMessage: msg`Workflow version changed, please reload and retry`,
+ },
);
+ }
- if (updatedVersions.length !== 1) {
- throw new WorkflowQueryValidationException(
- `Core workflow version '${coreWorkflowVersionId}' changed during this edit`,
- WorkflowQueryValidationExceptionCode.FORBIDDEN,
- {
- userFriendlyMessage: msg`Workflow version changed, please reload and retry`,
- },
- );
- }
- },
- );
- }, buildSystemAuthContext(workspaceId));
+ const { flatWorkflowVersionMaps } =
+ await this.flatEntityMapsCacheService.getOrRecomputeManyOrAllFlatEntityMaps(
+ { workspaceId, flatMapsKeys: ['flatWorkflowVersionMaps'] },
+ );
+
+ const flatWorkflowVersion = findFlatEntityByIdInFlatEntityMapsOrThrow({
+ flatEntityId: coreWorkflowVersionId,
+ flatEntityMaps: flatWorkflowVersionMaps,
+ });
+
+ await this.runCoreWorkflowMigration({
+ workspaceId,
+ failureMessage:
+ 'Multiple validation errors occurred while writing workflow version content',
+ operations: {
+ workflowVersion: {
+ flatEntityToCreate: [],
+ flatEntityToDelete: [],
+ flatEntityToUpdate: [
+ {
+ ...flatWorkflowVersion,
+ triggers: isDefined(trigger) ? [trigger] : null,
+ steps,
+ },
+ ],
+ },
+ },
+ });
+
+ await this.workspaceOrmManager.executeInWorkspaceContext(async () => {
+ await this.workspaceOrmManager.runInWorkspaceTransaction(
+ async (transactionScope) => {
+ const mirrorUpdateResult = await transactionScope
+ .getRepository<WorkflowVersionWorkspaceEntity>(
+ 'workflowVersion',
+ {
+ shouldBypassPermissionChecks: true,
+ },
+ )
+ .update({ coreWorkflowVersionId }, { trigger, steps });
+
+ assertExactlyOneMirrorRowWasWritten({
+ affected: mirrorUpdateResult.affected,
+ coreWorkflowVersionId,
+ });
+ },
+ );
+ }, buildSystemAuthContext(workspaceId));
+ },
+ );
try {
await this.workflowVersionCoreSyncService.invalidateAutomatedTriggerMaps(
@@ -182,18 +269,58 @@ export class CoreWorkflowVersionWriteService {
}
}
+ private async withCoreWorkflowVersionEditLock<T>(
+ coreWorkflowVersionId: string,
+ run: () => Promise<T>,
+ ): Promise<T> {
+ const lockKey = `core-workflow-version-edit-${coreWorkflowVersionId}`;
+ const queryRunner = this.coreDataSource.createQueryRunner();
+
+ try {
+ await queryRunner.connect();
+ // Transaction scoped, so the lock is released by the commit below and by
+ // any failure that rolls back, including a connection that dies holding it.
+ await queryRunner.startTransaction();
+
+ const [lockResult] = (await queryRunner.query(
+ 'SELECT pg_try_advisory_xact_lock(hashtextextended($1, 0)) AS acquired',
+ [lockKey],
+ )) as { acquired: boolean }[];
+
+ if (!lockResult?.acquired) {
+ throw new WorkflowQueryValidationException(
+ `Core workflow version '${coreWorkflowVersionId}' is being edited concurrently`,
+ WorkflowQueryValidationExceptionCode.FORBIDDEN,
+ {
+ userFriendlyMessage: msg`Workflow version changed, please reload and retry`,
+ },
+ );
+ }
+
+ const result = await run();
+
+ await queryRunner.commitTransaction();
+
+ return result;
+ } finally {
+ if (queryRunner.isTransactionActive) {
+ await queryRunner.rollbackTransaction();
+ }
+
+ await queryRunner.release();
+ }
+ }
+
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 }> {
@@ -221,26 +348,46 @@ export class CoreWorkflowVersionWriteService {
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,
+ const { workspaceCustomFlatApplication } =
+ await this.applicationService.findWorkspaceTwentyStandardAndCustomApplicationOrThrow(
+ { workspaceId },
+ );
+
+ const createdAt = new Date().toISOString();
+
+ await this.runCoreWorkflowMigration({
+ workspaceId,
+ applicationUniversalIdentifier:
+ workspaceCustomFlatApplication.universalIdentifier,
+ failureMessage:
+ 'Multiple validation errors occurred while creating workflow version draft',
+ operations: {
+ workflowVersion: {
+ flatEntityToCreate: [
+ {
+ id: coreWorkflowVersionId,
+ universalIdentifier: uuidv4(),
+ workflowId: workspaceWorkflowId,
coreWorkflowId,
- isDefined(trigger) ? JSON.stringify([trigger]) : null,
- isDefined(steps) ? JSON.stringify(steps) : null,
- uuidv4(),
- applicationId,
+ triggers: isDefined(trigger) ? [trigger] : null,
+ steps: steps ?? null,
+ status: CoreWorkflowVersionStatus.DRAFT,
workspaceWorkflowVersionId,
- ],
- );
+ applicationUniversalIdentifier:
+ workspaceCustomFlatApplication.universalIdentifier,
+ createdAt,
+ updatedAt: createdAt,
+ },
+ ],
+ flatEntityToDelete: [],
+ flatEntityToUpdate: [],
+ },
+ },
+ });
+ await this.workspaceOrmManager.executeInWorkspaceContext(async () => {
+ await this.workspaceOrmManager.runInWorkspaceTransaction(
+ async (transactionScope) => {
await transactionScope
.getRepository<WorkflowVersionWorkspaceEntity>('workflowVersion', {
shouldBypassPermissionChecks: true,
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 7c0d2ce7e82..ac8d99b897b 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
@@ -2,12 +2,24 @@ import { Injectable, Logger } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { isNonEmptyString } from '@sniptt/guards';
+import { WorkflowVisibility } from 'twenty-shared/types';
import { STANDARD_OBJECTS } from 'twenty-shared/metadata';
-import { isDefined } from 'twenty-shared/utils';
+import { isDefined, isNonEmptyArray } from 'twenty-shared/utils';
import { In, Repository } from 'typeorm';
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 {
+ CoreWorkflowMetadataException,
+ CoreWorkflowMetadataExceptionCode,
+} from 'src/engine/core-modules/workflow/exceptions/core-workflow-metadata.exception';
+import { type AllFlatEntityOperationByMetadataName } from 'src/engine/metadata-modules/flat-entity/types/flat-entity-to-create-delete-update.type';
+import { WorkspaceMigrationBuilderException } from 'src/engine/workspace-manager/workspace-migration/exceptions/workspace-migration-builder-exception';
+import { WorkspaceMigrationValidateBuildAndRunService } from 'src/engine/workspace-manager/workspace-migration/services/workspace-migration-validate-build-and-run-service';
+import { type UniversalFlatWorkflow } from 'src/engine/workspace-manager/workspace-migration/universal-flat-entity/types/universal-flat-workflow.type';
+import { WorkspaceManyOrAllFlatEntityMapsCacheService } from 'src/engine/metadata-modules/flat-entity/services/workspace-many-or-all-flat-entity-maps-cache.service';
+import { findFlatEntityByIdInFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-id-in-flat-entity-maps.util';
import { WorkspaceEntity } from 'src/engine/core-modules/workspace/workspace.entity';
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';
@@ -29,8 +41,48 @@ export class WorkflowCoreSyncService {
private readonly workspaceRepository: Repository<WorkspaceEntity>,
private readonly workspaceOrmManager: WorkspaceOrmManager,
private readonly workspaceCacheService: WorkspaceCacheService,
+ private readonly workspaceMigrationValidateBuildAndRunService: WorkspaceMigrationValidateBuildAndRunService,
+ private readonly applicationService: ApplicationService,
+ private readonly flatEntityMapsCacheService: WorkspaceManyOrAllFlatEntityMapsCacheService,
) {}
+ private async runCoreWorkflowMigration({
+ workspaceId,
+ failureMessage,
+ operations,
+ applicationUniversalIdentifier,
+ }: {
+ workspaceId: string;
+ failureMessage: string;
+ operations: AllFlatEntityOperationByMetadataName;
+ applicationUniversalIdentifier?: string;
+ }): Promise<void> {
+ const universalIdentifier =
+ applicationUniversalIdentifier ??
+ (
+ await this.applicationService.findWorkspaceTwentyStandardAndCustomApplicationOrThrow(
+ { workspaceId },
+ )
+ ).workspaceCustomFlatApplication.universalIdentifier;
+
+ const validateAndBuildResult =
+ await this.workspaceMigrationValidateBuildAndRunService.validateBuildAndRunWorkspaceMigration(
+ {
+ allFlatEntityOperationByMetadataName: operations,
+ workspaceId,
+ isSystemBuild: false,
+ applicationUniversalIdentifier: universalIdentifier,
+ },
+ );
+
+ if (validateAndBuildResult.status === 'fail') {
+ throw new WorkspaceMigrationBuilderException(
+ validateAndBuildResult,
+ failureMessage,
+ );
+ }
+ }
+
async upsertToCore(
workspaceId: string,
workspaceWorkflowIds: string[],
@@ -56,7 +108,10 @@ export class WorkflowCoreSyncService {
return;
}
- const applicationId = await this.getCustomApplicationIdOrThrow(workspaceId);
+ const { workspaceCustomFlatApplication } =
+ await this.applicationService.findWorkspaceTwentyStandardAndCustomApplicationOrThrow(
+ { workspaceId },
+ );
const workspaceWorkflowIdByOwnedCoreWorkflowId =
await this.resolveWorkspaceWorkflowIdByOwnedCoreWorkflowId(
@@ -111,11 +166,91 @@ export class WorkflowCoreSyncService {
: null,
createdAt: new Date(workflow.createdAt),
universalIdentifier: uuidv4(),
- applicationId,
};
});
- await this.coreWorkflowRepository.upsert(workspaceId, coreRows, ['id']);
+ const { flatWorkflowMaps } =
+ await this.flatEntityMapsCacheService.getOrRecomputeManyOrAllFlatEntityMaps(
+ { workspaceId, flatMapsKeys: ['flatWorkflowMaps'] },
+ );
+
+ const flatWorkflowsToCreate: (UniversalFlatWorkflow & { id?: string })[] =
+ [];
+ const flatWorkflowsToUpdate: UniversalFlatWorkflow[] = [];
+
+ // The cache decides which rows exist, so a stale map would send a persisted
+ // id down the create branch and hit the primary key. The table decides.
+ const persistedCoreWorkflowIds = new Set(
+ (
+ await this.coreWorkflowRepository.find(workspaceId, {
+ where: { id: In(coreRows.map(({ id }) => id)) },
+ select: { id: true },
+ })
+ ).map(({ id }) => id),
+ );
+
+ for (const coreRow of coreRows) {
+ const existingFlatWorkflow = persistedCoreWorkflowIds.has(coreRow.id)
+ ? findFlatEntityByIdInFlatEntityMaps({
+ flatEntityId: coreRow.id,
+ flatEntityMaps: flatWorkflowMaps,
+ })
+ : undefined;
+
+ if (
+ persistedCoreWorkflowIds.has(coreRow.id) &&
+ !isDefined(existingFlatWorkflow)
+ ) {
+ throw new CoreWorkflowMetadataException(
+ `Core workflow ${coreRow.id} is persisted but missing from the flat entity maps`,
+ CoreWorkflowMetadataExceptionCode.WORKFLOW_NOT_FOUND,
+ );
+ }
+
+ const flatWorkflow: UniversalFlatWorkflow = {
+ universalIdentifier: coreRow.universalIdentifier,
+ name: coreRow.name,
+ workspaceWorkflowId: coreRow.workspaceWorkflowId,
+ lastPublishedVersionId: coreRow.lastPublishedVersionId,
+ lastPublishedCoreWorkflowVersionId:
+ coreRow.lastPublishedCoreWorkflowVersionId,
+ visibility: WorkflowVisibility.WORKSPACE,
+ createdByUserWorkspaceId: null,
+ applicationUniversalIdentifier:
+ workspaceCustomFlatApplication.universalIdentifier,
+ createdAt: coreRow.createdAt.toISOString(),
+ updatedAt: new Date().toISOString(),
+ };
+
+ if (isDefined(existingFlatWorkflow)) {
+ flatWorkflowsToUpdate.push({
+ ...existingFlatWorkflow,
+ ...flatWorkflow,
+ universalIdentifier: existingFlatWorkflow.universalIdentifier,
+ createdAt: existingFlatWorkflow.createdAt,
+ visibility: existingFlatWorkflow.visibility,
+ createdByUserWorkspaceId:
+ existingFlatWorkflow.createdByUserWorkspaceId,
+ });
+ } else {
+ flatWorkflowsToCreate.push({ ...flatWorkflow, id: coreRow.id });
+ }
+ }
+
+ await this.runCoreWorkflowMigration({
+ workspaceId,
+ applicationUniversalIdentifier:
+ workspaceCustomFlatApplication.universalIdentifier,
+ failureMessage:
+ 'Multiple validation errors occurred while mirroring workflows to core',
+ operations: {
+ workflow: {
+ flatEntityToCreate: flatWorkflowsToCreate,
+ flatEntityToDelete: [],
+ flatEntityToUpdate: flatWorkflowsToUpdate,
+ },
+ },
+ });
await this.writeBackCoreWorkflowIds(
workspaceId,
@@ -128,6 +263,13 @@ export class WorkflowCoreSyncService {
workspaceWorkflowIds: string[],
): Promise<void> {
const schema = getWorkspaceSchemaName(workspaceId);
+ const coreWorkflowIdsToDelete: string[] = [];
+ const coreWorkflowUpdates: {
+ coreWorkflowId: string;
+ name: string | null;
+ lastPublishedVersionId: string | null;
+ lastPublishedCoreWorkflowVersionId: string | null;
+ }[] = [];
await this.workspaceOrmManager.executeInWorkspaceContext(async () => {
await this.workspaceOrmManager.runInWorkspaceTransaction(
@@ -149,9 +291,14 @@ export class WorkflowCoreSyncService {
const workflow = workflows[0];
if (!isDefined(workflow) || isDefined(workflow.deletedAt)) {
- await transactionScope.executeRawQuery(
- `DELETE FROM core."workflow" WHERE "workspaceId" = $1 AND "workspaceWorkflowId" = $2`,
- [workspaceId, workspaceWorkflowId],
+ const orphanCoreWorkflows =
+ (await transactionScope.executeRawQuery(
+ `SELECT id FROM core."workflow" WHERE "workspaceId" = $1 AND "workspaceWorkflowId" = $2`,
+ [workspaceId, workspaceWorkflowId],
+ )) as { id: string }[];
+
+ coreWorkflowIdsToDelete.push(
+ ...orphanCoreWorkflows.map(({ id }) => id),
);
continue;
}
@@ -188,22 +335,93 @@ export class WorkflowCoreSyncService {
coreWorkflowVersionId = versions[0].id;
}
- await transactionScope.executeRawQuery(
- `UPDATE core."workflow" SET "name" = $3, "lastPublishedVersionId" = $4, "lastPublishedCoreWorkflowVersionId" = $5, "updatedAt" = now() WHERE id = $1 AND "workspaceId" = $2`,
- [
- coreWorkflowId,
- workspaceId,
- workflow.name ?? null,
- isNonEmptyString(workflow.lastPublishedVersionId)
- ? workflow.lastPublishedVersionId
- : null,
- coreWorkflowVersionId,
- ],
- );
+ coreWorkflowUpdates.push({
+ coreWorkflowId,
+ name: workflow.name ?? null,
+ lastPublishedVersionId: isNonEmptyString(
+ workflow.lastPublishedVersionId,
+ )
+ ? workflow.lastPublishedVersionId
+ : null,
+ lastPublishedCoreWorkflowVersionId: coreWorkflowVersionId,
+ });
}
},
);
}, buildSystemAuthContext(workspaceId));
+
+ // The locks above only cover the workspace rows, so the core writes they
+ // decided on run once that transaction has committed, through the runner
+ // like every other core write.
+ await this.applyReconciledCoreWorkflowUpdates(
+ workspaceId,
+ coreWorkflowUpdates,
+ );
+
+ await this.deleteFromCore(workspaceId, coreWorkflowIdsToDelete);
+ }
+
+ private async applyReconciledCoreWorkflowUpdates(
+ workspaceId: string,
+ coreWorkflowUpdates: {
+ coreWorkflowId: string;
+ name: string | null;
+ lastPublishedVersionId: string | null;
+ lastPublishedCoreWorkflowVersionId: string | null;
+ }[],
+ ): Promise<void> {
+ if (!isNonEmptyArray(coreWorkflowUpdates)) {
+ return;
+ }
+
+ const { flatWorkflowMaps } =
+ await this.flatEntityMapsCacheService.getOrRecomputeManyOrAllFlatEntityMaps(
+ { workspaceId, flatMapsKeys: ['flatWorkflowMaps'] },
+ );
+
+ const { workspaceCustomFlatApplication } =
+ await this.applicationService.findWorkspaceTwentyStandardAndCustomApplicationOrThrow(
+ { workspaceId },
+ );
+
+ const flatWorkflowsToUpdate = coreWorkflowUpdates.flatMap(
+ ({ coreWorkflowId, ...coreWorkflowUpdate }) => {
+ const existingFlatWorkflow = findFlatEntityByIdInFlatEntityMaps({
+ flatEntityId: coreWorkflowId,
+ flatEntityMaps: flatWorkflowMaps,
+ });
+
+ if (!isDefined(existingFlatWorkflow)) {
+ throw new CoreWorkflowMetadataException(
+ `Core workflow ${coreWorkflowId} is persisted but missing from the flat entity maps`,
+ CoreWorkflowMetadataExceptionCode.WORKFLOW_NOT_FOUND,
+ );
+ }
+
+ return [
+ {
+ ...existingFlatWorkflow,
+ ...coreWorkflowUpdate,
+ updatedAt: new Date().toISOString(),
+ },
+ ];
+ },
+ );
+
+ await this.runCoreWorkflowMigration({
+ workspaceId,
+ applicationUniversalIdentifier:
+ workspaceCustomFlatApplication.universalIdentifier,
+ failureMessage:
+ 'Multiple validation errors occurred while reconciling workflows with the workspace mirror',
+ operations: {
+ workflow: {
+ flatEntityToCreate: [],
+ flatEntityToDelete: [],
+ flatEntityToUpdate: flatWorkflowsToUpdate,
+ },
+ },
+ });
}
private async resolveCoreVersionIdByWorkspaceVersionId(
@@ -272,8 +490,57 @@ export class WorkflowCoreSyncService {
return;
}
- await this.coreWorkflowRepository.delete(workspaceId, {
- id: In(coreWorkflowIds),
+ const { flatWorkflowMaps } =
+ await this.flatEntityMapsCacheService.getOrRecomputeManyOrAllFlatEntityMaps(
+ { workspaceId, flatMapsKeys: ['flatWorkflowMaps'] },
+ );
+
+ const resolvedFlatWorkflows = coreWorkflowIds.map((coreWorkflowId) =>
+ findFlatEntityByIdInFlatEntityMaps({
+ flatEntityId: coreWorkflowId,
+ flatEntityMaps: flatWorkflowMaps,
+ }),
+ );
+
+ const missingCoreWorkflowIds = coreWorkflowIds.filter(
+ (_, index) => !isDefined(resolvedFlatWorkflows[index]),
+ );
+
+ // The dual-write listener deletes the same rows when the workspace mirror is
+ // soft-deleted, so an id that is gone from both the cache and the table is an
+ // idempotent no-op. An id still in the table is a stale cache and must fail
+ // rather than leave an orphan that still reads and still broadcasts.
+ if (missingCoreWorkflowIds.length > 0) {
+ const stillPersisted = await this.coreWorkflowRepository.find(
+ workspaceId,
+ { where: { id: In(missingCoreWorkflowIds) }, select: { id: true } },
+ );
+
+ 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:
+ 'Multiple validation errors occurred while deleting workflows',
+ operations: {
+ workflow: {
+ flatEntityToCreate: [],
+ flatEntityToDelete: flatWorkflowsToDelete,
+ flatEntityToUpdate: [],
+ },
+ },
});
}
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 b4755c16e6f..8e451c98697 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
@@ -1,4 +1,13 @@
import { Injectable, Logger } from '@nestjs/common';
+
+import { ApplicationService } from 'src/engine/core-modules/application/application.service';
+import { toCoreWorkflowVersionStatus } from 'src/engine/core-modules/workflow/utils/workflow-version-status.util';
+import { WorkspaceManyOrAllFlatEntityMapsCacheService } from 'src/engine/metadata-modules/flat-entity/services/workspace-many-or-all-flat-entity-maps-cache.service';
+import { type AllFlatEntityOperationByMetadataName } from 'src/engine/metadata-modules/flat-entity/types/flat-entity-to-create-delete-update.type';
+import { findFlatEntityByIdInFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-id-in-flat-entity-maps.util';
+import { type UniversalFlatWorkflowVersion } from 'src/engine/workspace-manager/workspace-migration/universal-flat-entity/types/universal-flat-workflow-version.type';
+import { WorkspaceMigrationBuilderException } from 'src/engine/workspace-manager/workspace-migration/exceptions/workspace-migration-builder-exception';
+import { WorkspaceMigrationValidateBuildAndRunService } from 'src/engine/workspace-manager/workspace-migration/services/workspace-migration-validate-build-and-run-service';
import { InjectRepository } from '@nestjs/typeorm';
import { isNonEmptyString } from '@sniptt/guards';
@@ -11,6 +20,10 @@ import {
WorkflowVersionEntity,
WorkflowVersionStatus,
} from 'src/engine/core-modules/workflow/entities/workflow-version.entity';
+import {
+ CoreWorkflowMetadataException,
+ CoreWorkflowMetadataExceptionCode,
+} from 'src/engine/core-modules/workflow/exceptions/core-workflow-metadata.exception';
import { RecordPositionService } from 'src/engine/core-modules/record-position/services/record-position.service';
import { hasCoreWorkflowWorkspaceVersionIdColumn } from 'src/engine/core-modules/workflow/utils/has-core-workflow-workspace-version-id-column.util';
import { hasCoreWorkflowWorkspaceWorkflowIdColumn } from 'src/engine/core-modules/workflow/utils/has-core-workflow-workspace-workflow-id-column.util';
@@ -45,10 +58,50 @@ export class WorkflowVersionCoreSyncService {
private readonly workspaceCacheService: WorkspaceCacheService,
private readonly recordPositionService: RecordPositionService,
private readonly workflowMetadataReadService: WorkflowMetadataReadService,
+ private readonly workspaceMigrationValidateBuildAndRunService: WorkspaceMigrationValidateBuildAndRunService,
+ private readonly flatEntityMapsCacheService: WorkspaceManyOrAllFlatEntityMapsCacheService,
+ private readonly applicationService: ApplicationService,
@InjectCacheStorage(CacheStorageNamespace.ModuleWorkflow)
private readonly cacheStorageService: CacheStorageService,
) {}
+ private async runCoreWorkflowMigration({
+ workspaceId,
+ failureMessage,
+ operations,
+ applicationUniversalIdentifier,
+ }: {
+ workspaceId: string;
+ failureMessage: string;
+ operations: AllFlatEntityOperationByMetadataName;
+ applicationUniversalIdentifier?: string;
+ }): Promise<void> {
+ const universalIdentifier =
+ applicationUniversalIdentifier ??
+ (
+ await this.applicationService.findWorkspaceTwentyStandardAndCustomApplicationOrThrow(
+ { workspaceId },
+ )
+ ).workspaceCustomFlatApplication.universalIdentifier;
+
+ const validateAndBuildResult =
+ await this.workspaceMigrationValidateBuildAndRunService.validateBuildAndRunWorkspaceMigration(
+ {
+ allFlatEntityOperationByMetadataName: operations,
+ workspaceId,
+ isSystemBuild: false,
+ applicationUniversalIdentifier: universalIdentifier,
+ },
+ );
+
+ if (validateAndBuildResult.status === 'fail') {
+ throw new WorkspaceMigrationBuilderException(
+ validateAndBuildResult,
+ failureMessage,
+ );
+ }
+ }
+
async upsertToCore(
workspaceId: string,
workflowVersions: WorkflowVersionWorkspaceEntity[],
@@ -57,8 +110,6 @@ export class WorkflowVersionCoreSyncService {
return;
}
- const applicationId = await this.getCustomApplicationIdOrThrow(workspaceId);
-
const coreWorkflowIdByWorkflowId =
await this.resolveCoreWorkflowIdByWorkflowId(
workspaceId,
@@ -105,15 +156,96 @@ export class WorkflowVersionCoreSyncService {
? [workflowVersion.trigger]
: null,
steps: workflowVersion.steps ?? null,
- status: workflowVersion.status as unknown as WorkflowVersionStatus,
+ status: toCoreWorkflowVersionStatus(workflowVersion.status),
universalIdentifier: uuidv4(),
- applicationId,
};
});
- await this.coreWorkflowVersionRepository.upsert(workspaceId, coreRows, [
- 'id',
- ]);
+ const { workspaceCustomFlatApplication } =
+ await this.applicationService.findWorkspaceTwentyStandardAndCustomApplicationOrThrow(
+ { workspaceId },
+ );
+
+ const { flatWorkflowVersionMaps } =
+ await this.flatEntityMapsCacheService.getOrRecomputeManyOrAllFlatEntityMaps(
+ { workspaceId, flatMapsKeys: ['flatWorkflowVersionMaps'] },
+ );
+
+ // The table decides create vs update: a stale map would send a persisted id
+ // down the create branch and into the primary key.
+ const persistedCoreVersionIds = new Set(
+ (
+ await this.coreWorkflowVersionRepository.find(workspaceId, {
+ where: { id: In(coreRows.map(({ id }) => id)) },
+ select: { id: true },
+ })
+ ).map(({ id }) => id),
+ );
+
+ const timestamp = new Date().toISOString();
+ const flatVersionsToCreate: (UniversalFlatWorkflowVersion & {
+ id?: string;
+ })[] = [];
+ const flatVersionsToUpdate: UniversalFlatWorkflowVersion[] = [];
+
+ for (const coreRow of coreRows) {
+ const existingFlatWorkflowVersion = persistedCoreVersionIds.has(
+ coreRow.id,
+ )
+ ? findFlatEntityByIdInFlatEntityMaps({
+ flatEntityId: coreRow.id,
+ flatEntityMaps: flatWorkflowVersionMaps,
+ })
+ : undefined;
+
+ if (
+ persistedCoreVersionIds.has(coreRow.id) &&
+ !isDefined(existingFlatWorkflowVersion)
+ ) {
+ throw new CoreWorkflowMetadataException(
+ `Core workflow version ${coreRow.id} is persisted but missing from the flat entity maps`,
+ CoreWorkflowMetadataExceptionCode.WORKFLOW_VERSION_NOT_FOUND,
+ );
+ }
+
+ const flatWorkflowVersion: UniversalFlatWorkflowVersion & {
+ id: string;
+ } = {
+ ...coreRow,
+ coreWorkflowId:
+ coreRow.coreWorkflowId ??
+ existingFlatWorkflowVersion?.coreWorkflowId ??
+ null,
+ universalIdentifier:
+ existingFlatWorkflowVersion?.universalIdentifier ??
+ coreRow.universalIdentifier,
+ applicationUniversalIdentifier:
+ workspaceCustomFlatApplication.universalIdentifier,
+ createdAt: existingFlatWorkflowVersion?.createdAt ?? timestamp,
+ updatedAt: timestamp,
+ };
+
+ if (isDefined(existingFlatWorkflowVersion)) {
+ flatVersionsToUpdate.push(flatWorkflowVersion);
+ } else {
+ flatVersionsToCreate.push(flatWorkflowVersion);
+ }
+ }
+
+ await this.runCoreWorkflowMigration({
+ workspaceId,
+ applicationUniversalIdentifier:
+ workspaceCustomFlatApplication.universalIdentifier,
+ failureMessage:
+ 'Multiple validation errors occurred while mirroring workflow versions to core',
+ operations: {
+ workflowVersion: {
+ flatEntityToCreate: flatVersionsToCreate,
+ flatEntityToDelete: [],
+ flatEntityToUpdate: flatVersionsToUpdate,
+ },
+ },
+ });
await this.writeBackCoreVersionIds(
workspaceId,
@@ -165,8 +297,9 @@ export class WorkflowVersionCoreSyncService {
},
);
- await this.coreWorkflowVersionRepository.delete(workspaceId, {
- id: In(coreWorkflowVersionIds),
+ await this.deleteCoreVersionsThroughMigration({
+ workspaceId,
+ coreWorkflowVersionIds,
});
await this.invalidateAutomatedTriggerMaps(workspaceId);
@@ -193,6 +326,75 @@ export class WorkflowVersionCoreSyncService {
}
}
+ private async deleteCoreVersionsThroughMigration({
+ workspaceId,
+ coreWorkflowVersionIds,
+ }: {
+ workspaceId: string;
+ coreWorkflowVersionIds: string[];
+ }): Promise<void> {
+ if (coreWorkflowVersionIds.length === 0) {
+ return;
+ }
+
+ const { flatWorkflowVersionMaps } =
+ await this.flatEntityMapsCacheService.getOrRecomputeManyOrAllFlatEntityMaps(
+ { workspaceId, flatMapsKeys: ['flatWorkflowVersionMaps'] },
+ );
+
+ const resolvedFlatVersions = coreWorkflowVersionIds.map(
+ (coreWorkflowVersionId) =>
+ findFlatEntityByIdInFlatEntityMaps({
+ flatEntityId: coreWorkflowVersionId,
+ flatEntityMaps: flatWorkflowVersionMaps,
+ }),
+ );
+
+ const missingCoreWorkflowVersionIds = coreWorkflowVersionIds.filter(
+ (_, index) => !isDefined(resolvedFlatVersions[index]),
+ );
+
+ // The dual-write listener deletes the same ids when the mirror is soft
+ // deleted, so an id gone from both the cache and the table is an idempotent
+ // no-op. An id still in the table is a stale cache and must fail rather than
+ // leave an orphan that still reads and still broadcasts.
+ if (missingCoreWorkflowVersionIds.length > 0) {
+ const stillPersisted = await this.coreWorkflowVersionRepository.find(
+ workspaceId,
+ {
+ where: { id: In(missingCoreWorkflowVersionIds) },
+ select: { id: true },
+ },
+ );
+
+ if (stillPersisted.length > 0) {
+ throw new CoreWorkflowMetadataException(
+ `Core workflow versions ${stillPersisted.map(({ id }) => id).join(', ')} are persisted but missing from the flat entity maps`,
+ CoreWorkflowMetadataExceptionCode.WORKFLOW_VERSION_NOT_FOUND,
+ );
+ }
+ }
+
+ const flatVersionsToDelete = resolvedFlatVersions.filter(isDefined);
+
+ if (flatVersionsToDelete.length === 0) {
+ return;
+ }
+
+ await this.runCoreWorkflowMigration({
+ workspaceId,
+ failureMessage:
+ 'Multiple validation errors occurred while deleting workflow versions',
+ operations: {
+ workflowVersion: {
+ flatEntityToCreate: [],
+ flatEntityToDelete: flatVersionsToDelete,
+ flatEntityToUpdate: [],
+ },
+ },
+ });
+ }
+
async findCoreVersionById(
workspaceId: string,
coreWorkflowVersionId: string,
@@ -338,6 +540,17 @@ export class WorkflowVersionCoreSyncService {
);
}
+ // This writer stays on raw SQL because it runs inside a transaction its
+ // caller owns and relies on the locks taken above, so the flat entity maps
+ // have to be refreshed by hand or the next migration write diffs against a
+ // cache that no longer matches the table.
+ transactionScope.afterCommit(async () => {
+ await this.flatEntityMapsCacheService.invalidateFlatEntityMaps({
+ workspaceId,
+ flatMapsKeys: ['flatWorkflowVersionMaps'],
+ });
+ });
+
return { coreWorkflowVersionId };
}
@@ -593,8 +806,9 @@ export class WorkflowVersionCoreSyncService {
},
);
- await this.coreWorkflowVersionRepository.delete(workspaceId, {
- workflowId: In(workflowIds),
+ await this.deleteCoreVersionsThroughMigration({
+ workspaceId,
+ coreWorkflowVersionIds: deletedVersions.map(({ id }) => id),
});
await this.invalidateAutomatedTriggerMaps(workspaceId);
diff --git a/packages/twenty-server/src/engine/core-modules/workflow/utils/workflow-version-status.util.ts b/packages/twenty-server/src/engine/core-modules/workflow/utils/workflow-version-status.util.ts
new file mode 100644
index 00000000000..a7a82515249
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/workflow/utils/workflow-version-status.util.ts
@@ -0,0 +1,32 @@
+import { WorkflowVersionStatus as CoreWorkflowVersionStatus } from 'src/engine/core-modules/workflow/entities/workflow-version.entity';
+import { WorkflowVersionStatus as WorkspaceWorkflowVersionStatus } from 'src/modules/workflow/common/standard-objects/workflow-version.workspace-entity';
+
+const CORE_STATUS_BY_WORKSPACE_STATUS: Record<
+ WorkspaceWorkflowVersionStatus,
+ CoreWorkflowVersionStatus
+> = {
+ [WorkspaceWorkflowVersionStatus.DRAFT]: CoreWorkflowVersionStatus.DRAFT,
+ [WorkspaceWorkflowVersionStatus.ACTIVE]: CoreWorkflowVersionStatus.ACTIVE,
+ [WorkspaceWorkflowVersionStatus.DEACTIVATED]:
+ CoreWorkflowVersionStatus.DEACTIVATED,
+ [WorkspaceWorkflowVersionStatus.ARCHIVED]: CoreWorkflowVersionStatus.ARCHIVED,
+};
+
+const WORKSPACE_STATUS_BY_CORE_STATUS: Record<
+ CoreWorkflowVersionStatus,
+ WorkspaceWorkflowVersionStatus
+> = {
+ [CoreWorkflowVersionStatus.DRAFT]: WorkspaceWorkflowVersionStatus.DRAFT,
+ [CoreWorkflowVersionStatus.ACTIVE]: WorkspaceWorkflowVersionStatus.ACTIVE,
+ [CoreWorkflowVersionStatus.DEACTIVATED]:
+ WorkspaceWorkflowVersionStatus.DEACTIVATED,
+ [CoreWorkflowVersionStatus.ARCHIVED]: WorkspaceWorkflowVersionStatus.ARCHIVED,
+};
+
+export const toCoreWorkflowVersionStatus = (
+ status: WorkspaceWorkflowVersionStatus,
+): CoreWorkflowVersionStatus => CORE_STATUS_BY_WORKSPACE_STATUS[status];
+
+export const toWorkspaceWorkflowVersionStatus = (
+ status: CoreWorkflowVersionStatus,
+): WorkspaceWorkflowVersionStatus => WORKSPACE_STATUS_BY_CORE_STATUS[status];
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 734a296722c..4c654f8f925 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
@@ -25,7 +25,6 @@ import { WorkspaceEntity } from 'src/engine/core-modules/workspace/workspace.ent
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';
@@ -59,7 +58,6 @@ import { WorkflowTriggerModule } from 'src/modules/workflow/workflow-trigger/wor
ToolModule,
LogicFunctionModule,
CodeStepBuildModule,
- WorkspaceManyOrAllFlatEntityMapsCacheModule,
ConnectedAccountMetadataModule,
WorkflowVersionCoreModule,
WorkflowVersionValidationModule,
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 7b96d811809..47625ca30ff 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,7 +1,12 @@
import { Module } from '@nestjs/common';
+
+import { ApplicationModule } from 'src/engine/core-modules/application/application.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';
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 { WorkspaceEntity } from 'src/engine/core-modules/workspace/workspace.entity';
import { provideWorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/provide-workspace-scoped-repository';
@@ -9,8 +14,12 @@ import { WorkspaceCacheModule } from 'src/engine/workspace-cache/workspace-cache
@Module({
imports: [
+ ApplicationModule,
+ WorkspaceMigrationModule,
+ WorkspaceManyOrAllFlatEntityMapsCacheModule,
TypeOrmModule.forFeature([WorkflowEntity, WorkspaceEntity]),
WorkspaceCacheModule,
+ FlatWorkflowModule,
],
providers: [
WorkflowCoreSyncService,
diff --git a/packages/twenty-server/src/engine/core-modules/workflow/workflow-version-core.module.ts b/packages/twenty-server/src/engine/core-modules/workflow/workflow-version-core.module.ts
index 1fe37ee526b..3a3bffb42b1 100644
--- a/packages/twenty-server/src/engine/core-modules/workflow/workflow-version-core.module.ts
+++ b/packages/twenty-server/src/engine/core-modules/workflow/workflow-version-core.module.ts
@@ -1,9 +1,14 @@
import { Module } from '@nestjs/common';
+import { ApplicationModule } from 'src/engine/core-modules/application/application.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 { RecordPositionModule } from 'src/engine/core-modules/record-position/record-position.module';
import { TypeOrmModule } from '@nestjs/typeorm';
import { WorkflowVersionEntity } from 'src/engine/core-modules/workflow/entities/workflow-version.entity';
+import { FlatWorkflowVersionModule } from 'src/engine/metadata-modules/flat-workflow-version/flat-workflow-version.module';
import { WorkflowVersionCoreSyncService } from 'src/engine/core-modules/workflow/services/workflow-version-core-sync.service';
import { WorkspaceWorkflowAutomatedTriggerMapCacheService } from 'src/engine/core-modules/workflow/services/workspace-workflow-automated-trigger-map-cache.service';
import { WorkspaceEntity } from 'src/engine/core-modules/workspace/workspace.entity';
@@ -14,10 +19,14 @@ import { CacheStorageModule } from 'src/engine/core-modules/cache-storage/cache-
@Module({
imports: [
+ ApplicationModule,
CacheStorageModule,
+ WorkspaceMigrationModule,
+ WorkspaceManyOrAllFlatEntityMapsCacheModule,
RecordPositionModule,
TypeOrmModule.forFeature([WorkflowVersionEntity, WorkspaceEntity]),
WorkspaceCacheModule,
+ FlatWorkflowVersionModule,
WorkflowMetadataReadModule,
],
providers: [
diff --git a/packages/twenty-server/src/engine/metadata-modules/flat-entity/constant/__tests__/__snapshots__/all-universal-flat-entity-properties-to-compare-and-stringify.constant.spec.ts.snap b/packages/twenty-server/src/engine/metadata-modules/flat-entity/constant/__tests__/__snapshots__/all-universal-flat-entity-properties-to-compare-and-stringify.constant.spec.ts.snap
index 4f06647e9a4..becce8715fc 100644
--- a/packages/twenty-server/src/engine/metadata-modules/flat-entity/constant/__tests__/__snapshots__/all-universal-flat-entity-properties-to-compare-and-stringify.constant.spec.ts.snap
+++ b/packages/twenty-server/src/engine/metadata-modules/flat-entity/constant/__tests__/__snapshots__/all-universal-flat-entity-properties-to-compare-and-stringify.constant.spec.ts.snap
@@ -477,5 +477,26 @@ exports[`ALL_UNIVERSAL_FLAT_ENTITY_PROPERTIES_TO_COMPARE_AND_STRINGIFY should ma
"operations",
],
},
+ "workflow": {
+ "propertiesToCompare": [
+ "name",
+ "visibility",
+ "lastPublishedVersionId",
+ "lastPublishedCoreWorkflowVersionId",
+ ],
+ "propertiesToStringify": [],
+ },
+ "workflowVersion": {
+ "propertiesToCompare": [
+ "status",
+ "triggers",
+ "steps",
+ "coreWorkflowId",
+ ],
+ "propertiesToStringify": [
+ "triggers",
+ "steps",
+ ],
+ },
}
`;
diff --git a/packages/twenty-server/src/engine/metadata-modules/flat-entity/constant/__tests__/__snapshots__/overridable-and-translatable-properties.constant.spec.ts.snap b/packages/twenty-server/src/engine/metadata-modules/flat-entity/constant/__tests__/__snapshots__/overridable-and-translatable-properties.constant.spec.ts.snap
index 0d520d0e5aa..9e531ca0520 100644
--- a/packages/twenty-server/src/engine/metadata-modules/flat-entity/constant/__tests__/__snapshots__/overridable-and-translatable-properties.constant.spec.ts.snap
+++ b/packages/twenty-server/src/engine/metadata-modules/flat-entity/constant/__tests__/__snapshots__/overridable-and-translatable-properties.constant.spec.ts.snap
@@ -106,6 +106,8 @@ exports[`registry-derived override property maps derives the overridable propert
"viewGroup": [],
"viewSort": [],
"webhook": [],
+ "workflow": [],
+ "workflowVersion": [],
}
`;
diff --git a/packages/twenty-server/src/engine/metadata-modules/flat-entity/constant/all-entity-properties-configuration-by-metadata-name.constant.ts b/packages/twenty-server/src/engine/metadata-modules/flat-entity/constant/all-entity-properties-configuration-by-metadata-name.constant.ts
index cb6e0194a17..17a64cc2d1b 100644
--- a/packages/twenty-server/src/engine/metadata-modules/flat-entity/constant/all-entity-properties-configuration-by-metadata-name.constant.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/flat-entity/constant/all-entity-properties-configuration-by-metadata-name.constant.ts
@@ -2017,6 +2017,82 @@ export const ALL_ENTITY_PROPERTIES_CONFIGURATION_BY_METADATA_NAME = {
universalProperty: undefined,
},
},
+ workflow: {
+ name: { toCompare: true, toStringify: false, universalProperty: undefined },
+ visibility: {
+ toCompare: true,
+ toStringify: false,
+ universalProperty: undefined,
+ },
+ createdByUserWorkspaceId: {
+ toCompare: false,
+ toStringify: false,
+ universalProperty: undefined,
+ },
+ lastPublishedVersionId: {
+ toCompare: true,
+ toStringify: false,
+ universalProperty: undefined,
+ },
+ lastPublishedCoreWorkflowVersionId: {
+ toCompare: true,
+ toStringify: false,
+ universalProperty: undefined,
+ },
+ workspaceWorkflowId: {
+ toCompare: false,
+ toStringify: false,
+ universalProperty: undefined,
+ },
+ createdAt: {
+ toCompare: false,
+ toStringify: false,
+ universalProperty: undefined,
+ },
+ updatedAt: {
+ toCompare: false,
+ toStringify: false,
+ universalProperty: undefined,
+ },
+ },
+ workflowVersion: {
+ status: {
+ toCompare: true,
+ toStringify: false,
+ universalProperty: undefined,
+ },
+ triggers: {
+ toCompare: true,
+ toStringify: true,
+ universalProperty: undefined,
+ },
+ steps: { toCompare: true, toStringify: true, universalProperty: undefined },
+ coreWorkflowId: {
+ toCompare: true,
+ toStringify: false,
+ universalProperty: undefined,
+ },
+ workflowId: {
+ toCompare: false,
+ toStringify: false,
+ universalProperty: undefined,
+ },
+ workspaceWorkflowVersionId: {
+ toCompare: false,
+ toStringify: false,
+ universalProperty: undefined,
+ },
+ createdAt: {
+ toCompare: false,
+ toStringify: false,
+ universalProperty: undefined,
+ },
+ updatedAt: {
+ toCompare: false,
+ toStringify: false,
+ universalProperty: undefined,
+ },
+ },
} as const satisfies {
[P in AllMetadataName]: MetadataEntityPropertyConfiguration<P>;
};
diff --git a/packages/twenty-server/src/engine/metadata-modules/flat-entity/constant/all-many-to-one-metadata-foreign-key.constant.ts b/packages/twenty-server/src/engine/metadata-modules/flat-entity/constant/all-many-to-one-metadata-foreign-key.constant.ts
index bea56b6cada..866c4809cef 100644
--- a/packages/twenty-server/src/engine/metadata-modules/flat-entity/constant/all-many-to-one-metadata-foreign-key.constant.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/flat-entity/constant/all-many-to-one-metadata-foreign-key.constant.ts
@@ -329,6 +329,15 @@ export const ALL_MANY_TO_ONE_METADATA_FOREIGN_KEY = {
foreignKey: 'tsVectorFieldMetadataId',
},
},
+ workflow: {
+ workspace: null,
+ createdBy: null,
+ application: null,
+ },
+ workflowVersion: {
+ workspace: null,
+ application: null,
+ },
} as const satisfies ManyToOneMetadataRelationsProperties;
// satisfies with complex mapped types involving nested generics doesn't always catch missing required keys
diff --git a/packages/twenty-server/src/engine/metadata-modules/flat-entity/constant/all-many-to-one-metadata-relations.constant.ts b/packages/twenty-server/src/engine/metadata-modules/flat-entity/constant/all-many-to-one-metadata-relations.constant.ts
index fb570477074..e68a20d33b3 100644
--- a/packages/twenty-server/src/engine/metadata-modules/flat-entity/constant/all-many-to-one-metadata-relations.constant.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/flat-entity/constant/all-many-to-one-metadata-relations.constant.ts
@@ -581,6 +581,15 @@ export const ALL_MANY_TO_ONE_METADATA_RELATIONS = {
universalForeignKey: 'tsVectorFieldMetadataUniversalIdentifier',
},
},
+ workflow: {
+ workspace: null,
+ createdBy: null,
+ application: null,
+ },
+ workflowVersion: {
+ workspace: null,
+ application: null,
+ },
} as const satisfies ManyToOneMetadataRelationsProperties;
// satisfies with complex mapped types involving nested generics doesn't always catch missing required keys
diff --git a/packages/twenty-server/src/engine/metadata-modules/flat-entity/constant/all-metadata-entity-by-metadata-name.constant.ts b/packages/twenty-server/src/engine/metadata-modules/flat-entity/constant/all-metadata-entity-by-metadata-name.constant.ts
index ccbc575fa21..11e34a32c40 100644
--- a/packages/twenty-server/src/engine/metadata-modules/flat-entity/constant/all-metadata-entity-by-metadata-name.constant.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/flat-entity/constant/all-metadata-entity-by-metadata-name.constant.ts
@@ -1,3 +1,5 @@
+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 AllMetadataName } from 'twenty-shared/metadata';
import { type EntityTarget, type ObjectLiteral } from 'typeorm';
@@ -67,4 +69,6 @@ export const ALL_METADATA_ENTITY_BY_METADATA_NAME = {
connectionProvider: ConnectionProviderEntity,
searchFieldMetadata: SearchFieldMetadataEntity,
timelineActivityType: TimelineActivityTypeEntity,
+ workflow: WorkflowEntity,
+ workflowVersion: WorkflowVersionEntity,
} as const satisfies Record<AllMetadataName, EntityTarget<ObjectLiteral>>;
diff --git a/packages/twenty-server/src/engine/metadata-modules/flat-entity/constant/all-metadata-required-metadata-for-validation.constant.ts b/packages/twenty-server/src/engine/metadata-modules/flat-entity/constant/all-metadata-required-metadata-for-validation.constant.ts
index e536359e94c..70ab9772fce 100644
--- a/packages/twenty-server/src/engine/metadata-modules/flat-entity/constant/all-metadata-required-metadata-for-validation.constant.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/flat-entity/constant/all-metadata-required-metadata-for-validation.constant.ts
@@ -129,4 +129,6 @@ export const ALL_METADATA_REQUIRED_METADATA_FOR_VALIDATION = {
fieldMetadata: true,
frontComponent: true,
},
+ workflow: {},
+ workflowVersion: {},
} as const satisfies MetadataRequiredForValidation;
diff --git a/packages/twenty-server/src/engine/metadata-modules/flat-entity/constant/all-metadata-serialized-relation.constant.ts b/packages/twenty-server/src/engine/metadata-modules/flat-entity/constant/all-metadata-serialized-relation.constant.ts
index 173b178dc16..6e9c75014bb 100644
--- a/packages/twenty-server/src/engine/metadata-modules/flat-entity/constant/all-metadata-serialized-relation.constant.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/flat-entity/constant/all-metadata-serialized-relation.constant.ts
@@ -55,6 +55,8 @@ export const ALL_METADATA_SERIALIZED_RELATION = {
connectionProvider: {},
timelineActivityType: {},
searchFieldMetadata: {},
+ workflow: {},
+ workflowVersion: {},
} as const satisfies MetadataSerializedRelationProperties;
// satisfies with complex mapped types involving nested generics doesn't always catch missing required keys
diff --git a/packages/twenty-server/src/engine/metadata-modules/flat-entity/constant/all-one-to-many-metadata-relations.constant.ts b/packages/twenty-server/src/engine/metadata-modules/flat-entity/constant/all-one-to-many-metadata-relations.constant.ts
index d7db6ff2934..75019aeb1af 100644
--- a/packages/twenty-server/src/engine/metadata-modules/flat-entity/constant/all-one-to-many-metadata-relations.constant.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/flat-entity/constant/all-one-to-many-metadata-relations.constant.ts
@@ -303,6 +303,8 @@ export const ALL_ONE_TO_MANY_METADATA_RELATIONS = {
connectionProvider: {},
searchFieldMetadata: {},
timelineActivityType: {},
+ workflow: {},
+ workflowVersion: {},
} as const satisfies OneToManyMetadataRelationsProperties;
// satisfies with complex mapped types involving nested generics doesn't always catch missing required keys
diff --git a/packages/twenty-server/src/engine/metadata-modules/flat-entity/types/all-flat-entity-types-by-metadata-name.ts b/packages/twenty-server/src/engine/metadata-modules/flat-entity/types/all-flat-entity-types-by-metadata-name.ts
index 9f12b20f161..a99aba9460a 100644
--- a/packages/twenty-server/src/engine/metadata-modules/flat-entity/types/all-flat-entity-types-by-metadata-name.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/flat-entity/types/all-flat-entity-types-by-metadata-name.ts
@@ -1,3 +1,25 @@
+import { type FlatWorkflowVersionMaps } from 'src/engine/metadata-modules/flat-workflow-version/types/flat-workflow-version-maps.type';
+import { type FlatWorkflowVersion } from 'src/engine/metadata-modules/flat-workflow-version/types/flat-workflow-version.type';
+import { type FlatWorkflowMaps } from 'src/engine/metadata-modules/flat-workflow/types/flat-workflow-maps.type';
+import { type FlatWorkflow } from 'src/engine/metadata-modules/flat-workflow/types/flat-workflow.type';
+import { type UniversalFlatWorkflowVersion } from 'src/engine/workspace-manager/workspace-migration/universal-flat-entity/types/universal-flat-workflow-version.type';
+import { type UniversalFlatWorkflow } from 'src/engine/workspace-manager/workspace-migration/universal-flat-entity/types/universal-flat-workflow.type';
+import {
+ type FlatCreateWorkflowVersionAction,
+ type FlatDeleteWorkflowVersionAction,
+ type FlatUpdateWorkflowVersionAction,
+ type UniversalCreateWorkflowVersionAction,
+ type UniversalDeleteWorkflowVersionAction,
+ type UniversalUpdateWorkflowVersionAction,
+} from 'src/engine/workspace-manager/workspace-migration/workspace-migration-builder/builders/workflow-version/types/workspace-migration-workflow-version-action.type';
+import {
+ type FlatCreateWorkflowAction,
+ type FlatDeleteWorkflowAction,
+ type FlatUpdateWorkflowAction,
+ type UniversalCreateWorkflowAction,
+ type UniversalDeleteWorkflowAction,
+ type UniversalUpdateWorkflowAction,
+} from 'src/engine/workspace-manager/workspace-migration/workspace-migration-builder/builders/workflow/types/workspace-migration-workflow-action.type';
import { type FieldMetadataEntity } from 'src/engine/metadata-modules/field-metadata/field-metadata.entity';
import { type FlatAgentMaps } from 'src/engine/metadata-modules/flat-agent/types/flat-agent-maps.type';
import { type FlatAgent } from 'src/engine/metadata-modules/flat-agent/types/flat-agent.type';
@@ -870,4 +892,36 @@ export type AllFlatEntityTypesByMetadataName = {
universalFlatEntity: UniversalFlatTimelineActivityType;
entity: MetadataEntity<'timelineActivityType'>;
};
+ workflow: {
+ flatEntityMaps: FlatWorkflowMaps;
+ universalActions: {
+ create: UniversalCreateWorkflowAction;
+ update: UniversalUpdateWorkflowAction;
+ delete: UniversalDeleteWorkflowAction;
+ };
+ flatActions: {
+ create: FlatCreateWorkflowAction;
+ update: FlatUpdateWorkflowAction;
+ delete: FlatDeleteWorkflowAction;
+ };
+ flatEntity: FlatWorkflow;
+ universalFlatEntity: UniversalFlatWorkflow;
+ entity: MetadataEntity<'workflow'>;
+ };
+ workflowVersion: {
+ flatEntityMaps: FlatWorkflowVersionMaps;
+ universalActions: {
+ create: UniversalCreateWorkflowVersionAction;
+ update: UniversalUpdateWorkflowVersionAction;
+ delete: UniversalDeleteWorkflowVersionAction;
+ };
+ flatActions: {
+ create: FlatCreateWorkflowVersionAction;
+ update: FlatUpdateWorkflowVersionAction;
+ delete: FlatDeleteWorkflowVersionAction;
+ };
+ flatEntity: FlatWorkflowVersion;
+ universalFlatEntity: UniversalFlatWorkflowVersion;
+ entity: MetadataEntity<'workflowVersion'>;
+ };
};
diff --git a/packages/twenty-server/src/engine/metadata-modules/flat-entity/utils/__tests__/__snapshots__/get-metadata-related-metadata-names.util.spec.ts.snap b/packages/twenty-server/src/engine/metadata-modules/flat-entity/utils/__tests__/__snapshots__/get-metadata-related-metadata-names.util.spec.ts.snap
index 0d261de0aaa..fe380dc4e68 100644
--- a/packages/twenty-server/src/engine/metadata-modules/flat-entity/utils/__tests__/__snapshots__/get-metadata-related-metadata-names.util.spec.ts.snap
+++ b/packages/twenty-server/src/engine/metadata-modules/flat-entity/utils/__tests__/__snapshots__/get-metadata-related-metadata-names.util.spec.ts.snap
@@ -216,3 +216,7 @@ exports[`getMetadataRelatedMetadataNames should return related metadata names fo
`;
exports[`getMetadataRelatedMetadataNames should return related metadata names for webhook 1`] = `[]`;
+
+exports[`getMetadataRelatedMetadataNames should return related metadata names for workflow 1`] = `[]`;
+
+exports[`getMetadataRelatedMetadataNames should return related metadata names for workflowVersion 1`] = `[]`;
diff --git a/packages/twenty-server/src/engine/metadata-modules/flat-entity/utils/__tests__/__snapshots__/sort-metadata-names-children-first.util.spec.ts.snap b/packages/twenty-server/src/engine/metadata-modules/flat-entity/utils/__tests__/__snapshots__/sort-metadata-names-children-first.util.spec.ts.snap
index ad62468b064..125f230a299 100644
--- a/packages/twenty-server/src/engine/metadata-modules/flat-entity/utils/__tests__/__snapshots__/sort-metadata-names-children-first.util.spec.ts.snap
+++ b/packages/twenty-server/src/engine/metadata-modules/flat-entity/utils/__tests__/__snapshots__/sort-metadata-names-children-first.util.spec.ts.snap
@@ -29,6 +29,8 @@ exports[`sortMetadataNamesChildrenFirst should return metadata names sorted with
"viewFieldGroup",
"viewFilterGroup",
"webhook",
+ "workflow",
+ "workflowVersion",
"permissionFlag",
"view",
"fieldMetadata",
diff --git a/packages/twenty-server/src/engine/metadata-modules/flat-workflow-version/flat-workflow-version.module.ts b/packages/twenty-server/src/engine/metadata-modules/flat-workflow-version/flat-workflow-version.module.ts
new file mode 100644
index 00000000000..e43a8fcf877
--- /dev/null
+++ b/packages/twenty-server/src/engine/metadata-modules/flat-workflow-version/flat-workflow-version.module.ts
@@ -0,0 +1,22 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+
+import { ApplicationEntity } from 'src/engine/core-modules/application/application.entity';
+import { WorkflowVersionEntity } from 'src/engine/core-modules/workflow/entities/workflow-version.entity';
+import { WorkflowEntity } from 'src/engine/core-modules/workflow/entities/workflow.entity';
+import { WorkspaceManyOrAllFlatEntityMapsCacheModule } from 'src/engine/metadata-modules/flat-entity/services/workspace-many-or-all-flat-entity-maps-cache.module';
+import { WorkspaceFlatWorkflowVersionMapCacheService } from 'src/engine/metadata-modules/flat-workflow-version/services/workspace-flat-workflow-version-map-cache.service';
+
+@Module({
+ imports: [
+ TypeOrmModule.forFeature([
+ ApplicationEntity,
+ WorkflowEntity,
+ WorkflowVersionEntity,
+ ]),
+ WorkspaceManyOrAllFlatEntityMapsCacheModule,
+ ],
+ providers: [WorkspaceFlatWorkflowVersionMapCacheService],
+ exports: [WorkspaceFlatWorkflowVersionMapCacheService],
+})
+export class FlatWorkflowVersionModule {}
diff --git a/packages/twenty-server/src/engine/metadata-modules/flat-workflow-version/services/workspace-flat-workflow-version-map-cache.service.ts b/packages/twenty-server/src/engine/metadata-modules/flat-workflow-version/services/workspace-flat-workflow-version-map-cache.service.ts
new file mode 100644
index 00000000000..9ae162e70b8
--- /dev/null
+++ b/packages/twenty-server/src/engine/metadata-modules/flat-workflow-version/services/workspace-flat-workflow-version-map-cache.service.ts
@@ -0,0 +1,55 @@
+import { Injectable } from '@nestjs/common';
+
+import { isDefined } from 'twenty-shared/utils';
+
+import { MetadataFlatEntityMapsCacheProvider } from 'src/engine/workspace-cache/interfaces/metadata-flat-entity-maps-cache-provider.service';
+
+import { createEmptyFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/constant/create-empty-flat-entity-maps.constant';
+import { type FlatWorkflowVersionMaps } from 'src/engine/metadata-modules/flat-workflow-version/types/flat-workflow-version-maps.type';
+import { fromWorkflowVersionEntityToFlatWorkflowVersion } from 'src/engine/metadata-modules/flat-workflow-version/utils/from-workflow-version-entity-to-flat-workflow-version.util';
+import { WorkspaceCache } from 'src/engine/workspace-cache/decorators/workspace-cache.decorator';
+import { type WorkspaceCacheProviderContext } from 'src/engine/workspace-cache/types/workspace-cache-provider-context.type';
+import { createIdToUniversalIdentifierMap } from 'src/engine/workspace-cache/utils/create-id-to-universal-identifier-map.util';
+import { addFlatEntityToFlatEntityMapsThroughMutationOrThrow } from 'src/engine/workspace-manager/workspace-migration/utils/add-flat-entity-to-flat-entity-maps-through-mutation-or-throw.util';
+
+const FLAT_WORKFLOW_VERSION_ROWS_REQUIREMENT = {
+ workflowVersion: true,
+ application: ['id', 'universalIdentifier', 'deletedAt'],
+} as const;
+
+@Injectable()
+@WorkspaceCache('flatWorkflowVersionMaps', { packingPonderation: 1 })
+export class WorkspaceFlatWorkflowVersionMapCacheService extends MetadataFlatEntityMapsCacheProvider<'workflowVersion'> {
+ override readonly rowsRequirement = FLAT_WORKFLOW_VERSION_ROWS_REQUIREMENT;
+
+ computeForCache({
+ rows,
+ }: WorkspaceCacheProviderContext<
+ typeof FLAT_WORKFLOW_VERSION_ROWS_REQUIREMENT
+ >): FlatWorkflowVersionMaps {
+ const { workflowVersion: workflowVersions, application: applications } =
+ rows;
+
+ const applicationIdToUniversalIdentifierMap =
+ createIdToUniversalIdentifierMap(
+ applications.filter((application) => !isDefined(application.deletedAt)),
+ );
+
+ const flatWorkflowVersionMaps = createEmptyFlatEntityMaps();
+
+ for (const workflowVersionEntity of workflowVersions) {
+ const flatWorkflowVersion =
+ fromWorkflowVersionEntityToFlatWorkflowVersion({
+ entity: workflowVersionEntity,
+ applicationIdToUniversalIdentifierMap,
+ });
+
+ addFlatEntityToFlatEntityMapsThroughMutationOrThrow({
+ flatEntity: flatWorkflowVersion,
+ flatEntityMapsToMutate: flatWorkflowVersionMaps,
+ });
+ }
+
+ return flatWorkflowVersionMaps;
+ }
+}
diff --git a/packages/twenty-server/src/engine/metadata-modules/flat-workflow-version/types/flat-workflow-version-maps.type.ts b/packages/twenty-server/src/engine/metadata-modules/flat-workflow-version/types/flat-workflow-version-maps.type.ts
new file mode 100644
index 00000000000..630b7fc6a9a
--- /dev/null
+++ b/packages/twenty-server/src/engine/metadata-modules/flat-workflow-version/types/flat-workflow-version-maps.type.ts
@@ -0,0 +1,4 @@
+import { type FlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/flat-entity-maps.type';
+import { type FlatWorkflowVersion } from 'src/engine/metadata-modules/flat-workflow-version/types/flat-workflow-version.type';
+
+export type FlatWorkflowVersionMaps = FlatEntityMaps<FlatWorkflowVersion>;
diff --git a/packages/twenty-server/src/engine/metadata-modules/flat-workflow-version/types/flat-workflow-version.type.ts b/packages/twenty-server/src/engine/metadata-modules/flat-workflow-version/types/flat-workflow-version.type.ts
new file mode 100644
index 00000000000..404f402fa49
--- /dev/null
+++ b/packages/twenty-server/src/engine/metadata-modules/flat-workflow-version/types/flat-workflow-version.type.ts
@@ -0,0 +1,4 @@
+import { type WorkflowVersionEntity } from 'src/engine/core-modules/workflow/entities/workflow-version.entity';
+import { type FlatEntityFrom } from 'src/engine/metadata-modules/flat-entity/types/flat-entity-from.type';
+
+export type FlatWorkflowVersion = FlatEntityFrom<WorkflowVersionEntity>;
diff --git a/packages/twenty-server/src/engine/metadata-modules/flat-workflow-version/utils/from-workflow-version-entity-to-flat-workflow-version.util.ts b/packages/twenty-server/src/engine/metadata-modules/flat-workflow-version/utils/from-workflow-version-entity-to-flat-workflow-version.util.ts
new file mode 100644
index 00000000000..768bb94a371
--- /dev/null
+++ b/packages/twenty-server/src/engine/metadata-modules/flat-workflow-version/utils/from-workflow-version-entity-to-flat-workflow-version.util.ts
@@ -0,0 +1,26 @@
+import { fromEntityToScalarEntity } from 'src/engine/metadata-modules/flat-entity/utils/from-entity-to-scalar-entity.util';
+import { type FlatWorkflowVersion } from 'src/engine/metadata-modules/flat-workflow-version/types/flat-workflow-version.type';
+import { type FromEntityToFlatEntityArgs } from 'src/engine/workspace-cache/types/from-entity-to-flat-entity-args.type';
+import { resolveManyToOneRelationIdsToUniversalIdentifiers } from 'src/engine/workspace-manager/workspace-migration/universal-flat-entity/utils/resolve-many-to-one-relation-ids-to-universal-identifiers.util';
+
+export const fromWorkflowVersionEntityToFlatWorkflowVersion = (
+ args: FromEntityToFlatEntityArgs<'workflowVersion'>,
+): FlatWorkflowVersion => {
+ const { entity: workflowVersionEntity } = args;
+
+ const workflowVersionScalarEntity = fromEntityToScalarEntity({
+ metadataName: 'workflowVersion',
+ entity: workflowVersionEntity,
+ });
+
+ const relationUniversalIdentifiers =
+ resolveManyToOneRelationIdsToUniversalIdentifiers({
+ metadataName: 'workflowVersion',
+ ...args,
+ });
+
+ return {
+ ...workflowVersionScalarEntity,
+ ...relationUniversalIdentifiers,
+ };
+};
diff --git a/packages/twenty-server/src/engine/metadata-modules/flat-workflow/flat-workflow.module.ts b/packages/twenty-server/src/engine/metadata-modules/flat-workflow/flat-workflow.module.ts
new file mode 100644
index 00000000000..b90536e5094
--- /dev/null
+++ b/packages/twenty-server/src/engine/metadata-modules/flat-workflow/flat-workflow.module.ts
@@ -0,0 +1,17 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+
+import { ApplicationEntity } from 'src/engine/core-modules/application/application.entity';
+import { WorkflowEntity } from 'src/engine/core-modules/workflow/entities/workflow.entity';
+import { WorkspaceManyOrAllFlatEntityMapsCacheModule } from 'src/engine/metadata-modules/flat-entity/services/workspace-many-or-all-flat-entity-maps-cache.module';
+import { WorkspaceFlatWorkflowMapCacheService } from 'src/engine/metadata-modules/flat-workflow/services/workspace-flat-workflow-map-cache.service';
+
+@Module({
+ imports: [
+ TypeOrmModule.forFeature([ApplicationEntity, WorkflowEntity]),
+ WorkspaceManyOrAllFlatEntityMapsCacheModule,
+ ],
+ providers: [WorkspaceFlatWorkflowMapCacheService],
+ exports: [WorkspaceFlatWorkflowMapCacheService],
+})
+export class FlatWorkflowModule {}
diff --git a/packages/twenty-server/src/engine/metadata-modules/flat-workflow/services/workspace-flat-workflow-map-cache.service.ts b/packages/twenty-server/src/engine/metadata-modules/flat-workflow/services/workspace-flat-workflow-map-cache.service.ts
new file mode 100644
index 00000000000..5f3d3b5a881
--- /dev/null
+++ b/packages/twenty-server/src/engine/metadata-modules/flat-workflow/services/workspace-flat-workflow-map-cache.service.ts
@@ -0,0 +1,53 @@
+import { Injectable } from '@nestjs/common';
+
+import { isDefined } from 'twenty-shared/utils';
+
+import { MetadataFlatEntityMapsCacheProvider } from 'src/engine/workspace-cache/interfaces/metadata-flat-entity-maps-cache-provider.service';
+
+import { createEmptyFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/constant/create-empty-flat-entity-maps.constant';
+import { type FlatWorkflowMaps } from 'src/engine/metadata-modules/flat-workflow/types/flat-workflow-maps.type';
+import { fromWorkflowEntityToFlatWorkflow } from 'src/engine/metadata-modules/flat-workflow/utils/from-workflow-entity-to-flat-workflow.util';
+import { WorkspaceCache } from 'src/engine/workspace-cache/decorators/workspace-cache.decorator';
+import { type WorkspaceCacheProviderContext } from 'src/engine/workspace-cache/types/workspace-cache-provider-context.type';
+import { createIdToUniversalIdentifierMap } from 'src/engine/workspace-cache/utils/create-id-to-universal-identifier-map.util';
+import { addFlatEntityToFlatEntityMapsThroughMutationOrThrow } from 'src/engine/workspace-manager/workspace-migration/utils/add-flat-entity-to-flat-entity-maps-through-mutation-or-throw.util';
+
+const FLAT_WORKFLOW_ROWS_REQUIREMENT = {
+ workflow: true,
+ application: ['id', 'universalIdentifier', 'deletedAt'],
+} as const;
+
+@Injectable()
+@WorkspaceCache('flatWorkflowMaps', { packingPonderation: 1 })
+export class WorkspaceFlatWorkflowMapCacheService extends MetadataFlatEntityMapsCacheProvider<'workflow'> {
+ override readonly rowsRequirement = FLAT_WORKFLOW_ROWS_REQUIREMENT;
+
+ computeForCache({
+ rows,
+ }: WorkspaceCacheProviderContext<
+ typeof FLAT_WORKFLOW_ROWS_REQUIREMENT
+ >): FlatWorkflowMaps {
+ const { workflow: workflows, application: applications } = rows;
+
+ const applicationIdToUniversalIdentifierMap =
+ createIdToUniversalIdentifierMap(
+ applications.filter((application) => !isDefined(application.deletedAt)),
+ );
+
+ const flatWorkflowMaps = createEmptyFlatEntityMaps();
+
+ for (const workflowEntity of workflows) {
+ const flatWorkflow = fromWorkflowEntityToFlatWorkflow({
+ entity: workflowEntity,
+ applicationIdToUniversalIdentifierMap,
+ });
+
+ addFlatEntityToFlatEntityMapsThroughMutationOrThrow({
+ flatEntity: flatWorkflow,
+ flatEntityMapsToMutate: flatWorkflowMaps,
+ });
+ }
+
+ return flatWorkflowMaps;
+ }
+}
diff --git a/packages/twenty-server/src/engine/metadata-modules/flat-workflow/types/flat-workflow-maps.type.ts b/packages/twenty-server/src/engine/metadata-modules/flat-workflow/types/flat-workflow-maps.type.ts
new file mode 100644
index 00000000000..3b0ee31298f
--- /dev/null
+++ b/packages/twenty-server/src/engine/metadata-modules/flat-workflow/types/flat-workflow-maps.type.ts
@@ -0,0 +1,4 @@
+import { type FlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/flat-entity-maps.type';
+import { type FlatWorkflow } from 'src/engine/metadata-modules/flat-workflow/types/flat-workflow.type';
+
+export type FlatWorkflowMaps = FlatEntityMaps<FlatWorkflow>;
diff --git a/packages/twenty-server/src/engine/metadata-modules/flat-workflow/types/flat-workflow.type.ts b/packages/twenty-server/src/engine/metadata-modules/flat-workflow/types/flat-workflow.type.ts
new file mode 100644
index 00000000000..cb443a2fa5a
--- /dev/null
+++ b/packages/twenty-server/src/engine/metadata-modules/flat-workflow/types/flat-workflow.type.ts
@@ -0,0 +1,4 @@
+import { type WorkflowEntity } from 'src/engine/core-modules/workflow/entities/workflow.entity';
+import { type FlatEntityFrom } from 'src/engine/metadata-modules/flat-entity/types/flat-entity-from.type';
+
+export type FlatWorkflow = FlatEntityFrom<WorkflowEntity>;
diff --git a/packages/twenty-server/src/engine/metadata-modules/flat-workflow/utils/from-workflow-entity-to-flat-workflow.util.ts b/packages/twenty-server/src/engine/metadata-modules/flat-workflow/utils/from-workflow-entity-to-flat-workflow.util.ts
new file mode 100644
index 00000000000..beaf3a7ca84
--- /dev/null
+++ b/packages/twenty-server/src/engine/metadata-modules/flat-workflow/utils/from-workflow-entity-to-flat-workflow.util.ts
@@ -0,0 +1,26 @@
+import { fromEntityToScalarEntity } from 'src/engine/metadata-modules/flat-entity/utils/from-entity-to-scalar-entity.util';
+import { type FlatWorkflow } from 'src/engine/metadata-modules/flat-workflow/types/flat-workflow.type';
+import { type FromEntityToFlatEntityArgs } from 'src/engine/workspace-cache/types/from-entity-to-flat-entity-args.type';
+import { resolveManyToOneRelationIdsToUniversalIdentifiers } from 'src/engine/workspace-manager/workspace-migration/universal-flat-entity/utils/resolve-many-to-one-relation-ids-to-universal-identifiers.util';
+
+export const fromWorkflowEntityToFlatWorkflow = (
+ args: FromEntityToFlatEntityArgs<'workflow'>,
+): FlatWorkflow => {
+ const { entity: workflowEntity } = args;
+
+ const workflowScalarEntity = fromEntityToScalarEntity({
+ metadataName: 'workflow',
+ entity: workflowEntity,
+ });
+
+ const relationUniversalIdentifiers =
+ resolveManyToOneRelationIdsToUniversalIdentifiers({
+ metadataName: 'workflow',
+ ...args,
+ });
+
+ return {
+ ...workflowScalarEntity,
+ ...relationUniversalIdentifiers,
+ };
+};
diff --git a/packages/twenty-server/src/engine/metadata-modules/permissions/utils/__tests__/resolve-user-workspace-ids-with-permission-flag.util.spec.ts b/packages/twenty-server/src/engine/metadata-modules/permissions/utils/__tests__/resolve-user-workspace-ids-with-permission-flag.util.spec.ts
new file mode 100644
index 00000000000..86995f871b1
--- /dev/null
+++ b/packages/twenty-server/src/engine/metadata-modules/permissions/utils/__tests__/resolve-user-workspace-ids-with-permission-flag.util.spec.ts
@@ -0,0 +1,182 @@
+import {
+ PermissionFlagType,
+ SystemPermissionFlag,
+} from 'twenty-shared/constants';
+
+import { type FlatRolePermissionFlagMaps } from 'src/engine/metadata-modules/flat-role-permission-flag/types/flat-role-permission-flag-maps.type';
+import { type FlatRoleTargetMaps } from 'src/engine/metadata-modules/flat-role-target/types/flat-role-target-maps.type';
+import { type FlatRoleMaps } from 'src/engine/metadata-modules/flat-role/types/flat-role-maps.type';
+import { resolveUserWorkspaceIdsWithPermissionFlag } from 'src/engine/metadata-modules/permissions/utils/resolve-user-workspace-ids-with-permission-flag.util';
+
+const buildInput = ({
+ permissionFlag = PermissionFlagType.WORKFLOWS,
+ roles = [],
+ roleTargets = [],
+}: {
+ permissionFlag?: PermissionFlagType;
+ roles?: {
+ id: string;
+ canUpdateAllSettings?: boolean;
+ canAccessAllTools?: boolean;
+ grantedPermissionFlag?: PermissionFlagType;
+ }[];
+ roleTargets?: { roleId: string; userWorkspaceId: string | null }[];
+}) => {
+ const rolePermissionFlagMaps = roles.flatMap((role) =>
+ role.grantedPermissionFlag
+ ? [
+ {
+ rolePermissionFlagId: `role-permission-flag-${role.id}`,
+ permissionFlagUniversalIdentifier:
+ SystemPermissionFlag[role.grantedPermissionFlag],
+ },
+ ]
+ : [],
+ );
+
+ return {
+ permissionFlag,
+ flatRoleMaps: {
+ byUniversalIdentifier: Object.fromEntries(
+ roles.map((role) => [
+ role.id,
+ {
+ id: role.id,
+ canUpdateAllSettings: role.canUpdateAllSettings ?? false,
+ canAccessAllTools: role.canAccessAllTools ?? false,
+ rolePermissionFlagIds: role.grantedPermissionFlag
+ ? [`role-permission-flag-${role.id}`]
+ : [],
+ roleTargetIds: roleTargets.flatMap((roleTarget, index) =>
+ roleTarget.roleId === role.id ? [`role-target-${index}`] : [],
+ ),
+ },
+ ]),
+ ),
+ } as unknown as FlatRoleMaps,
+ flatRolePermissionFlagMaps: {
+ byUniversalIdentifier: Object.fromEntries(
+ rolePermissionFlagMaps.map((entry) => [
+ entry.rolePermissionFlagId,
+ {
+ permissionFlagUniversalIdentifier:
+ entry.permissionFlagUniversalIdentifier,
+ },
+ ]),
+ ),
+ universalIdentifierById: Object.fromEntries(
+ rolePermissionFlagMaps.map((entry) => [
+ entry.rolePermissionFlagId,
+ entry.rolePermissionFlagId,
+ ]),
+ ),
+ } as unknown as FlatRolePermissionFlagMaps,
+ flatRoleTargetMaps: {
+ byUniversalIdentifier: Object.fromEntries(
+ roleTargets.map((roleTarget, index) => [
+ `role-target-${index}`,
+ roleTarget,
+ ]),
+ ),
+ universalIdentifierById: Object.fromEntries(
+ roleTargets.map((_, index) => [
+ `role-target-${index}`,
+ `role-target-${index}`,
+ ]),
+ ),
+ } as unknown as FlatRoleTargetMaps,
+ };
+};
+
+describe('resolveUserWorkspaceIdsWithPermissionFlag', () => {
+ it('returns no recipient when no role holds the flag', () => {
+ expect(
+ resolveUserWorkspaceIdsWithPermissionFlag(
+ buildInput({
+ roles: [{ id: 'role-1' }],
+ roleTargets: [{ roleId: 'role-1', userWorkspaceId: 'uw-1' }],
+ }),
+ ),
+ ).toEqual([]);
+ });
+
+ it('includes members of a role granted the flag', () => {
+ expect(
+ resolveUserWorkspaceIdsWithPermissionFlag(
+ buildInput({
+ roles: [
+ {
+ id: 'role-1',
+ grantedPermissionFlag: PermissionFlagType.WORKFLOWS,
+ },
+ ],
+ roleTargets: [{ roleId: 'role-1', userWorkspaceId: 'uw-1' }],
+ }),
+ ),
+ ).toEqual(['uw-1']);
+ });
+
+ it('includes members of a role that can update all settings', () => {
+ expect(
+ resolveUserWorkspaceIdsWithPermissionFlag(
+ buildInput({
+ roles: [{ id: 'admin-role', canUpdateAllSettings: true }],
+ roleTargets: [{ roleId: 'admin-role', userWorkspaceId: 'uw-admin' }],
+ }),
+ ),
+ ).toEqual(['uw-admin']);
+ });
+
+ it('uses the tool base permission for a tool flag', () => {
+ const roles = [
+ { id: 'tool-role', canAccessAllTools: true },
+ { id: 'settings-role', canUpdateAllSettings: true },
+ ];
+ const roleTargets = [
+ { roleId: 'tool-role', userWorkspaceId: 'uw-tool' },
+ { roleId: 'settings-role', userWorkspaceId: 'uw-settings' },
+ ];
+
+ expect(
+ resolveUserWorkspaceIdsWithPermissionFlag(
+ buildInput({
+ permissionFlag: PermissionFlagType.VIEWS,
+ roles,
+ roleTargets,
+ }),
+ ),
+ ).toEqual(['uw-tool']);
+
+ expect(
+ resolveUserWorkspaceIdsWithPermissionFlag(
+ buildInput({
+ permissionFlag: PermissionFlagType.WORKFLOWS,
+ roles,
+ roleTargets,
+ }),
+ ),
+ ).toEqual(['uw-settings']);
+ });
+
+ it('ignores another flag and non-user targets, and deduplicates', () => {
+ expect(
+ resolveUserWorkspaceIdsWithPermissionFlag(
+ buildInput({
+ roles: [
+ {
+ id: 'role-1',
+ grantedPermissionFlag: PermissionFlagType.DATA_MODEL,
+ },
+ { id: 'role-2', canUpdateAllSettings: true },
+ ],
+ roleTargets: [
+ { roleId: 'role-1', userWorkspaceId: 'uw-1' },
+ { roleId: 'role-2', userWorkspaceId: 'uw-2' },
+ { roleId: 'role-2', userWorkspaceId: 'uw-2' },
+ { roleId: 'role-2', userWorkspaceId: null },
+ ],
+ }),
+ ),
+ ).toEqual(['uw-2']);
+ });
+});
diff --git a/packages/twenty-server/src/engine/metadata-modules/permissions/utils/resolve-user-workspace-ids-with-permission-flag.util.ts b/packages/twenty-server/src/engine/metadata-modules/permissions/utils/resolve-user-workspace-ids-with-permission-flag.util.ts
new file mode 100644
index 00000000000..9fcfa9e6c67
--- /dev/null
+++ b/packages/twenty-server/src/engine/metadata-modules/permissions/utils/resolve-user-workspace-ids-with-permission-flag.util.ts
@@ -0,0 +1,62 @@
+import { isNonEmptyString } from '@sniptt/guards';
+import { type PermissionFlagType } from 'twenty-shared/constants';
+import { isDefined } from 'twenty-shared/utils';
+
+import { type FlatRolePermissionFlagMaps } from 'src/engine/metadata-modules/flat-role-permission-flag/types/flat-role-permission-flag-maps.type';
+import { type FlatRoleTargetMaps } from 'src/engine/metadata-modules/flat-role-target/types/flat-role-target-maps.type';
+import { type FlatRoleMaps } from 'src/engine/metadata-modules/flat-role/types/flat-role-maps.type';
+import { findFlatEntityByIdInFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-id-in-flat-entity-maps.util';
+import { type FlatRole } from 'src/engine/metadata-modules/flat-role/types/flat-role.type';
+import { flatRoleHasPermissionFlag } from 'src/engine/metadata-modules/flat-role/utils/flat-role-has-permission-flag.util';
+import { TOOL_PERMISSION_FLAGS } from 'src/engine/metadata-modules/permissions/constants/tool-permission-flags';
+
+export const resolveUserWorkspaceIdsWithPermissionFlag = ({
+ permissionFlag,
+ flatRoleMaps,
+ flatRolePermissionFlagMaps,
+ flatRoleTargetMaps,
+}: {
+ permissionFlag: PermissionFlagType;
+ flatRoleMaps: FlatRoleMaps;
+ flatRolePermissionFlagMaps: FlatRolePermissionFlagMaps;
+ flatRoleTargetMaps: FlatRoleTargetMaps;
+}): string[] => {
+ const hasBasePermission = (flatRole: FlatRole): boolean =>
+ TOOL_PERMISSION_FLAGS.includes(permissionFlag)
+ ? flatRole.canAccessAllTools
+ : flatRole.canUpdateAllSettings;
+
+ const flatRolesWithPermissionFlag = Object.values(
+ flatRoleMaps.byUniversalIdentifier,
+ )
+ .filter(isDefined)
+ .filter(
+ (flatRole) =>
+ hasBasePermission(flatRole) ||
+ flatRoleHasPermissionFlag({
+ flatRole,
+ permissionFlag,
+ flatRolePermissionFlagMaps,
+ }),
+ );
+
+ const userWorkspaceIds = new Set<string>();
+
+ for (const flatRole of flatRolesWithPermissionFlag) {
+ for (const roleTargetId of flatRole.roleTargetIds) {
+ const flatRoleTarget = findFlatEntityByIdInFlatEntityMaps({
+ flatEntityId: roleTargetId,
+ flatEntityMaps: flatRoleTargetMaps,
+ });
+
+ if (
+ isDefined(flatRoleTarget) &&
+ isNonEmptyString(flatRoleTarget.userWorkspaceId)
+ ) {
+ userWorkspaceIds.add(flatRoleTarget.userWorkspaceId);
+ }
+ }
+ }
+
+ return [...userWorkspaceIds];
+};
diff --git a/packages/twenty-server/src/engine/subscriptions/constants/broadcast-property-keys-by-gated-entity-name.constant.ts b/packages/twenty-server/src/engine/subscriptions/constants/broadcast-property-keys-by-gated-entity-name.constant.ts
new file mode 100644
index 00000000000..fd642d78b01
--- /dev/null
+++ b/packages/twenty-server/src/engine/subscriptions/constants/broadcast-property-keys-by-gated-entity-name.constant.ts
@@ -0,0 +1,13 @@
+import { type AllMetadataName } from 'twenty-shared/metadata';
+
+export const BROADCAST_PROPERTY_KEYS_BY_GATED_ENTITY_NAME = {
+ workflow: ['id'],
+ workflowVersion: ['id', 'coreWorkflowId'],
+} as const satisfies Partial<Record<AllMetadataName, readonly string[]>>;
+
+export const getBroadcastPropertyKeysForGatedEntityName = (
+ entityName: string,
+): readonly string[] | undefined =>
+ BROADCAST_PROPERTY_KEYS_BY_GATED_ENTITY_NAME[
+ entityName as keyof typeof BROADCAST_PROPERTY_KEYS_BY_GATED_ENTITY_NAME
+ ];
diff --git a/packages/twenty-server/src/engine/subscriptions/constants/required-permission-flag-by-broadcast-entity-name.constant.ts b/packages/twenty-server/src/engine/subscriptions/constants/required-permission-flag-by-broadcast-entity-name.constant.ts
new file mode 100644
index 00000000000..75c5794ddba
--- /dev/null
+++ b/packages/twenty-server/src/engine/subscriptions/constants/required-permission-flag-by-broadcast-entity-name.constant.ts
@@ -0,0 +1,14 @@
+import { PermissionFlagType } from 'twenty-shared/constants';
+import { type AllMetadataName } from 'twenty-shared/metadata';
+
+export const REQUIRED_PERMISSION_FLAG_BY_BROADCAST_ENTITY_NAME = {
+ workflow: PermissionFlagType.WORKFLOWS,
+ workflowVersion: PermissionFlagType.WORKFLOWS,
+} as const satisfies Partial<Record<AllMetadataName, PermissionFlagType>>;
+
+export const getRequiredPermissionFlagForBroadcastEntityName = (
+ entityName: string,
+): PermissionFlagType | undefined =>
+ REQUIRED_PERMISSION_FLAG_BY_BROADCAST_ENTITY_NAME[
+ entityName as keyof typeof REQUIRED_PERMISSION_FLAG_BY_BROADCAST_ENTITY_NAME
+ ];
diff --git a/packages/twenty-server/src/engine/subscriptions/metadata-event/metadata-event-publisher.ts b/packages/twenty-server/src/engine/subscriptions/metadata-event/metadata-event-publisher.ts
index 812b95a0753..4339e806fd5 100644
--- a/packages/twenty-server/src/engine/subscriptions/metadata-event/metadata-event-publisher.ts
+++ b/packages/twenty-server/src/engine/subscriptions/metadata-event/metadata-event-publisher.ts
@@ -1,14 +1,35 @@
import { Injectable } from '@nestjs/common';
import { isNonEmptyString } from '@sniptt/guards';
+import { WorkflowVisibility } from 'twenty-shared/types';
import { isDefined, isNonEmptyArray } from 'twenty-shared/utils';
import { WorkspaceManyOrAllFlatEntityMapsCacheService } from 'src/engine/metadata-modules/flat-entity/services/workspace-many-or-all-flat-entity-maps-cache.service';
+import { findFlatEntityByIdInFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-id-in-flat-entity-maps.util';
import { NavigationMenuItemRecordIdentifierService } from 'src/engine/metadata-modules/navigation-menu-item/services/navigation-menu-item-record-identifier.service';
import { type MetadataEventBatch } from 'src/engine/subscriptions/metadata-event/types/metadata-event-batch.type';
import { enrichFieldMetadataEventWithRelations } from 'src/engine/subscriptions/metadata-event/utils/enrich-field-metadata-event-with-relations.util';
+import { getRequiredPermissionFlagForBroadcastEntityName } from 'src/engine/subscriptions/constants/required-permission-flag-by-broadcast-entity-name.constant';
+import { pickBroadcastEventProperties } from 'src/engine/subscriptions/utils/pick-broadcast-event-properties.util';
import { WorkspaceEventBroadcaster } from 'src/engine/subscriptions/workspace-event-broadcaster/workspace-event-broadcaster.service';
+type BroadcastEventRecord = {
+ userWorkspaceId?: string | null;
+ visibility?: WorkflowVisibility | null;
+ createdByUserWorkspaceId?: string | null;
+ coreWorkflowId?: string | null;
+};
+
+const getBroadcastEventRecord = (event: MetadataEventBatch['events'][number]) =>
+ (event.type === 'deleted'
+ ? event.properties.before
+ : event.properties.after) as BroadcastEventRecord | undefined;
+
+const getPrivateWorkflowOwner = (record: BroadcastEventRecord | undefined) =>
+ record?.visibility === WorkflowVisibility.PRIVATE
+ ? (record.createdByUserWorkspaceId ?? undefined)
+ : undefined;
+
@Injectable()
export class MetadataEventPublisher {
constructor(
@@ -25,39 +46,112 @@ export class MetadataEventPublisher {
const enrichedBatch =
await this.enrichMetadataEventBatch(metadataEventBatch);
+ const recipientUserWorkspaceIdsByRecordId =
+ await this.resolveRecipientUserWorkspaceIdsByRecordId(enrichedBatch);
+
await this.workspaceEventBroadcaster.broadcast({
workspaceId: enrichedBatch.workspaceId,
updatedCollectionHash: enrichedBatch.updatedCollectionHash,
events: enrichedBatch.events.map((event) => {
- const ownerUserWorkspaceId = this.resolveOwnerUserWorkspaceId(event);
+ const recipientUserWorkspaceIds =
+ recipientUserWorkspaceIdsByRecordId.get(event.recordId);
return {
type: event.type,
entityName: event.metadataName,
recordId: event.recordId,
- properties: event.properties as Record<string, unknown>,
- recipientUserWorkspaceIds: isNonEmptyString(ownerUserWorkspaceId)
- ? [ownerUserWorkspaceId]
- : undefined,
+ properties: pickBroadcastEventProperties({
+ entityName: event.metadataName,
+ properties: event.properties as Record<string, unknown>,
+ }),
+ recipientUserWorkspaceIds,
+ requiredPermissionFlag:
+ getRequiredPermissionFlagForBroadcastEntityName(event.metadataName),
};
}),
});
}
- private resolveOwnerUserWorkspaceId(
- event: MetadataEventBatch['events'][number],
- ): string | undefined {
- if (event.metadataName !== 'navigationMenuItem') {
- return undefined;
- }
+ // An unowned private workflow stays workspace-wide on purpose: the read path
+ // opens it to everyone once its creator has left the workspace. A version
+ // whose parent is already gone is the opposite case and fails closed, since
+ // the parent is deleted before its versions are published.
+ private async resolveRecipientUserWorkspaceIdsByRecordId({
+ metadataName,
+ workspaceId,
+ events,
+ }: MetadataEventBatch): Promise<Map<string, string[]>> {
+ const flatWorkflowMaps =
+ metadataName === 'workflowVersion'
+ ? (
+ await this.workspaceManyOrAllFlatEntityMapsCacheService.getOrRecomputeManyOrAllFlatEntityMaps(
+ { workspaceId, flatMapsKeys: ['flatWorkflowMaps'] },
+ )
+ ).flatWorkflowMaps
+ : undefined;
+
+ const resolveRecipients = (
+ record: BroadcastEventRecord | undefined,
+ ): string[] | undefined => {
+ switch (metadataName) {
+ case 'navigationMenuItem':
+ return isNonEmptyString(record?.userWorkspaceId)
+ ? [record.userWorkspaceId]
+ : undefined;
+ case 'workflow': {
+ const ownerUserWorkspaceId = getPrivateWorkflowOwner(record);
+
+ return isNonEmptyString(ownerUserWorkspaceId)
+ ? [ownerUserWorkspaceId]
+ : undefined;
+ }
+ case 'workflowVersion': {
+ const coreWorkflowId = record?.coreWorkflowId;
+
+ if (
+ !isNonEmptyString(coreWorkflowId) ||
+ !isDefined(flatWorkflowMaps)
+ ) {
+ return undefined;
+ }
+
+ const parentFlatWorkflow = findFlatEntityByIdInFlatEntityMaps({
+ flatEntityMaps: flatWorkflowMaps,
+ flatEntityId: coreWorkflowId,
+ });
- const record = (
- event.type === 'deleted'
- ? event.properties.before
- : event.properties.after
- ) as { userWorkspaceId?: string | null } | undefined;
+ if (!isDefined(parentFlatWorkflow)) {
+ return [];
+ }
+
+ const ownerUserWorkspaceId =
+ getPrivateWorkflowOwner(parentFlatWorkflow);
+
+ return isNonEmptyString(ownerUserWorkspaceId)
+ ? [ownerUserWorkspaceId]
+ : undefined;
+ }
+ default:
+ return undefined;
+ }
+ };
+
+ const recipientUserWorkspaceIdsByRecordId = new Map<string, string[]>();
+
+ for (const event of events) {
+ const recipientUserWorkspaceIds = resolveRecipients(
+ getBroadcastEventRecord(event),
+ );
+
+ if (isDefined(recipientUserWorkspaceIds)) {
+ recipientUserWorkspaceIdsByRecordId.set(
+ event.recordId,
+ recipientUserWorkspaceIds,
+ );
+ }
+ }
- return record?.userWorkspaceId ?? undefined;
+ return recipientUserWorkspaceIdsByRecordId;
}
private async enrichMetadataEventBatch(
diff --git a/packages/twenty-server/src/engine/subscriptions/utils/__tests__/pick-broadcast-event-properties.util.spec.ts b/packages/twenty-server/src/engine/subscriptions/utils/__tests__/pick-broadcast-event-properties.util.spec.ts
new file mode 100644
index 00000000000..5edeb98dc8e
--- /dev/null
+++ b/packages/twenty-server/src/engine/subscriptions/utils/__tests__/pick-broadcast-event-properties.util.spec.ts
@@ -0,0 +1,53 @@
+import { pickBroadcastEventProperties } from 'src/engine/subscriptions/utils/pick-broadcast-event-properties.util';
+
+describe('pickBroadcastEventProperties', () => {
+ it('leaves an ungated entity untouched', () => {
+ const properties = {
+ after: { id: 'view-1', name: 'My view' },
+ };
+
+ expect(
+ pickBroadcastEventProperties({ entityName: 'view', properties }),
+ ).toEqual(properties);
+ });
+
+ it('keeps only the routing identifiers of a workflow', () => {
+ expect(
+ pickBroadcastEventProperties({
+ entityName: 'workflow',
+ properties: {
+ updatedFields: ['name'],
+ after: {
+ id: 'workflow-1',
+ name: 'Secret workflow',
+ visibility: 'PRIVATE',
+ },
+ },
+ }),
+ ).toEqual({
+ updatedFields: ['name'],
+ before: undefined,
+ after: { id: 'workflow-1' },
+ });
+ });
+
+ it('strips the steps of a deleted workflow version', () => {
+ expect(
+ pickBroadcastEventProperties({
+ entityName: 'workflowVersion',
+ properties: {
+ before: {
+ id: 'workflow-version-1',
+ coreWorkflowId: 'workflow-1',
+ steps: [{ type: 'CODE' }],
+ triggers: [{ type: 'MANUAL' }],
+ },
+ },
+ }),
+ ).toEqual({
+ updatedFields: undefined,
+ before: { id: 'workflow-version-1', coreWorkflowId: 'workflow-1' },
+ after: undefined,
+ });
+ });
+});
diff --git a/packages/twenty-server/src/engine/subscriptions/utils/pick-broadcast-event-properties.util.ts b/packages/twenty-server/src/engine/subscriptions/utils/pick-broadcast-event-properties.util.ts
new file mode 100644
index 00000000000..0cf4bd5d5c8
--- /dev/null
+++ b/packages/twenty-server/src/engine/subscriptions/utils/pick-broadcast-event-properties.util.ts
@@ -0,0 +1,36 @@
+import { isDefined } from 'twenty-shared/utils';
+
+import { getBroadcastPropertyKeysForGatedEntityName } from 'src/engine/subscriptions/constants/broadcast-property-keys-by-gated-entity-name.constant';
+import { type WorkspaceBroadcastEvent } from 'src/engine/subscriptions/workspace-event-broadcaster/types/workspace-broadcast-event.type';
+
+const pickRecordProperties = (
+ record: Record<string, unknown> | undefined,
+ propertyKeys: readonly string[],
+): Record<string, unknown> | undefined =>
+ isDefined(record)
+ ? Object.fromEntries(
+ propertyKeys
+ .filter((propertyKey) => propertyKey in record)
+ .map((propertyKey) => [propertyKey, record[propertyKey]]),
+ )
+ : undefined;
+
+export const pickBroadcastEventProperties = ({
+ entityName,
+ properties,
+}: {
+ entityName: string;
+ properties: WorkspaceBroadcastEvent['properties'];
+}): WorkspaceBroadcastEvent['properties'] => {
+ const propertyKeys = getBroadcastPropertyKeysForGatedEntityName(entityName);
+
+ if (!isDefined(propertyKeys)) {
+ return properties;
+ }
+
+ return {
+ updatedFields: properties.updatedFields,
+ before: pickRecordProperties(properties.before, propertyKeys),
+ after: pickRecordProperties(properties.after, propertyKeys),
+ };
+};
diff --git a/packages/twenty-server/src/engine/subscriptions/workspace-event-broadcaster/types/workspace-broadcast-event.type.ts b/packages/twenty-server/src/engine/subscriptions/workspace-event-broadcaster/types/workspace-broadcast-event.type.ts
index bc73d038ceb..de167fdce5c 100644
--- a/packages/twenty-server/src/engine/subscriptions/workspace-event-broadcaster/types/workspace-broadcast-event.type.ts
+++ b/packages/twenty-server/src/engine/subscriptions/workspace-event-broadcaster/types/workspace-broadcast-event.type.ts
@@ -1,3 +1,5 @@
+import { type PermissionFlagType } from 'twenty-shared/constants';
+
export type WorkspaceBroadcastEvent = {
type: 'created' | 'updated' | 'deleted';
entityName: string;
@@ -13,4 +15,9 @@ export type WorkspaceBroadcastEvent = {
// fields). Set for user-scoped entities (e.g. agentChatThread) so other users
// in the same workspace don't receive them.
recipientUserWorkspaceIds?: string[];
+ // Restricts delivery to streams whose user holds this settings permission
+ // flag. Metadata events are workspace-wide by default; entities whose
+ // existence is itself gated (workflows) set this so the channel cannot
+ // leak them to users who cannot read them.
+ requiredPermissionFlag?: PermissionFlagType;
};
diff --git a/packages/twenty-server/src/engine/subscriptions/workspace-event-broadcaster/workspace-event-broadcaster.service.ts b/packages/twenty-server/src/engine/subscriptions/workspace-event-broadcaster/workspace-event-broadcaster.service.ts
index b16adf7d453..9d8d7cba7c3 100644
--- a/packages/twenty-server/src/engine/subscriptions/workspace-event-broadcaster/workspace-event-broadcaster.service.ts
+++ b/packages/twenty-server/src/engine/subscriptions/workspace-event-broadcaster/workspace-event-broadcaster.service.ts
@@ -2,6 +2,10 @@ import { Injectable } from '@nestjs/common';
import { isDefined } from 'twenty-shared/utils';
+import { type PermissionFlagType } from 'twenty-shared/constants';
+
+import { WorkspaceManyOrAllFlatEntityMapsCacheService } from 'src/engine/metadata-modules/flat-entity/services/workspace-many-or-all-flat-entity-maps-cache.service';
+import { resolveUserWorkspaceIdsWithPermissionFlag } from 'src/engine/metadata-modules/permissions/utils/resolve-user-workspace-ids-with-permission-flag.util';
import { EventStreamService } from 'src/engine/subscriptions/event-stream.service';
import { SubscriptionService } from 'src/engine/subscriptions/subscription.service';
import { type EventStreamData } from 'src/engine/subscriptions/types/event-stream-data.type';
@@ -9,11 +13,19 @@ import { type EventStreamPayload } from 'src/engine/subscriptions/types/event-st
import { type QueueJobEvent } from 'src/engine/subscriptions/types/queue-job-event.type';
import { type WorkspaceBroadcastEvent } from 'src/engine/subscriptions/workspace-event-broadcaster/types/workspace-broadcast-event.type';
+// A stream carrying an application or an api key is narrower than the user it
+// authenticates: the read guard intersects the user role with the application
+// role, which this fan-out cannot evaluate, so a gated event must not reach it.
+const isStreamScopedToItsUser = (streamData: EventStreamData): boolean =>
+ !isDefined(streamData.authContext.applicationId) &&
+ !isDefined(streamData.authContext.apiKeyId);
+
@Injectable()
export class WorkspaceEventBroadcaster {
constructor(
private readonly eventStreamService: EventStreamService,
private readonly subscriptionService: SubscriptionService,
+ private readonly flatEntityMapsCacheService: WorkspaceManyOrAllFlatEntityMapsCacheService,
) {}
async broadcast({
@@ -29,11 +41,31 @@ export class WorkspaceEventBroadcaster {
return;
}
+ const allowedUserWorkspaceIdsByPermissionFlag =
+ await this.resolveAllowedUserWorkspaceIdsByPermissionFlag({
+ workspaceId,
+ events,
+ });
+
await this.publishToActiveStreams(workspaceId, (streamData) => {
const streamUserWorkspaceId = streamData.authContext.userWorkspaceId;
const metadataEventsForStream = events
.filter((event) => {
+ if (isDefined(event.requiredPermissionFlag)) {
+ const isStreamAllowed =
+ isStreamScopedToItsUser(streamData) &&
+ isDefined(streamUserWorkspaceId) &&
+ (allowedUserWorkspaceIdsByPermissionFlag
+ .get(event.requiredPermissionFlag)
+ ?.has(streamUserWorkspaceId) ??
+ false);
+
+ if (!isStreamAllowed) {
+ return false;
+ }
+ }
+
// Events without recipientUserWorkspaceIds are workspace-wide; delivered
// to every stream. Events with the field are user-scoped; only delivered
// to streams whose authContext.userWorkspaceId is in the list.
@@ -86,6 +118,59 @@ export class WorkspaceEventBroadcaster {
);
}
+ private async resolveAllowedUserWorkspaceIdsByPermissionFlag({
+ workspaceId,
+ events,
+ }: {
+ workspaceId: string;
+ events: WorkspaceBroadcastEvent[];
+ }): Promise<Map<PermissionFlagType, Set<string>>> {
+ const requiredPermissionFlags = new Set(
+ events
+ .map((event) => event.requiredPermissionFlag)
+ .filter((permissionFlag): permissionFlag is PermissionFlagType =>
+ isDefined(permissionFlag),
+ ),
+ );
+
+ const allowedUserWorkspaceIdsByPermissionFlag = new Map<
+ PermissionFlagType,
+ Set<string>
+ >();
+
+ if (requiredPermissionFlags.size === 0) {
+ return allowedUserWorkspaceIdsByPermissionFlag;
+ }
+
+ const { flatRoleMaps, flatRolePermissionFlagMaps, flatRoleTargetMaps } =
+ await this.flatEntityMapsCacheService.getOrRecomputeManyOrAllFlatEntityMaps(
+ {
+ workspaceId,
+ flatMapsKeys: [
+ 'flatRoleMaps',
+ 'flatRolePermissionFlagMaps',
+ 'flatRoleTargetMaps',
+ ],
+ },
+ );
+
+ for (const permissionFlag of requiredPermissionFlags) {
+ allowedUserWorkspaceIdsByPermissionFlag.set(
+ permissionFlag,
+ new Set(
+ resolveUserWorkspaceIdsWithPermissionFlag({
+ permissionFlag,
+ flatRoleMaps,
+ flatRolePermissionFlagMaps,
+ flatRoleTargetMaps,
+ }),
+ ),
+ );
+ }
+
+ return allowedUserWorkspaceIdsByPermissionFlag;
+ }
+
private async publishToActiveStreams(
workspaceId: string,
buildPayloadForStream: (
diff --git a/packages/twenty-server/src/engine/workspace-manager/workspace-migration/services/workspace-migration-build-orchestrator.service.ts b/packages/twenty-server/src/engine/workspace-manager/workspace-migration/services/workspace-migration-build-orchestrator.service.ts
index 3c6308c6274..1a083ace749 100644
--- a/packages/twenty-server/src/engine/workspace-manager/workspace-migration/services/workspace-migration-build-orchestrator.service.ts
+++ b/packages/twenty-server/src/engine/workspace-manager/workspace-migration/services/workspace-migration-build-orchestrator.service.ts
@@ -1,3 +1,5 @@
+import { WorkspaceMigrationWorkflowVersionActionsBuilderService } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-builder/builders/workflow-version/workspace-migration-workflow-version-actions-builder.service';
+import { WorkspaceMigrationWorkflowActionsBuilderService } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-builder/builders/workflow/workspace-migration-workflow-actions-builder.service';
import { Injectable } from '@nestjs/common';
import {
@@ -161,6 +163,8 @@ export class WorkspaceMigrationBuildOrchestratorService {
workspaceMigrationConnectionProviderActionsBuilderService: WorkspaceMigrationConnectionProviderActionsBuilderService,
workspaceMigrationTimelineActivityTypeActionsBuilderService: WorkspaceMigrationTimelineActivityTypeActionsBuilderService,
workspaceMigrationSearchFieldMetadataActionsBuilderService: WorkspaceMigrationSearchFieldMetadataActionsBuilderService,
+ workspaceMigrationWorkflowActionsBuilderService: WorkspaceMigrationWorkflowActionsBuilderService,
+ workspaceMigrationWorkflowVersionActionsBuilderService: WorkspaceMigrationWorkflowVersionActionsBuilderService,
) {
// The order of this array defines the execution order of the per-entity
// builders. Each builder may mutate `optimisticAllFlatEntityMaps`, so
@@ -297,6 +301,14 @@ export class WorkspaceMigrationBuildOrchestratorService {
ALL_METADATA_NAME.timelineActivityType,
workspaceMigrationTimelineActivityTypeActionsBuilderService,
),
+ createEntityActionsBuilderTask(
+ ALL_METADATA_NAME.workflow,
+ workspaceMigrationWorkflowActionsBuilderService,
+ ),
+ createEntityActionsBuilderTask(
+ ALL_METADATA_NAME.workflowVersion,
+ workspaceMigrationWorkflowVersionActionsBuilderService,
+ ),
];
}
diff --git a/packages/twenty-server/src/engine/workspace-manager/workspace-migration/universal-flat-entity/constants/__tests__/__snapshots__/all-universal-flat-entity-foreign-key-aggregator-properties.constant.spec.ts.snap b/packages/twenty-server/src/engine/workspace-manager/workspace-migration/universal-flat-entity/constants/__tests__/__snapshots__/all-universal-flat-entity-foreign-key-aggregator-properties.constant.spec.ts.snap
index 2a1518f5862..436501eda36 100644
--- a/packages/twenty-server/src/engine/workspace-manager/workspace-migration/universal-flat-entity/constants/__tests__/__snapshots__/all-universal-flat-entity-foreign-key-aggregator-properties.constant.spec.ts.snap
+++ b/packages/twenty-server/src/engine/workspace-manager/workspace-migration/universal-flat-entity/constants/__tests__/__snapshots__/all-universal-flat-entity-foreign-key-aggregator-properties.constant.spec.ts.snap
@@ -84,5 +84,7 @@ exports[`ALL_UNIVERSAL_FLAT_ENTITY_FOREIGN_KEY_AGGREGATOR_PROPERTIES should matc
"viewGroup": [],
"viewSort": [],
"webhook": [],
+ "workflow": [],
+ "workflowVersion": [],
}
`;
diff --git a/packages/twenty-server/src/engine/workspace-manager/workspace-migration/universal-flat-entity/constants/all-jsonb-properties-with-serialized-relation-by-metadata-name.constant.ts b/packages/twenty-server/src/engine/workspace-manager/workspace-migration/universal-flat-entity/constants/all-jsonb-properties-with-serialized-relation-by-metadata-name.constant.ts
index 3a2ae45517f..b2e3bbb0914 100644
--- a/packages/twenty-server/src/engine/workspace-manager/workspace-migration/universal-flat-entity/constants/all-jsonb-properties-with-serialized-relation-by-metadata-name.constant.ts
+++ b/packages/twenty-server/src/engine/workspace-manager/workspace-migration/universal-flat-entity/constants/all-jsonb-properties-with-serialized-relation-by-metadata-name.constant.ts
@@ -51,6 +51,8 @@ export const ALL_JSONB_PROPERTIES_WITH_SERIALIZED_RELATION_BY_METADATA_NAME = {
connectionProvider: {},
timelineActivityType: {},
searchFieldMetadata: {},
+ workflow: {},
+ workflowVersion: {},
} as const satisfies {
[P in AllMetadataName]: Partial<{
// TODO prastoin: improve strict typing to recursively serach for nested SerializedRelation
diff --git a/packages/twenty-server/src/engine/workspace-manager/workspace-migration/universal-flat-entity/types/universal-flat-workflow-version.type.ts b/packages/twenty-server/src/engine/workspace-manager/workspace-migration/universal-flat-entity/types/universal-flat-workflow-version.type.ts
new file mode 100644
index 00000000000..b782d178a28
--- /dev/null
+++ b/packages/twenty-server/src/engine/workspace-manager/workspace-migration/universal-flat-entity/types/universal-flat-workflow-version.type.ts
@@ -0,0 +1,7 @@
+import { type WorkflowVersionEntity } from 'src/engine/core-modules/workflow/entities/workflow-version.entity';
+import { type UniversalFlatEntityFrom } from 'src/engine/workspace-manager/workspace-migration/universal-flat-entity/types/universal-flat-entity-from.type';
+
+export type UniversalFlatWorkflowVersion = UniversalFlatEntityFrom<
+ WorkflowVersionEntity,
+ 'workflowVersion'
+>;
diff --git a/packages/twenty-server/src/engine/workspace-manager/workspace-migration/universal-flat-entity/types/universal-flat-workflow.type.ts b/packages/twenty-server/src/engine/workspace-manager/workspace-migration/universal-flat-entity/types/universal-flat-workflow.type.ts
new file mode 100644
index 00000000000..49d1486b740
--- /dev/null
+++ b/packages/twenty-server/src/engine/workspace-manager/workspace-migration/universal-flat-entity/types/universal-flat-workflow.type.ts
@@ -0,0 +1,7 @@
+import { type WorkflowEntity } from 'src/engine/core-modules/workflow/entities/workflow.entity';
+import { type UniversalFlatEntityFrom } from 'src/engine/workspace-manager/workspace-migration/universal-flat-entity/types/universal-flat-entity-from.type';
+
+export type UniversalFlatWorkflow = UniversalFlatEntityFrom<
+ WorkflowEntity,
+ 'workflow'
+>;
diff --git a/packages/twenty-server/src/engine/workspace-manager/workspace-migration/utils/compute-ordered-migration-actions.util.ts b/packages/twenty-server/src/engine/workspace-manager/workspace-migration/utils/compute-ordered-migration-actions.util.ts
index 0c3669aa8b3..64fe797a184 100644
--- a/packages/twenty-server/src/engine/workspace-manager/workspace-migration/utils/compute-ordered-migration-actions.util.ts
+++ b/packages/twenty-server/src/engine/workspace-manager/workspace-migration/utils/compute-ordered-migration-actions.util.ts
@@ -41,6 +41,13 @@ export const computeOrderedMigrationActions = (
...aggregatedOrchestratorActionsReport.viewSort.delete,
...aggregatedOrchestratorActionsReport.view.delete,
+ ...aggregatedOrchestratorActionsReport.workflowVersion.delete,
+ ...aggregatedOrchestratorActionsReport.workflow.delete,
+ ...aggregatedOrchestratorActionsReport.workflow.create,
+ ...aggregatedOrchestratorActionsReport.workflow.update,
+ ...aggregatedOrchestratorActionsReport.workflowVersion.create,
+ ...aggregatedOrchestratorActionsReport.workflowVersion.update,
+
...aggregatedOrchestratorActionsReport.logicFunction.delete,
...aggregatedOrchestratorActionsReport.logicFunction.create,
...aggregatedOrchestratorActionsReport.logicFunction.update,
diff --git a/packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-builder/builders/workflow-version/types/workspace-migration-workflow-version-action.type.ts b/packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-builder/builders/workflow-version/types/workspace-migration-workflow-version-action.type.ts
new file mode 100644
index 00000000000..da5963c0016
--- /dev/null
+++ b/packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-builder/builders/workflow-version/types/workspace-migration-workflow-version-action.type.ts
@@ -0,0 +1,24 @@
+import { type BaseFlatCreateWorkspaceMigrationAction } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-builder/types/base-flat-create-workspace-migration-action.type';
+import { type BaseFlatDeleteWorkspaceMigrationAction } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-builder/types/base-flat-delete-workspace-migration-action.type';
+import { type BaseFlatUpdateWorkspaceMigrationAction } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-builder/types/base-flat-update-workspace-migration-action.type';
+import { type BaseUniversalCreateWorkspaceMigrationAction } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-builder/types/base-universal-create-workspace-migration-action.type';
+import { type BaseUniversalDeleteWorkspaceMigrationAction } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-builder/types/base-universal-delete-workspace-migration-action.type';
+import { type BaseUniversalUpdateWorkspaceMigrationAction } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-builder/types/base-universal-update-workspace-migration-action.type';
+
+export type FlatCreateWorkflowVersionAction =
+ BaseFlatCreateWorkspaceMigrationAction<'workflowVersion'>;
+
+export type UniversalCreateWorkflowVersionAction =
+ BaseUniversalCreateWorkspaceMigrationAction<'workflowVersion'>;
+
+export type FlatUpdateWorkflowVersionAction =
+ BaseFlatUpdateWorkspaceMigrationAction<'workflowVersion'>;
+
+export type UniversalUpdateWorkflowVersionAction =
+ BaseUniversalUpdateWorkspaceMigrationAction<'workflowVersion'>;
+
+export type UniversalDeleteWorkflowVersionAction =
+ BaseUniversalDeleteWorkspaceMigrationAction<'workflowVersion'>;
+
+export type FlatDeleteWorkflowVersionAction =
+ BaseFlatDeleteWorkspaceMigrationAction<'workflowVersion'>;
diff --git a/packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-builder/builders/workflow-version/workspace-migration-workflow-version-actions-builder.service.ts b/packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-builder/builders/workflow-version/workspace-migration-workflow-version-actions-builder.service.ts
new file mode 100644
index 00000000000..e9617825ab7
--- /dev/null
+++ b/packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-builder/builders/workflow-version/workspace-migration-workflow-version-actions-builder.service.ts
@@ -0,0 +1,120 @@
+import { Injectable } from '@nestjs/common';
+
+import { ALL_METADATA_NAME } from 'twenty-shared/metadata';
+
+import { UniversalUpdateWorkflowVersionAction } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-builder/builders/workflow-version/types/workspace-migration-workflow-version-action.type';
+import { WorkspaceEntityMigrationBuilderService } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-builder/services/workspace-entity-migration-builder.service';
+import { FlatEntityUpdateValidationArgs } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-builder/types/universal-flat-entity-update-validation-args.type';
+import { UniversalFlatEntityValidationArgs } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-builder/types/universal-flat-entity-validation-args.type';
+import { UniversalFlatEntityValidationReturnType } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-builder/types/universal-flat-entity-validation-result.type';
+import { FlatWorkflowVersionValidatorService } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-builder/validators/services/flat-workflow-version-validator.service';
+
+@Injectable()
+export class WorkspaceMigrationWorkflowVersionActionsBuilderService extends WorkspaceEntityMigrationBuilderService<
+ typeof ALL_METADATA_NAME.workflowVersion
+> {
+ constructor(
+ private readonly flatWorkflowVersionValidatorService: FlatWorkflowVersionValidatorService,
+ ) {
+ super(ALL_METADATA_NAME.workflowVersion);
+ }
+
+ protected validateFlatEntityCreation(
+ args: UniversalFlatEntityValidationArgs<
+ typeof ALL_METADATA_NAME.workflowVersion
+ >,
+ ): UniversalFlatEntityValidationReturnType<
+ typeof ALL_METADATA_NAME.workflowVersion,
+ 'create'
+ > {
+ const validationResult =
+ this.flatWorkflowVersionValidatorService.validateFlatWorkflowVersionCreation(
+ args,
+ );
+
+ if (validationResult.errors.length > 0) {
+ return {
+ status: 'fail',
+ ...validationResult,
+ };
+ }
+
+ const { flatEntityToValidate: flatWorkflowVersionToValidate } = args;
+
+ return {
+ status: 'success',
+ action: {
+ type: 'create',
+ metadataName: 'workflowVersion',
+ flatEntity: flatWorkflowVersionToValidate,
+ },
+ };
+ }
+
+ protected validateFlatEntityDeletion(
+ args: UniversalFlatEntityValidationArgs<
+ typeof ALL_METADATA_NAME.workflowVersion
+ >,
+ ): UniversalFlatEntityValidationReturnType<
+ typeof ALL_METADATA_NAME.workflowVersion,
+ 'delete'
+ > {
+ const validationResult =
+ this.flatWorkflowVersionValidatorService.validateFlatWorkflowVersionDeletion(
+ args,
+ );
+
+ if (validationResult.errors.length > 0) {
+ return {
+ status: 'fail',
+ ...validationResult,
+ };
+ }
+
+ const { flatEntityToValidate: flatWorkflowVersionToValidate } = args;
+
+ return {
+ status: 'success',
+ action: {
+ type: 'delete',
+ metadataName: 'workflowVersion',
+ universalIdentifier: flatWorkflowVersionToValidate.universalIdentifier,
+ },
+ };
+ }
+
+ protected validateFlatEntityUpdate(
+ args: FlatEntityUpdateValidationArgs<
+ typeof ALL_METADATA_NAME.workflowVersion
+ >,
+ ): UniversalFlatEntityValidationReturnType<
+ typeof ALL_METADATA_NAME.workflowVersion,
+ 'update'
+ > {
+ const validationResult =
+ this.flatWorkflowVersionValidatorService.validateFlatWorkflowVersionUpdate(
+ args,
+ );
+
+ if (validationResult.errors.length > 0) {
+ return {
+ status: 'fail',
+ ...validationResult,
+ };
+ }
+
+ const { universalIdentifier, flatEntityUpdate } = args;
+
+ const updateWorkflowVersionAction: UniversalUpdateWorkflowVersionAction = {
+ type: 'update',
+ metadataName: 'workflowVersion',
+ universalIdentifier,
+ update: flatEntityUpdate,
+ };
+
+ return {
+ status: 'success',
+ action: updateWorkflowVersionAction,
+ };
+ }
+}
diff --git a/packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-builder/builders/workflow/types/workspace-migration-workflow-action.type.ts b/packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-builder/builders/workflow/types/workspace-migration-workflow-action.type.ts
new file mode 100644
index 00000000000..99ab958c148
--- /dev/null
+++ b/packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-builder/builders/workflow/types/workspace-migration-workflow-action.type.ts
@@ -0,0 +1,24 @@
+import { type BaseFlatCreateWorkspaceMigrationAction } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-builder/types/base-flat-create-workspace-migration-action.type';
+import { type BaseFlatDeleteWorkspaceMigrationAction } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-builder/types/base-flat-delete-workspace-migration-action.type';
+import { type BaseFlatUpdateWorkspaceMigrationAction } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-builder/types/base-flat-update-workspace-migration-action.type';
+import { type BaseUniversalCreateWorkspaceMigrationAction } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-builder/types/base-universal-create-workspace-migration-action.type';
+import { type BaseUniversalDeleteWorkspaceMigrationAction } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-builder/types/base-universal-delete-workspace-migration-action.type';
+import { type BaseUniversalUpdateWorkspaceMigrationAction } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-builder/types/base-universal-update-workspace-migration-action.type';
+
+export type FlatCreateWorkflowAction =
+ BaseFlatCreateWorkspaceMigrationAction<'workflow'>;
+
+export type UniversalCreateWorkflowAction =
+ BaseUniversalCreateWorkspaceMigrationAction<'workflow'>;
+
+export type FlatUpdateWorkflowAction =
+ BaseFlatUpdateWorkspaceMigrationAction<'workflow'>;
+
+export type UniversalUpdateWorkflowAction =
+ BaseUniversalUpdateWorkspaceMigrationAction<'workflow'>;
+
+export type UniversalDeleteWorkflowAction =
+ BaseUniversalDeleteWorkspaceMigrationAction<'workflow'>;
+
+export type FlatDeleteWorkflowAction =
+ BaseFlatDeleteWorkspaceMigrationAction<'workflow'>;
diff --git a/packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-builder/builders/workflow/workspace-migration-workflow-actions-builder.service.ts b/packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-builder/builders/workflow/workspace-migration-workflow-actions-builder.service.ts
new file mode 100644
index 00000000000..9586a33e4b2
--- /dev/null
+++ b/packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-builder/builders/workflow/workspace-migration-workflow-actions-builder.service.ts
@@ -0,0 +1,108 @@
+import { Injectable } from '@nestjs/common';
+
+import { ALL_METADATA_NAME } from 'twenty-shared/metadata';
+
+import { UniversalUpdateWorkflowAction } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-builder/builders/workflow/types/workspace-migration-workflow-action.type';
+import { WorkspaceEntityMigrationBuilderService } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-builder/services/workspace-entity-migration-builder.service';
+import { FlatEntityUpdateValidationArgs } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-builder/types/universal-flat-entity-update-validation-args.type';
+import { UniversalFlatEntityValidationArgs } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-builder/types/universal-flat-entity-validation-args.type';
+import { UniversalFlatEntityValidationReturnType } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-builder/types/universal-flat-entity-validation-result.type';
+import { FlatWorkflowValidatorService } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-builder/validators/services/flat-workflow-validator.service';
+
+@Injectable()
+export class WorkspaceMigrationWorkflowActionsBuilderService extends WorkspaceEntityMigrationBuilderService<
+ typeof ALL_METADATA_NAME.workflow
+> {
+ constructor(
+ private readonly flatWorkflowValidatorService: FlatWorkflowValidatorService,
+ ) {
+ super(ALL_METADATA_NAME.workflow);
+ }
+
+ protected validateFlatEntityCreation(
+ args: UniversalFlatEntityValidationArgs<typeof ALL_METADATA_NAME.workflow>,
+ ): UniversalFlatEntityValidationReturnType<
+ typeof ALL_METADATA_NAME.workflow,
+ 'create'
+ > {
+ const validationResult =
+ this.flatWorkflowValidatorService.validateFlatWorkflowCreation(args);
+
+ if (validationResult.errors.length > 0) {
+ return {
+ status: 'fail',
+ ...validationResult,
+ };
+ }
+
+ const { flatEntityToValidate: flatWorkflowToValidate } = args;
+
+ return {
+ status: 'success',
+ action: {
+ type: 'create',
+ metadataName: 'workflow',
+ flatEntity: flatWorkflowToValidate,
+ },
+ };
+ }
+
+ protected validateFlatEntityDeletion(
+ args: UniversalFlatEntityValidationArgs<typeof ALL_METADATA_NAME.workflow>,
+ ): UniversalFlatEntityValidationReturnType<
+ typeof ALL_METADATA_NAME.workflow,
+ 'delete'
+ > {
+ const validationResult =
+ this.flatWorkflowValidatorService.validateFlatWorkflowDeletion(args);
+
+ if (validationResult.errors.length > 0) {
+ return {
+ status: 'fail',
+ ...validationResult,
+ };
+ }
+
+ const { flatEntityToValidate: flatWorkflowToValidate } = args;
+
+ return {
+ status: 'success',
+ action: {
+ type: 'delete',
+ metadataName: 'workflow',
+ universalIdentifier: flatWorkflowToValidate.universalIdentifier,
+ },
+ };
+ }
+
+ protected validateFlatEntityUpdate(
+ args: FlatEntityUpdateValidationArgs<typeof ALL_METADATA_NAME.workflow>,
+ ): UniversalFlatEntityValidationReturnType<
+ typeof ALL_METADATA_NAME.workflow,
+ 'update'
+ > {
+ const validationResult =
+ this.flatWorkflowValidatorService.validateFlatWorkflowUpdate(args);
+
+ if (validationResult.errors.length > 0) {
+ return {
+ status: 'fail',
+ ...validationResult,
+ };
+ }
+
+ const { universalIdentifier, flatEntityUpdate } = args;
+
+ const updateWorkflowAction: UniversalUpdateWorkflowAction = {
+ type: 'update',
+ metadataName: 'workflow',
+ universalIdentifier,
+ update: flatEntityUpdate,
+ };
+
+ return {
+ status: 'success',
+ action: updateWorkflowAction,
+ };
+ }
+}
diff --git a/packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-builder/validators/services/flat-workflow-validator.service.ts b/packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-builder/validators/services/flat-workflow-validator.service.ts
new file mode 100644
index 00000000000..e0b378f12e1
--- /dev/null
+++ b/packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-builder/validators/services/flat-workflow-validator.service.ts
@@ -0,0 +1,113 @@
+import { Injectable } from '@nestjs/common';
+
+import { msg, t } from '@lingui/core/macro';
+import { ALL_METADATA_NAME } from 'twenty-shared/metadata';
+import { isDefined } from 'twenty-shared/utils';
+
+import { CoreWorkflowMetadataExceptionCode } from 'src/engine/core-modules/workflow/exceptions/core-workflow-metadata.exception';
+import { findFlatEntityByUniversalIdentifier } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-universal-identifier.util';
+import { type FailedFlatEntityValidation } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-builder/builders/types/failed-flat-entity-validation.type';
+import { getEmptyFlatEntityValidationError } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-builder/builders/utils/get-flat-entity-validation-error.util';
+import { type FlatEntityUpdateValidationArgs } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-builder/types/universal-flat-entity-update-validation-args.type';
+import { type UniversalFlatEntityValidationArgs } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-builder/types/universal-flat-entity-validation-args.type';
+
+@Injectable()
+export class FlatWorkflowValidatorService {
+ public validateFlatWorkflowCreation({
+ flatEntityToValidate: flatWorkflow,
+ optimisticFlatEntityMapsAndRelatedFlatEntityMaps: {
+ flatWorkflowMaps: optimisticFlatWorkflowMaps,
+ },
+ }: UniversalFlatEntityValidationArgs<
+ typeof ALL_METADATA_NAME.workflow
+ >): FailedFlatEntityValidation<'workflow', 'create'> {
+ const validationResult = getEmptyFlatEntityValidationError({
+ flatEntityMinimalInformation: {
+ universalIdentifier: flatWorkflow.universalIdentifier,
+ name: flatWorkflow.name ?? undefined,
+ },
+ metadataName: 'workflow',
+ type: 'create',
+ });
+
+ const existingWorkflow = findFlatEntityByUniversalIdentifier({
+ universalIdentifier: flatWorkflow.universalIdentifier,
+ flatEntityMaps: optimisticFlatWorkflowMaps,
+ });
+
+ if (isDefined(existingWorkflow)) {
+ validationResult.errors.push({
+ code: CoreWorkflowMetadataExceptionCode.WORKFLOW_ALREADY_EXISTS,
+ message: t`Workflow already exists`,
+ userFriendlyMessage: msg`This workflow already exists`,
+ });
+ }
+
+ return validationResult;
+ }
+
+ public validateFlatWorkflowDeletion({
+ flatEntityToValidate,
+ optimisticFlatEntityMapsAndRelatedFlatEntityMaps: {
+ flatWorkflowMaps: optimisticFlatWorkflowMaps,
+ },
+ }: UniversalFlatEntityValidationArgs<
+ typeof ALL_METADATA_NAME.workflow
+ >): FailedFlatEntityValidation<'workflow', 'delete'> {
+ const validationResult = getEmptyFlatEntityValidationError({
+ flatEntityMinimalInformation: {
+ universalIdentifier: flatEntityToValidate.universalIdentifier,
+ name: flatEntityToValidate.name ?? undefined,
+ },
+ metadataName: 'workflow',
+ type: 'delete',
+ });
+
+ const existingWorkflow = findFlatEntityByUniversalIdentifier({
+ universalIdentifier: flatEntityToValidate.universalIdentifier,
+ flatEntityMaps: optimisticFlatWorkflowMaps,
+ });
+
+ if (!isDefined(existingWorkflow)) {
+ validationResult.errors.push({
+ code: CoreWorkflowMetadataExceptionCode.WORKFLOW_NOT_FOUND,
+ message: t`Workflow not found`,
+ userFriendlyMessage: msg`Workflow not found`,
+ });
+ }
+
+ return validationResult;
+ }
+
+ public validateFlatWorkflowUpdate({
+ universalIdentifier,
+ optimisticFlatEntityMapsAndRelatedFlatEntityMaps: {
+ flatWorkflowMaps: optimisticFlatWorkflowMaps,
+ },
+ }: FlatEntityUpdateValidationArgs<
+ typeof ALL_METADATA_NAME.workflow
+ >): FailedFlatEntityValidation<'workflow', 'update'> {
+ const validationResult = getEmptyFlatEntityValidationError({
+ flatEntityMinimalInformation: {
+ universalIdentifier,
+ },
+ metadataName: 'workflow',
+ type: 'update',
+ });
+
+ const existingWorkflow = findFlatEntityByUniversalIdentifier({
+ universalIdentifier,
+ flatEntityMaps: optimisticFlatWorkflowMaps,
+ });
+
+ if (!isDefined(existingWorkflow)) {
+ validationResult.errors.push({
+ code: CoreWorkflowMetadataExceptionCode.WORKFLOW_NOT_FOUND,
+ message: t`Workflow not found`,
+ userFriendlyMessage: msg`Workflow not found`,
+ });
+ }
+
+ return validationResult;
+ }
+}
diff --git a/packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-builder/validators/services/flat-workflow-version-validator.service.ts b/packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-builder/validators/services/flat-workflow-version-validator.service.ts
new file mode 100644
index 00000000000..e52bfc08106
--- /dev/null
+++ b/packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-builder/validators/services/flat-workflow-version-validator.service.ts
@@ -0,0 +1,111 @@
+import { Injectable } from '@nestjs/common';
+
+import { msg, t } from '@lingui/core/macro';
+import { ALL_METADATA_NAME } from 'twenty-shared/metadata';
+import { isDefined } from 'twenty-shared/utils';
+
+import { CoreWorkflowMetadataExceptionCode } from 'src/engine/core-modules/workflow/exceptions/core-workflow-metadata.exception';
+import { findFlatEntityByUniversalIdentifier } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-universal-identifier.util';
+import { type FailedFlatEntityValidation } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-builder/builders/types/failed-flat-entity-validation.type';
+import { getEmptyFlatEntityValidationError } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-builder/builders/utils/get-flat-entity-validation-error.util';
+import { type FlatEntityUpdateValidationArgs } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-builder/types/universal-flat-entity-update-validation-args.type';
+import { type UniversalFlatEntityValidationArgs } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-builder/types/universal-flat-entity-validation-args.type';
+
+@Injectable()
+export class FlatWorkflowVersionValidatorService {
+ public validateFlatWorkflowVersionCreation({
+ flatEntityToValidate: flatWorkflowVersion,
+ optimisticFlatEntityMapsAndRelatedFlatEntityMaps: {
+ flatWorkflowVersionMaps: optimisticFlatWorkflowVersionMaps,
+ },
+ }: UniversalFlatEntityValidationArgs<
+ typeof ALL_METADATA_NAME.workflowVersion
+ >): FailedFlatEntityValidation<'workflowVersion', 'create'> {
+ const validationResult = getEmptyFlatEntityValidationError({
+ flatEntityMinimalInformation: {
+ universalIdentifier: flatWorkflowVersion.universalIdentifier,
+ },
+ metadataName: 'workflowVersion',
+ type: 'create',
+ });
+
+ const existingWorkflowVersion = findFlatEntityByUniversalIdentifier({
+ universalIdentifier: flatWorkflowVersion.universalIdentifier,
+ flatEntityMaps: optimisticFlatWorkflowVersionMaps,
+ });
+
+ if (isDefined(existingWorkflowVersion)) {
+ validationResult.errors.push({
+ code: CoreWorkflowMetadataExceptionCode.WORKFLOW_VERSION_ALREADY_EXISTS,
+ message: t`Workflow version already exists`,
+ userFriendlyMessage: msg`This workflow version already exists`,
+ });
+ }
+
+ return validationResult;
+ }
+
+ public validateFlatWorkflowVersionDeletion({
+ flatEntityToValidate,
+ optimisticFlatEntityMapsAndRelatedFlatEntityMaps: {
+ flatWorkflowVersionMaps: optimisticFlatWorkflowVersionMaps,
+ },
+ }: UniversalFlatEntityValidationArgs<
+ typeof ALL_METADATA_NAME.workflowVersion
+ >): FailedFlatEntityValidation<'workflowVersion', 'delete'> {
+ const validationResult = getEmptyFlatEntityValidationError({
+ flatEntityMinimalInformation: {
+ universalIdentifier: flatEntityToValidate.universalIdentifier,
+ },
+ metadataName: 'workflowVersion',
+ type: 'delete',
+ });
+
+ const existingWorkflowVersion = findFlatEntityByUniversalIdentifier({
+ universalIdentifier: flatEntityToValidate.universalIdentifier,
+ flatEntityMaps: optimisticFlatWorkflowVersionMaps,
+ });
+
+ if (!isDefined(existingWorkflowVersion)) {
+ validationResult.errors.push({
+ code: CoreWorkflowMetadataExceptionCode.WORKFLOW_VERSION_NOT_FOUND,
+ message: t`Workflow version not found`,
+ userFriendlyMessage: msg`Workflow version not found`,
+ });
+ }
+
+ return validationResult;
+ }
+
+ public validateFlatWorkflowVersionUpdate({
+ universalIdentifier,
+ optimisticFlatEntityMapsAndRelatedFlatEntityMaps: {
+ flatWorkflowVersionMaps: optimisticFlatWorkflowVersionMaps,
+ },
+ }: FlatEntityUpdateValidationArgs<
+ typeof ALL_METADATA_NAME.workflowVersion
+ >): FailedFlatEntityValidation<'workflowVersion', 'update'> {
+ const validationResult = getEmptyFlatEntityValidationError({
+ flatEntityMinimalInformation: {
+ universalIdentifier,
+ },
+ metadataName: 'workflowVersion',
+ type: 'update',
+ });
+
+ const existingWorkflowVersion = findFlatEntityByUniversalIdentifier({
+ universalIdentifier,
+ flatEntityMaps: optimisticFlatWorkflowVersionMaps,
+ });
+
+ if (!isDefined(existingWorkflowVersion)) {
+ validationResult.errors.push({
+ code: CoreWorkflowMetadataExceptionCode.WORKFLOW_VERSION_NOT_FOUND,
+ message: t`Workflow version not found`,
+ userFriendlyMessage: msg`Workflow version not found`,
+ });
+ }
+
+ return validationResult;
+ }
+}
diff --git a/packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-builder/validators/workspace-migration-builder-validators.module.ts b/packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-builder/validators/workspace-migration-builder-validators.module.ts
index aa17e1b91d4..4b94ff90206 100644
--- a/packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-builder/validators/workspace-migration-builder-validators.module.ts
+++ b/packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-builder/validators/workspace-migration-builder-validators.module.ts
@@ -1,3 +1,5 @@
+import { FlatWorkflowVersionValidatorService } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-builder/validators/services/flat-workflow-version-validator.service';
+import { FlatWorkflowValidatorService } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-builder/validators/services/flat-workflow-validator.service';
import { Module } from '@nestjs/common';
import { FeatureFlagModule } from 'src/engine/core-modules/feature-flag/feature-flag.module';
@@ -36,6 +38,8 @@ import { FlatSearchFieldMetadataValidatorService } from 'src/engine/workspace-ma
@Module({
imports: [FeatureFlagModule],
providers: [
+ FlatWorkflowValidatorService,
+ FlatWorkflowVersionValidatorService,
FlatViewFieldValidatorService,
FlatViewFilterGroupValidatorService,
FlatViewGroupValidatorService,
@@ -69,6 +73,8 @@ import { FlatSearchFieldMetadataValidatorService } from 'src/engine/workspace-ma
FlatSearchFieldMetadataValidatorService,
],
exports: [
+ FlatWorkflowValidatorService,
+ FlatWorkflowVersionValidatorService,
FlatViewFieldValidatorService,
FlatViewFilterGroupValidatorService,
FlatViewGroupValidatorService,
diff --git a/packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-builder/workspace-migration-builder.module.ts b/packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-builder/workspace-migration-builder.module.ts
index e707f9f4c2a..a2cf2fff760 100644
--- a/packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-builder/workspace-migration-builder.module.ts
+++ b/packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-builder/workspace-migration-builder.module.ts
@@ -1,3 +1,5 @@
+import { WorkspaceMigrationWorkflowVersionActionsBuilderService } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-builder/builders/workflow-version/workspace-migration-workflow-version-actions-builder.service';
+import { WorkspaceMigrationWorkflowActionsBuilderService } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-builder/builders/workflow/workspace-migration-workflow-actions-builder.service';
import { Module } from '@nestjs/common';
import { FeatureFlagModule } from 'src/engine/core-modules/feature-flag/feature-flag.module';
@@ -44,6 +46,8 @@ import { WorkspaceMigrationBuilderValidatorsModule } from 'src/engine/workspace-
MetricsModule,
],
providers: [
+ WorkspaceMigrationWorkflowActionsBuilderService,
+ WorkspaceMigrationWorkflowVersionActionsBuilderService,
FlatFieldMetadataTypeValidatorService,
WorkspaceMigrationObjectActionsBuilderService,
WorkspaceMigrationViewActionsBuilderService,
@@ -79,6 +83,8 @@ import { WorkspaceMigrationBuilderValidatorsModule } from 'src/engine/workspace-
WorkspaceMigrationSearchFieldMetadataActionsBuilderService,
],
exports: [
+ WorkspaceMigrationWorkflowActionsBuilderService,
+ WorkspaceMigrationWorkflowVersionActionsBuilderService,
WorkspaceMigrationViewActionsBuilderService,
WorkspaceMigrationIndexActionsBuilderService,
WorkspaceMigrationObjectActionsBuilderService,
diff --git a/packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-runner/action-handlers/workflow-version/services/create-workflow-version-action-handler.service.ts b/packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-runner/action-handlers/workflow-version/services/create-workflow-version-action-handler.service.ts
new file mode 100644
index 00000000000..91be7c17fd1
--- /dev/null
+++ b/packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-runner/action-handlers/workflow-version/services/create-workflow-version-action-handler.service.ts
@@ -0,0 +1,65 @@
+import { Injectable } from '@nestjs/common';
+
+import { v4 } from 'uuid';
+
+import { WorkspaceMigrationRunnerActionHandler } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-runner/interfaces/workspace-migration-runner-action-handler-service.interface';
+
+import { getUniversalFlatEntityEmptyForeignKeyAggregators } from 'src/engine/workspace-manager/workspace-migration/universal-flat-entity/utils/reset-universal-flat-entity-foreign-key-aggregators.util';
+import {
+ FlatCreateWorkflowVersionAction,
+ UniversalCreateWorkflowVersionAction,
+} from 'src/engine/workspace-manager/workspace-migration/workspace-migration-builder/builders/workflow-version/types/workspace-migration-workflow-version-action.type';
+import {
+ WorkspaceMigrationActionRunnerArgs,
+ WorkspaceMigrationActionRunnerContext,
+} from 'src/engine/workspace-manager/workspace-migration/workspace-migration-runner/types/workspace-migration-action-runner-args.type';
+
+@Injectable()
+export class CreateWorkflowVersionActionHandlerService extends WorkspaceMigrationRunnerActionHandler(
+ 'create',
+ 'workflowVersion',
+) {
+ constructor() {
+ super();
+ }
+
+ override async transpileUniversalActionToFlatAction({
+ action,
+ flatApplication,
+ workspaceId,
+ }: WorkspaceMigrationActionRunnerArgs<UniversalCreateWorkflowVersionAction>): Promise<FlatCreateWorkflowVersionAction> {
+ const emptyUniversalForeignKeyAggregators =
+ getUniversalFlatEntityEmptyForeignKeyAggregators({
+ metadataName: 'workflowVersion',
+ });
+
+ return {
+ ...action,
+ flatEntity: {
+ ...action.flatEntity,
+ applicationId: flatApplication.id,
+ id: action.id ?? v4(),
+ workspaceId,
+ ...emptyUniversalForeignKeyAggregators,
+ },
+ };
+ }
+
+ async executeForMetadata(
+ context: WorkspaceMigrationActionRunnerContext<FlatCreateWorkflowVersionAction>,
+ ): Promise<void> {
+ const { flatAction, queryRunner } = context;
+ const { flatEntity } = flatAction;
+
+ await this.insertFlatEntitiesInRepository({
+ queryRunner,
+ flatEntities: [flatEntity],
+ });
+ }
+
+ async executeForWorkspaceSchema(
+ _context: WorkspaceMigrationActionRunnerContext<FlatCreateWorkflowVersionAction>,
+ ): Promise<void> {
+ return;
+ }
+}
diff --git a/packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-runner/action-handlers/workflow-version/services/delete-workflow-version-action-handler.service.ts b/packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-runner/action-handlers/workflow-version/services/delete-workflow-version-action-handler.service.ts
new file mode 100644
index 00000000000..c83be6e21e1
--- /dev/null
+++ b/packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-runner/action-handlers/workflow-version/services/delete-workflow-version-action-handler.service.ts
@@ -0,0 +1,51 @@
+import { Injectable } from '@nestjs/common';
+
+import { WorkspaceMigrationRunnerActionHandler } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-runner/interfaces/workspace-migration-runner-action-handler-service.interface';
+
+import { WorkflowVersionEntity } from 'src/engine/core-modules/workflow/entities/workflow-version.entity';
+import {
+ FlatDeleteWorkflowVersionAction,
+ UniversalDeleteWorkflowVersionAction,
+} from 'src/engine/workspace-manager/workspace-migration/workspace-migration-builder/builders/workflow-version/types/workspace-migration-workflow-version-action.type';
+import {
+ WorkspaceMigrationActionRunnerArgs,
+ WorkspaceMigrationActionRunnerContext,
+} from 'src/engine/workspace-manager/workspace-migration/workspace-migration-runner/types/workspace-migration-action-runner-args.type';
+
+@Injectable()
+export class DeleteWorkflowVersionActionHandlerService extends WorkspaceMigrationRunnerActionHandler(
+ 'delete',
+ 'workflowVersion',
+) {
+ constructor() {
+ super();
+ }
+
+ override async transpileUniversalActionToFlatAction(
+ context: WorkspaceMigrationActionRunnerArgs<UniversalDeleteWorkflowVersionAction>,
+ ): Promise<FlatDeleteWorkflowVersionAction> {
+ return this.transpileUniversalDeleteActionToFlatDeleteAction(context);
+ }
+
+ async executeForMetadata(
+ context: WorkspaceMigrationActionRunnerContext<FlatDeleteWorkflowVersionAction>,
+ ): Promise<void> {
+ const { flatAction, queryRunner, workspaceId } = context;
+
+ const workflowVersionRepository =
+ queryRunner.manager.getRepository<WorkflowVersionEntity>(
+ WorkflowVersionEntity,
+ );
+
+ await workflowVersionRepository.delete({
+ id: flatAction.entityId,
+ workspaceId,
+ });
+ }
+
+ async executeForWorkspaceSchema(
+ _context: WorkspaceMigrationActionRunnerContext<FlatDeleteWorkflowVersionAction>,
+ ): Promise<void> {
+ return;
+ }
+}
diff --git a/packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-runner/action-handlers/workflow-version/services/update-workflow-version-action-handler.service.ts b/packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-runner/action-handlers/workflow-version/services/update-workflow-version-action-handler.service.ts
new file mode 100644
index 00000000000..5d96629fc59
--- /dev/null
+++ b/packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-runner/action-handlers/workflow-version/services/update-workflow-version-action-handler.service.ts
@@ -0,0 +1,68 @@
+import { Injectable } from '@nestjs/common';
+
+import { WorkspaceMigrationRunnerActionHandler } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-runner/interfaces/workspace-migration-runner-action-handler-service.interface';
+
+import { WorkflowVersionEntity } from 'src/engine/core-modules/workflow/entities/workflow-version.entity';
+import { findFlatEntityByUniversalIdentifierOrThrow } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-universal-identifier-or-throw.util';
+import { resolveUniversalUpdateRelationIdentifiersToIds } from 'src/engine/workspace-manager/workspace-migration/universal-flat-entity/utils/resolve-universal-update-relation-identifiers-to-ids.util';
+import {
+ FlatUpdateWorkflowVersionAction,
+ UniversalUpdateWorkflowVersionAction,
+} from 'src/engine/workspace-manager/workspace-migration/workspace-migration-builder/builders/workflow-version/types/workspace-migration-workflow-version-action.type';
+import {
+ WorkspaceMigrationActionRunnerArgs,
+ WorkspaceMigrationActionRunnerContext,
+} from 'src/engine/workspace-manager/workspace-migration/workspace-migration-runner/types/workspace-migration-action-runner-args.type';
+
+@Injectable()
+export class UpdateWorkflowVersionActionHandlerService extends WorkspaceMigrationRunnerActionHandler(
+ 'update',
+ 'workflowVersion',
+) {
+ override async transpileUniversalActionToFlatAction(
+ context: WorkspaceMigrationActionRunnerArgs<UniversalUpdateWorkflowVersionAction>,
+ ): Promise<FlatUpdateWorkflowVersionAction> {
+ const { action, allFlatEntityMaps } = context;
+
+ const flatWorkflowVersion = findFlatEntityByUniversalIdentifierOrThrow({
+ flatEntityMaps: allFlatEntityMaps.flatWorkflowVersionMaps,
+ universalIdentifier: action.universalIdentifier,
+ });
+
+ const update = resolveUniversalUpdateRelationIdentifiersToIds({
+ metadataName: 'workflowVersion',
+ universalUpdate: action.update,
+ allFlatEntityMaps,
+ });
+
+ return {
+ type: 'update',
+ metadataName: 'workflowVersion',
+ entityId: flatWorkflowVersion.id,
+ update,
+ };
+ }
+
+ async executeForMetadata(
+ context: WorkspaceMigrationActionRunnerContext<FlatUpdateWorkflowVersionAction>,
+ ): Promise<void> {
+ const { flatAction, queryRunner, workspaceId } = context;
+ const { entityId, update } = flatAction;
+
+ const workflowVersionRepository =
+ queryRunner.manager.getRepository<WorkflowVersionEntity>(
+ WorkflowVersionEntity,
+ );
+
+ await workflowVersionRepository.update(
+ { id: entityId, workspaceId },
+ update,
+ );
+ }
+
+ async executeForWorkspaceSchema(
+ _context: WorkspaceMigrationActionRunnerContext<FlatUpdateWorkflowVersionAction>,
+ ): Promise<void> {
+ return;
+ }
+}
diff --git a/packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-runner/action-handlers/workflow/services/create-workflow-action-handler.service.ts b/packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-runner/action-handlers/workflow/services/create-workflow-action-handler.service.ts
new file mode 100644
index 00000000000..c0025e8dab1
--- /dev/null
+++ b/packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-runner/action-handlers/workflow/services/create-workflow-action-handler.service.ts
@@ -0,0 +1,65 @@
+import { Injectable } from '@nestjs/common';
+
+import { v4 } from 'uuid';
+
+import { WorkspaceMigrationRunnerActionHandler } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-runner/interfaces/workspace-migration-runner-action-handler-service.interface';
+
+import { getUniversalFlatEntityEmptyForeignKeyAggregators } from 'src/engine/workspace-manager/workspace-migration/universal-flat-entity/utils/reset-universal-flat-entity-foreign-key-aggregators.util';
+import {
+ FlatCreateWorkflowAction,
+ UniversalCreateWorkflowAction,
+} from 'src/engine/workspace-manager/workspace-migration/workspace-migration-builder/builders/workflow/types/workspace-migration-workflow-action.type';
+import {
+ WorkspaceMigrationActionRunnerArgs,
+ WorkspaceMigrationActionRunnerContext,
+} from 'src/engine/workspace-manager/workspace-migration/workspace-migration-runner/types/workspace-migration-action-runner-args.type';
+
+@Injectable()
+export class CreateWorkflowActionHandlerService extends WorkspaceMigrationRunnerActionHandler(
+ 'create',
+ 'workflow',
+) {
+ constructor() {
+ super();
+ }
+
+ override async transpileUniversalActionToFlatAction({
+ action,
+ flatApplication,
+ workspaceId,
+ }: WorkspaceMigrationActionRunnerArgs<UniversalCreateWorkflowAction>): Promise<FlatCreateWorkflowAction> {
+ const emptyUniversalForeignKeyAggregators =
+ getUniversalFlatEntityEmptyForeignKeyAggregators({
+ metadataName: 'workflow',
+ });
+
+ return {
+ ...action,
+ flatEntity: {
+ ...action.flatEntity,
+ applicationId: flatApplication.id,
+ id: action.id ?? v4(),
+ workspaceId,
+ ...emptyUniversalForeignKeyAggregators,
+ },
+ };
+ }
+
+ async executeForMetadata(
+ context: WorkspaceMigrationActionRunnerContext<FlatCreateWorkflowAction>,
+ ): Promise<void> {
+ const { flatAction, queryRunner } = context;
+ const { flatEntity } = flatAction;
+
+ await this.insertFlatEntitiesInRepository({
+ queryRunner,
+ flatEntities: [flatEntity],
+ });
+ }
+
+ async executeForWorkspaceSchema(
+ _context: WorkspaceMigrationActionRunnerContext<FlatCreateWorkflowAction>,
+ ): Promise<void> {
+ return;
+ }
+}
diff --git a/packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-runner/action-handlers/workflow/services/delete-workflow-action-handler.service.ts b/packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-runner/action-handlers/workflow/services/delete-workflow-action-handler.service.ts
new file mode 100644
index 00000000000..f2431efab97
--- /dev/null
+++ b/packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-runner/action-handlers/workflow/services/delete-workflow-action-handler.service.ts
@@ -0,0 +1,49 @@
+import { Injectable } from '@nestjs/common';
+
+import { WorkspaceMigrationRunnerActionHandler } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-runner/interfaces/workspace-migration-runner-action-handler-service.interface';
+
+import { WorkflowEntity } from 'src/engine/core-modules/workflow/entities/workflow.entity';
+import {
+ FlatDeleteWorkflowAction,
+ UniversalDeleteWorkflowAction,
+} from 'src/engine/workspace-manager/workspace-migration/workspace-migration-builder/builders/workflow/types/workspace-migration-workflow-action.type';
+import {
+ WorkspaceMigrationActionRunnerArgs,
+ WorkspaceMigrationActionRunnerContext,
+} from 'src/engine/workspace-manager/workspace-migration/workspace-migration-runner/types/workspace-migration-action-runner-args.type';
+
+@Injectable()
+export class DeleteWorkflowActionHandlerService extends WorkspaceMigrationRunnerActionHandler(
+ 'delete',
+ 'workflow',
+) {
+ constructor() {
+ super();
+ }
+
+ override async transpileUniversalActionToFlatAction(
+ context: WorkspaceMigrationActionRunnerArgs<UniversalDeleteWorkflowAction>,
+ ): Promise<FlatDeleteWorkflowAction> {
+ return this.transpileUniversalDeleteActionToFlatDeleteAction(context);
+ }
+
+ async executeForMetadata(
+ context: WorkspaceMigrationActionRunnerContext<FlatDeleteWorkflowAction>,
+ ): Promise<void> {
+ const { flatAction, queryRunner, workspaceId } = context;
+
+ const workflowRepository =
+ queryRunner.manager.getRepository<WorkflowEntity>(WorkflowEntity);
+
+ await workflowRepository.delete({
+ id: flatAction.entityId,
+ workspaceId,
+ });
+ }
+
+ async executeForWorkspaceSchema(
+ _context: WorkspaceMigrationActionRunnerContext<FlatDeleteWorkflowAction>,
+ ): Promise<void> {
+ return;
+ }
+}
diff --git a/packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-runner/action-handlers/workflow/services/update-workflow-action-handler.service.ts b/packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-runner/action-handlers/workflow/services/update-workflow-action-handler.service.ts
new file mode 100644
index 00000000000..8a459d2d353
--- /dev/null
+++ b/packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-runner/action-handlers/workflow/services/update-workflow-action-handler.service.ts
@@ -0,0 +1,63 @@
+import { Injectable } from '@nestjs/common';
+
+import { WorkspaceMigrationRunnerActionHandler } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-runner/interfaces/workspace-migration-runner-action-handler-service.interface';
+
+import { WorkflowEntity } from 'src/engine/core-modules/workflow/entities/workflow.entity';
+import { findFlatEntityByUniversalIdentifierOrThrow } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-universal-identifier-or-throw.util';
+import { resolveUniversalUpdateRelationIdentifiersToIds } from 'src/engine/workspace-manager/workspace-migration/universal-flat-entity/utils/resolve-universal-update-relation-identifiers-to-ids.util';
+import {
+ FlatUpdateWorkflowAction,
+ UniversalUpdateWorkflowAction,
+} from 'src/engine/workspace-manager/workspace-migration/workspace-migration-builder/builders/workflow/types/workspace-migration-workflow-action.type';
+import {
+ WorkspaceMigrationActionRunnerArgs,
+ WorkspaceMigrationActionRunnerContext,
+} from 'src/engine/workspace-manager/workspace-migration/workspace-migration-runner/types/workspace-migration-action-runner-args.type';
+
+@Injectable()
+export class UpdateWorkflowActionHandlerService extends WorkspaceMigrationRunnerActionHandler(
+ 'update',
+ 'workflow',
+) {
+ override async transpileUniversalActionToFlatAction(
+ context: WorkspaceMigrationActionRunnerArgs<UniversalUpdateWorkflowAction>,
+ ): Promise<FlatUpdateWorkflowAction> {
+ const { action, allFlatEntityMaps } = context;
+
+ const flatWorkflow = findFlatEntityByUniversalIdentifierOrThrow({
+ flatEntityMaps: allFlatEntityMaps.flatWorkflowMaps,
+ universalIdentifier: action.universalIdentifier,
+ });
+
+ const update = resolveUniversalUpdateRelationIdentifiersToIds({
+ metadataName: 'workflow',
+ universalUpdate: action.update,
+ allFlatEntityMaps,
+ });
+
+ return {
+ type: 'update',
+ metadataName: 'workflow',
+ entityId: flatWorkflow.id,
+ update,
+ };
+ }
+
+ async executeForMetadata(
+ context: WorkspaceMigrationActionRunnerContext<FlatUpdateWorkflowAction>,
+ ): Promise<void> {
+ const { flatAction, queryRunner, workspaceId } = context;
+ const { entityId, update } = flatAction;
+
+ const workflowRepository =
+ queryRunner.manager.getRepository<WorkflowEntity>(WorkflowEntity);
+
+ await workflowRepository.update({ id: entityId, workspaceId }, update);
+ }
+
+ async executeForWorkspaceSchema(
+ _context: WorkspaceMigrationActionRunnerContext<FlatUpdateWorkflowAction>,
+ ): Promise<void> {
+ return;
+ }
+}
diff --git a/packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-runner/action-handlers/workspace-schema-migration-runner-action-handlers.module.ts b/packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-runner/action-handlers/workspace-schema-migration-runner-action-handlers.module.ts
index 654c0b141b3..5898b11d2a5 100644
--- a/packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-runner/action-handlers/workspace-schema-migration-runner-action-handlers.module.ts
+++ b/packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-runner/action-handlers/workspace-schema-migration-runner-action-handlers.module.ts
@@ -1,3 +1,9 @@
+import { CreateWorkflowVersionActionHandlerService } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-runner/action-handlers/workflow-version/services/create-workflow-version-action-handler.service';
+import { DeleteWorkflowVersionActionHandlerService } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-runner/action-handlers/workflow-version/services/delete-workflow-version-action-handler.service';
+import { UpdateWorkflowVersionActionHandlerService } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-runner/action-handlers/workflow-version/services/update-workflow-version-action-handler.service';
+import { CreateWorkflowActionHandlerService } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-runner/action-handlers/workflow/services/create-workflow-action-handler.service';
+import { DeleteWorkflowActionHandlerService } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-runner/action-handlers/workflow/services/delete-workflow-action-handler.service';
+import { UpdateWorkflowActionHandlerService } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-runner/action-handlers/workflow/services/update-workflow-action-handler.service';
import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
@@ -110,6 +116,14 @@ import { UpdateSearchFieldMetadataActionHandlerService } from 'src/engine/worksp
MetricsModule,
],
providers: [
+ CreateWorkflowActionHandlerService,
+ UpdateWorkflowActionHandlerService,
+ DeleteWorkflowActionHandlerService,
+
+ CreateWorkflowVersionActionHandlerService,
+ UpdateWorkflowVersionActionHandlerService,
+ DeleteWorkflowVersionActionHandlerService,
+
CreateFieldActionHandlerService,
UpdateFieldActionHandlerService,
DeleteFieldActionHandlerService,
diff --git a/packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-runner/constants/metadata-event-to-emit.constant.ts b/packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-runner/constants/metadata-event-to-emit.constant.ts
index 1c99c4704af..729ab1d74c0 100644
--- a/packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-runner/constants/metadata-event-to-emit.constant.ts
+++ b/packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-runner/constants/metadata-event-to-emit.constant.ts
@@ -33,4 +33,6 @@ export const METADATA_EVENTS_TO_EMIT = {
connectionProvider: true,
timelineActivityType: true,
searchFieldMetadata: true,
+ workflow: true,
+ workflowVersion: true,
} as const satisfies { [P in AllMetadataName]: boolean };
diff --git a/packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-runner/utils/derive-metadata-events-from-create-action.util.ts b/packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-runner/utils/derive-metadata-events-from-create-action.util.ts
index e2f905aa54c..03b0eb235aa 100644
--- a/packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-runner/utils/derive-metadata-events-from-create-action.util.ts
+++ b/packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-runner/utils/derive-metadata-events-from-create-action.util.ts
@@ -98,6 +98,8 @@ const deriveAllMetadataEventsFromCreateAction = (
case 'fieldPermission':
case 'viewSort':
case 'webhook':
+ case 'workflow':
+ case 'workflowVersion':
case 'connectionProvider':
case 'timelineActivityType':
case 'searchFieldMetadata': {
diff --git a/packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-runner/utils/derive-metadata-events-from-delete-action.util.ts b/packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-runner/utils/derive-metadata-events-from-delete-action.util.ts
index cef1ce1f4ef..5746eb33fe6 100644
--- a/packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-runner/utils/derive-metadata-events-from-delete-action.util.ts
+++ b/packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-runner/utils/derive-metadata-events-from-delete-action.util.ts
@@ -62,6 +62,8 @@ const deriveAllMetadataEventsFromDeleteAction = ({
case 'fieldPermission':
case 'viewSort':
case 'webhook':
+ case 'workflow':
+ case 'workflowVersion':
case 'connectionProvider':
case 'timelineActivityType':
case 'searchFieldMetadata': {
diff --git a/packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-runner/utils/derive-metadata-events-from-update-action.util.ts b/packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-runner/utils/derive-metadata-events-from-update-action.util.ts
index 43b1a50cd65..9f40700eade 100644
--- a/packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-runner/utils/derive-metadata-events-from-update-action.util.ts
+++ b/packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-runner/utils/derive-metadata-events-from-update-action.util.ts
@@ -140,6 +140,8 @@ const deriveAllMetadataEventsFromUpdateAction = ({
case 'fieldPermission':
case 'viewSort':
case 'webhook':
+ case 'workflow':
+ case 'workflowVersion':
case 'connectionProvider':
case 'timelineActivityType':
case 'searchFieldMetadata': {
diff --git a/packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-runner/utils/optimistically-apply-create-action-on-all-flat-entity-maps.util.ts b/packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-runner/utils/optimistically-apply-create-action-on-all-flat-entity-maps.util.ts
index 39a7546c37b..02070957f3c 100644
--- a/packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-runner/utils/optimistically-apply-create-action-on-all-flat-entity-maps.util.ts
+++ b/packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-runner/utils/optimistically-apply-create-action-on-all-flat-entity-maps.util.ts
@@ -86,6 +86,8 @@ export const optimisticallyApplyCreateActionOnAllFlatEntityMaps = ({
case 'fieldPermission':
case 'webhook':
case 'applicationVariable':
+ case 'workflow':
+ case 'workflowVersion':
case 'connectionProvider':
case 'timelineActivityType': {
addFlatEntityToFlatEntityAndRelatedEntityMapsThroughMutationOrThrow({
diff --git a/packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-runner/utils/optimistically-apply-delete-action-on-all-flat-entity-maps.util.ts b/packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-runner/utils/optimistically-apply-delete-action-on-all-flat-entity-maps.util.ts
index f506b34ae83..cded7f5b92c 100644
--- a/packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-runner/utils/optimistically-apply-delete-action-on-all-flat-entity-maps.util.ts
+++ b/packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-runner/utils/optimistically-apply-delete-action-on-all-flat-entity-maps.util.ts
@@ -46,6 +46,8 @@ export const optimisticallyApplyDeleteActionOnAllFlatEntityMaps = ({
case 'fieldPermission':
case 'webhook':
case 'applicationVariable':
+ case 'workflow':
+ case 'workflowVersion':
case 'connectionProvider':
case 'timelineActivityType':
case 'searchFieldMetadata': {
diff --git a/packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-runner/utils/optimistically-apply-update-action-on-all-flat-entity-maps.util.ts b/packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-runner/utils/optimistically-apply-update-action-on-all-flat-entity-maps.util.ts
index 124d8afd440..c05e646f03a 100644
--- a/packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-runner/utils/optimistically-apply-update-action-on-all-flat-entity-maps.util.ts
+++ b/packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-runner/utils/optimistically-apply-update-action-on-all-flat-entity-maps.util.ts
@@ -67,6 +67,8 @@ export const optimisticallyApplyUpdateActionOnAllFlatEntityMaps = ({
case 'fieldPermission':
case 'webhook':
case 'applicationVariable':
+ case 'workflow':
+ case 'workflowVersion':
case 'connectionProvider':
case 'timelineActivityType':
case 'searchFieldMetadata': {
diff --git a/packages/twenty-server/test/integration/graphql/suites/workflow/core-workflow-execution.integration-spec.ts b/packages/twenty-server/test/integration/graphql/suites/workflow/core-workflow-execution.integration-spec.ts
index d8d6960c02e..b5374459271 100644
--- a/packages/twenty-server/test/integration/graphql/suites/workflow/core-workflow-execution.integration-spec.ts
+++ b/packages/twenty-server/test/integration/graphql/suites/workflow/core-workflow-execution.integration-spec.ts
@@ -538,7 +538,7 @@ describe('core workflow execution and queue compatibility (e2e)', () => {
global.workflowTestServices;
const hiddenColumns = jest
.spyOn(upgradeState, 'getHiddenColumnPropertyNames')
- .mockReturnValueOnce(new Set(['workspaceWorkflowVersionId']));
+ .mockReturnValue(new Set(['workspaceWorkflowVersionId']));
await workspaceCache.invalidateAndRecompute(workspaceId, [
'workflowAutomatedTriggerMaps',
diff --git a/packages/twenty-shared/src/metadata/constants/all-metadata-name.constant.ts b/packages/twenty-shared/src/metadata/constants/all-metadata-name.constant.ts
index a01925f3294..3deada53106 100644
--- a/packages/twenty-shared/src/metadata/constants/all-metadata-name.constant.ts
+++ b/packages/twenty-shared/src/metadata/constants/all-metadata-name.constant.ts
@@ -31,4 +31,6 @@ export const ALL_METADATA_NAME = {
connectionProvider: 'connectionProvider',
searchFieldMetadata: 'searchFieldMetadata',
timelineActivityType: 'timelineActivityType',
+ workflow: 'workflow',
+ workflowVersion: 'workflowVersion',
} as const;