Skip to content

The open alternative to Salesforce, designed for AI.

feat(workflow): migrate MCP tools and bundled app consumers to core workflow IDs (#26189)

Thomas Trompetteb513d0edb07b
diff --git a/packages/twenty-server/src/engine/api/graphql/workspace-graphql-schema-sdl/core-workflow-app-operations-sdl.constants.ts b/packages/twenty-server/src/engine/api/graphql/workspace-graphql-schema-sdl/core-workflow-app-operations-sdl.constants.ts
new file mode 100644
index 00000000000..2d0653cb8c9
--- /dev/null
+++ b/packages/twenty-server/src/engine/api/graphql/workspace-graphql-schema-sdl/core-workflow-app-operations-sdl.constants.ts
@@ -0,0 +1,3 @@
+export const CORE_WORKFLOW_APP_OPERATIONS_SDL_APPENDER = Symbol(
+ 'CORE_WORKFLOW_APP_OPERATIONS_SDL_APPENDER',
+);
diff --git a/packages/twenty-server/src/engine/api/graphql/workspace-graphql-schema-sdl/core-workflow-app-operations-sdl.module.ts b/packages/twenty-server/src/engine/api/graphql/workspace-graphql-schema-sdl/core-workflow-app-operations-sdl.module.ts
new file mode 100644
index 00000000000..38395efcbfa
--- /dev/null
+++ b/packages/twenty-server/src/engine/api/graphql/workspace-graphql-schema-sdl/core-workflow-app-operations-sdl.module.ts
@@ -0,0 +1,15 @@
+import { Module } from '@nestjs/common';
+
+import { CORE_WORKFLOW_APP_OPERATIONS_SDL_APPENDER } from 'src/engine/api/graphql/workspace-graphql-schema-sdl/core-workflow-app-operations-sdl.constants';
+import { appendCoreWorkflowAppOperationsToSdl } from 'src/engine/api/graphql/workspace-graphql-schema-sdl/utils/append-core-workflow-app-operations-to-sdl.util';
+
+@Module({
+ providers: [
+ {
+ provide: CORE_WORKFLOW_APP_OPERATIONS_SDL_APPENDER,
+ useValue: appendCoreWorkflowAppOperationsToSdl,
+ },
+ ],
+ exports: [CORE_WORKFLOW_APP_OPERATIONS_SDL_APPENDER],
+})
+export class CoreWorkflowAppOperationsSdlModule {}
diff --git a/packages/twenty-server/src/engine/api/graphql/workspace-graphql-schema-sdl/types/core-workflow-app-operations-sdl-appender.type.ts b/packages/twenty-server/src/engine/api/graphql/workspace-graphql-schema-sdl/types/core-workflow-app-operations-sdl-appender.type.ts
new file mode 100644
index 00000000000..537a0d760dd
--- /dev/null
+++ b/packages/twenty-server/src/engine/api/graphql/workspace-graphql-schema-sdl/types/core-workflow-app-operations-sdl-appender.type.ts
@@ -0,0 +1,3 @@
+export type CoreWorkflowAppOperationsSdlAppender = (
+ baseSdl: string,
+) => Promise<string>;
diff --git a/packages/twenty-server/src/engine/api/graphql/workspace-graphql-schema-sdl/utils/__tests__/append-core-workflow-app-operations-to-sdl.util.spec.ts b/packages/twenty-server/src/engine/api/graphql/workspace-graphql-schema-sdl/utils/__tests__/append-core-workflow-app-operations-to-sdl.util.spec.ts
new file mode 100644
index 00000000000..bcc04c98cbd
--- /dev/null
+++ b/packages/twenty-server/src/engine/api/graphql/workspace-graphql-schema-sdl/utils/__tests__/append-core-workflow-app-operations-to-sdl.util.spec.ts
@@ -0,0 +1,134 @@
+import { NestFactory } from '@nestjs/core';
+import {
+ GraphQLSchemaBuilderModule,
+ GraphQLSchemaFactory,
+} from '@nestjs/graphql';
+
+import { makeExecutableSchema } from '@graphql-tools/schema';
+import {
+ buildSchema,
+ isScalarType,
+ lexicographicSortSchema,
+ printType,
+ validateSchema,
+ type GraphQLNamedType,
+ type GraphQLSchema,
+} from 'graphql';
+
+import { appendCoreWorkflowAppOperationsToSdl } from 'src/engine/api/graphql/workspace-graphql-schema-sdl/utils/append-core-workflow-app-operations-to-sdl.util';
+import {
+ CORE_WORKFLOW_APP_MUTATION_NAMES,
+ CORE_WORKFLOW_APP_QUERY_NAMES,
+} from 'src/engine/api/graphql/workspace-graphql-schema-sdl/utils/build-core-workflow-app-operations-sdl.util';
+import { CoreWorkflowVersionMutationResolver } from 'src/engine/core-modules/workflow/resolvers/core-workflow-version-mutation.resolver';
+import { CoreWorkflowResolver } from 'src/engine/core-modules/workflow/resolvers/core-workflow.resolver';
+
+jest.setTimeout(60000);
+
+const BASE_SDL = /* GraphQL */ `
+ scalar UUID
+
+ type Company {
+ id: UUID!
+ name: String
+ }
+
+ type Query {
+ companies: [Company!]!
+ }
+
+ type Mutation {
+ createCompany: Company
+ }
+`;
+
+const describeField = (schema: GraphQLSchema, operationName: string) => {
+ const field =
+ schema.getQueryType()?.getFields()[operationName] ??
+ schema.getMutationType()?.getFields()[operationName];
+
+ return {
+ type: field?.type.toString(),
+ args: field?.args
+ .map((argument) => `${argument.name}: ${argument.type.toString()}`)
+ .sort(),
+ };
+};
+
+describe('appendCoreWorkflowAppOperationsToSdl', () => {
+ let coreSchema: GraphQLSchema;
+ let mergedSchema: GraphQLSchema;
+
+ beforeAll(async () => {
+ const applicationContext = await NestFactory.createApplicationContext(
+ GraphQLSchemaBuilderModule,
+ { logger: false },
+ );
+
+ coreSchema = await applicationContext
+ .get(GraphQLSchemaFactory)
+ .create([CoreWorkflowResolver, CoreWorkflowVersionMutationResolver]);
+
+ await applicationContext.close();
+
+ mergedSchema = buildSchema(
+ await appendCoreWorkflowAppOperationsToSdl(BASE_SDL),
+ );
+ });
+
+ it('produces a valid schema that keeps the workspace operations', () => {
+ expect(validateSchema(mergedSchema)).toEqual([]);
+ expect(mergedSchema.getQueryType()?.getFields()).toHaveProperty(
+ 'companies',
+ );
+ expect(mergedSchema.getMutationType()?.getFields()).toHaveProperty(
+ 'createCompany',
+ );
+ });
+
+ it.each([
+ ...CORE_WORKFLOW_APP_QUERY_NAMES,
+ ...CORE_WORKFLOW_APP_MUTATION_NAMES,
+ ])(
+ 'exposes %s with the signature the core schema declares',
+ (operationName) => {
+ const coreField = describeField(coreSchema, operationName);
+
+ expect(coreField.type).toBeDefined();
+ expect(describeField(mergedSchema, operationName)).toEqual(coreField);
+ },
+ );
+
+ it('carries every referenced type over unchanged', () => {
+ const coreTypeNames = Object.values(coreSchema.getTypeMap())
+ .filter(
+ (type: GraphQLNamedType) =>
+ !type.name.startsWith('__') && !isScalarType(type),
+ )
+ .map((type) => type.name)
+ .filter((typeName) => !['Query', 'Mutation'].includes(typeName));
+
+ const referencedTypeNames = coreTypeNames.filter((typeName) =>
+ Boolean(mergedSchema.getType(typeName)),
+ );
+
+ expect(referencedTypeNames.length).toBeGreaterThan(0);
+
+ const sortedCoreSchema = lexicographicSortSchema(coreSchema);
+
+ for (const typeName of referencedTypeNames) {
+ const mergedType = mergedSchema.getType(typeName);
+ const coreType = sortedCoreSchema.getType(typeName);
+
+ expect(mergedType && printType(mergedType)).toEqual(
+ coreType && printType(coreType),
+ );
+ }
+ });
+
+ it('is accepted by the sdk client generator schema builder', async () => {
+ const typeDefs = await appendCoreWorkflowAppOperationsToSdl(BASE_SDL);
+
+ expect(() => makeExecutableSchema({ typeDefs })).not.toThrow();
+ });
+});
diff --git a/packages/twenty-server/src/engine/api/graphql/workspace-graphql-schema-sdl/utils/__tests__/merge-core-workflow-app-operations-into-sdl.util.spec.ts b/packages/twenty-server/src/engine/api/graphql/workspace-graphql-schema-sdl/utils/__tests__/merge-core-workflow-app-operations-into-sdl.util.spec.ts
new file mode 100644
index 00000000000..e184f15fea8
--- /dev/null
+++ b/packages/twenty-server/src/engine/api/graphql/workspace-graphql-schema-sdl/utils/__tests__/merge-core-workflow-app-operations-into-sdl.util.spec.ts
@@ -0,0 +1,134 @@
+import { buildSchema, validateSchema } from 'graphql';
+
+import { mergeCoreWorkflowAppOperationsIntoSdl } from 'src/engine/api/graphql/workspace-graphql-schema-sdl/utils/merge-core-workflow-app-operations-into-sdl.util';
+
+const OPERATIONS_SDL = /* GraphQL */ `
+ scalar JSON
+ scalar UUID
+
+ type CoreWorkflowDTO {
+ id: UUID!
+ settings: JSON
+ }
+
+ type Mutation {
+ createCoreWorkflow: CoreWorkflowDTO!
+ }
+
+ type Query {
+ coreWorkflows: [CoreWorkflowDTO!]!
+ }
+`;
+
+const BASE_SDL_WITH_SCALARS = /* GraphQL */ `
+ scalar JSON
+ scalar UUID
+
+ type Company {
+ id: UUID!
+ }
+
+ type Query {
+ companies: [Company!]!
+ }
+
+ type Mutation {
+ createCompany: Company
+ }
+`;
+
+const buildMerged = (baseSdl: string) =>
+ buildSchema(
+ mergeCoreWorkflowAppOperationsIntoSdl({
+ baseSdl,
+ operationsSdl: OPERATIONS_SDL,
+ }),
+ );
+
+describe('mergeCoreWorkflowAppOperationsIntoSdl', () => {
+ it('adds the operations onto the existing root types without dropping the base ones', () => {
+ const schema = buildMerged(BASE_SDL_WITH_SCALARS);
+
+ expect(validateSchema(schema)).toEqual([]);
+ expect(Object.keys(schema.getQueryType()?.getFields() ?? {})).toEqual(
+ expect.arrayContaining(['companies', 'coreWorkflows']),
+ );
+ expect(Object.keys(schema.getMutationType()?.getFields() ?? {})).toEqual(
+ expect.arrayContaining(['createCompany', 'createCoreWorkflow']),
+ );
+ });
+
+ it('does not redeclare a scalar the base schema already declares', () => {
+ expect(() => buildMerged(BASE_SDL_WITH_SCALARS)).not.toThrow();
+ });
+
+ it('declares the scalars the base schema is missing', () => {
+ const schema = buildMerged(/* GraphQL */ `
+ type Query {
+ placeholder: String
+ }
+
+ type Mutation {
+ placeholder: String
+ }
+ `);
+
+ expect(schema.getType('UUID')).toBeDefined();
+ expect(schema.getType('JSON')).toBeDefined();
+ });
+
+ it('defines the root types the base schema does not declare', () => {
+ const schema = buildMerged(/* GraphQL */ `
+ type Query {
+ placeholder: String
+ }
+ `);
+
+ expect(validateSchema(schema)).toEqual([]);
+ expect(schema.getMutationType()?.getFields()).toHaveProperty(
+ 'createCoreWorkflow',
+ );
+ });
+
+ it('leaves the base schema untouched when a root field name collides', () => {
+ const baseSdl = /* GraphQL */ `
+ scalar UUID
+
+ type CoreWorkflow {
+ id: UUID!
+ }
+
+ type Query {
+ coreWorkflows: [CoreWorkflow!]!
+ }
+ `;
+
+ expect(
+ mergeCoreWorkflowAppOperationsIntoSdl({
+ baseSdl,
+ operationsSdl: OPERATIONS_SDL,
+ }),
+ ).toBe(baseSdl);
+ });
+
+ it('leaves the base schema untouched when a type name collides', () => {
+ const baseSdl = /* GraphQL */ `
+ scalar UUID
+
+ type CoreWorkflowDTO {
+ id: UUID!
+ }
+
+ type Query {
+ placeholder: String
+ }
+ `;
+
+ expect(
+ mergeCoreWorkflowAppOperationsIntoSdl({
+ baseSdl,
+ operationsSdl: OPERATIONS_SDL,
+ }),
+ ).toBe(baseSdl);
+ });
+});
diff --git a/packages/twenty-server/src/engine/api/graphql/workspace-graphql-schema-sdl/utils/append-core-workflow-app-operations-to-sdl.util.ts b/packages/twenty-server/src/engine/api/graphql/workspace-graphql-schema-sdl/utils/append-core-workflow-app-operations-to-sdl.util.ts
new file mode 100644
index 00000000000..2ec5048ed01
--- /dev/null
+++ b/packages/twenty-server/src/engine/api/graphql/workspace-graphql-schema-sdl/utils/append-core-workflow-app-operations-to-sdl.util.ts
@@ -0,0 +1,10 @@
+import { buildCoreWorkflowAppOperationsSdl } from 'src/engine/api/graphql/workspace-graphql-schema-sdl/utils/build-core-workflow-app-operations-sdl.util';
+import { mergeCoreWorkflowAppOperationsIntoSdl } from 'src/engine/api/graphql/workspace-graphql-schema-sdl/utils/merge-core-workflow-app-operations-into-sdl.util';
+
+export const appendCoreWorkflowAppOperationsToSdl = async (
+ baseSdl: string,
+): Promise<string> =>
+ mergeCoreWorkflowAppOperationsIntoSdl({
+ baseSdl,
+ operationsSdl: await buildCoreWorkflowAppOperationsSdl(),
+ });
diff --git a/packages/twenty-server/src/engine/api/graphql/workspace-graphql-schema-sdl/utils/build-core-workflow-app-operations-sdl.util.ts b/packages/twenty-server/src/engine/api/graphql/workspace-graphql-schema-sdl/utils/build-core-workflow-app-operations-sdl.util.ts
new file mode 100644
index 00000000000..dfe62f5e2fa
--- /dev/null
+++ b/packages/twenty-server/src/engine/api/graphql/workspace-graphql-schema-sdl/utils/build-core-workflow-app-operations-sdl.util.ts
@@ -0,0 +1,113 @@
+import { NestFactory } from '@nestjs/core';
+import {
+ GraphQLSchemaBuilderModule,
+ GraphQLSchemaFactory,
+} from '@nestjs/graphql';
+
+import {
+ GraphQLObjectType,
+ GraphQLSchema,
+ isInterfaceType,
+ lexicographicSortSchema,
+ printSchema,
+ type GraphQLFieldConfigMap,
+} from 'graphql';
+import { isDefined } from 'twenty-shared/utils';
+
+import { CoreWorkflowVersionMutationResolver } from 'src/engine/core-modules/workflow/resolvers/core-workflow-version-mutation.resolver';
+import { CoreWorkflowResolver } from 'src/engine/core-modules/workflow/resolvers/core-workflow.resolver';
+
+export const CORE_WORKFLOW_APP_QUERY_NAMES = [
+ 'coreWorkflows',
+ 'coreWorkflowVersionsByCoreWorkflowId',
+];
+
+export const CORE_WORKFLOW_APP_MUTATION_NAMES = [
+ 'createCoreWorkflow',
+ 'updateCoreWorkflowVersionTrigger',
+ 'createCoreWorkflowVersionStep',
+ 'updateCoreWorkflowVersionStep',
+ 'activateCoreWorkflowVersion',
+];
+
+type RootTypeConfig = ReturnType<GraphQLObjectType['toConfig']>;
+
+const pickRootType = ({
+ rootTypeConfig,
+ operationNames,
+}: {
+ rootTypeConfig: RootTypeConfig;
+ operationNames: string[];
+}): GraphQLObjectType => {
+ const missingOperationNames = operationNames.filter(
+ (operationName) => !isDefined(rootTypeConfig.fields[operationName]),
+ );
+
+ if (missingOperationNames.length > 0) {
+ throw new Error(
+ `Core workflow operations missing from the ${rootTypeConfig.name} type: ${missingOperationNames.join(', ')}`,
+ );
+ }
+
+ const fields: GraphQLFieldConfigMap<unknown, unknown> = Object.fromEntries(
+ operationNames.map((operationName) => [
+ operationName,
+ rootTypeConfig.fields[operationName],
+ ]),
+ );
+
+ return new GraphQLObjectType({ ...rootTypeConfig, fields });
+};
+
+const buildSlice = async (): Promise<string> => {
+ const applicationContext = await NestFactory.createApplicationContext(
+ GraphQLSchemaBuilderModule,
+ );
+
+ try {
+ const coreSchema = await applicationContext
+ .get(GraphQLSchemaFactory)
+ .create([CoreWorkflowResolver, CoreWorkflowVersionMutationResolver]);
+
+ const queryTypeConfig = coreSchema.getQueryType()?.toConfig();
+ const mutationTypeConfig = coreSchema.getMutationType()?.toConfig();
+
+ if (!isDefined(queryTypeConfig) || !isDefined(mutationTypeConfig)) {
+ throw new Error(
+ 'Core workflow resolvers produced no Query or Mutation type',
+ );
+ }
+
+ const query = pickRootType({
+ rootTypeConfig: queryTypeConfig,
+ operationNames: CORE_WORKFLOW_APP_QUERY_NAMES,
+ });
+ const mutation = pickRootType({
+ rootTypeConfig: mutationTypeConfig,
+ operationNames: CORE_WORKFLOW_APP_MUTATION_NAMES,
+ });
+
+ const reachableTypes = Object.values(
+ new GraphQLSchema({ query, mutation }).getTypeMap(),
+ );
+ const interfaceImplementations = reachableTypes
+ .filter(isInterfaceType)
+ .flatMap((interfaceType) => coreSchema.getPossibleTypes(interfaceType));
+
+ return printSchema(
+ lexicographicSortSchema(
+ new GraphQLSchema({ query, mutation, types: interfaceImplementations }),
+ ),
+ );
+ } finally {
+ await applicationContext.close();
+ }
+};
+
+let coreWorkflowAppOperationsSdlPromise: Promise<string> | undefined;
+
+export const buildCoreWorkflowAppOperationsSdl = (): Promise<string> => {
+ coreWorkflowAppOperationsSdlPromise ??= buildSlice();
+
+ return coreWorkflowAppOperationsSdlPromise;
+};
diff --git a/packages/twenty-server/src/engine/api/graphql/workspace-graphql-schema-sdl/utils/merge-core-workflow-app-operations-into-sdl.util.ts b/packages/twenty-server/src/engine/api/graphql/workspace-graphql-schema-sdl/utils/merge-core-workflow-app-operations-into-sdl.util.ts
new file mode 100644
index 00000000000..80d295ffb49
--- /dev/null
+++ b/packages/twenty-server/src/engine/api/graphql/workspace-graphql-schema-sdl/utils/merge-core-workflow-app-operations-into-sdl.util.ts
@@ -0,0 +1,90 @@
+import {
+ Kind,
+ parse,
+ print,
+ type DefinitionNode,
+ type DocumentNode,
+} from 'graphql';
+import { isDefined } from 'twenty-shared/utils';
+
+const ROOT_TYPE_NAMES = ['Query', 'Mutation'];
+
+const getDefinitionName = (definition: DefinitionNode): string | undefined =>
+ 'name' in definition ? definition.name?.value : undefined;
+
+const getRootFieldNames = (
+ definitions: readonly DefinitionNode[],
+): Set<string> =>
+ new Set(
+ definitions
+ .filter(
+ (definition) =>
+ definition.kind === Kind.OBJECT_TYPE_DEFINITION &&
+ ROOT_TYPE_NAMES.includes(definition.name.value),
+ )
+ .flatMap((definition) =>
+ definition.kind === Kind.OBJECT_TYPE_DEFINITION
+ ? (definition.fields ?? []).map((field) => field.name.value)
+ : [],
+ ),
+ );
+
+export const mergeCoreWorkflowAppOperationsIntoSdl = ({
+ baseSdl,
+ operationsSdl,
+}: {
+ baseSdl: string;
+ operationsSdl: string;
+}): string => {
+ const baseDocument = parse(baseSdl);
+ const baseDefinitionNames = new Set(
+ baseDocument.definitions.map(getDefinitionName).filter(isDefined),
+ );
+ const baseRootFieldNames = getRootFieldNames(baseDocument.definitions);
+ const operationsDocument = parse(operationsSdl);
+
+ const hasCollidingRootField = [
+ ...getRootFieldNames(operationsDocument.definitions),
+ ].some((fieldName) => baseRootFieldNames.has(fieldName));
+
+ if (hasCollidingRootField) {
+ return baseSdl;
+ }
+
+ const appendedDefinitions: DefinitionNode[] = [];
+
+ for (const definition of operationsDocument.definitions) {
+ const definitionName = getDefinitionName(definition);
+
+ if (!isDefined(definitionName)) {
+ continue;
+ }
+
+ const isAlreadyDeclared = baseDefinitionNames.has(definitionName);
+
+ if (ROOT_TYPE_NAMES.includes(definitionName)) {
+ appendedDefinitions.push(
+ isAlreadyDeclared && definition.kind === Kind.OBJECT_TYPE_DEFINITION
+ ? { ...definition, kind: Kind.OBJECT_TYPE_EXTENSION }
+ : definition,
+ );
+ continue;
+ }
+
+ if (!isAlreadyDeclared) {
+ appendedDefinitions.push(definition);
+ continue;
+ }
+
+ if (definition.kind !== Kind.SCALAR_TYPE_DEFINITION) {
+ return baseSdl;
+ }
+ }
+
+ const mergedDocument: DocumentNode = {
+ kind: Kind.DOCUMENT,
+ definitions: [...baseDocument.definitions, ...appendedDefinitions],
+ };
+
+ return print(mergedDocument);
+};
diff --git a/packages/twenty-server/src/engine/api/graphql/workspace-graphql-schema-sdl/workspace-graphql-schema-sdl.module.ts b/packages/twenty-server/src/engine/api/graphql/workspace-graphql-schema-sdl/workspace-graphql-schema-sdl.module.ts
index 931d7b12b5a..209bd79b9d4 100644
--- a/packages/twenty-server/src/engine/api/graphql/workspace-graphql-schema-sdl/workspace-graphql-schema-sdl.module.ts
+++ b/packages/twenty-server/src/engine/api/graphql/workspace-graphql-schema-sdl/workspace-graphql-schema-sdl.module.ts
@@ -1,6 +1,7 @@
import { Module } from '@nestjs/common';
import { ScalarsExplorerService } from 'src/engine/api/graphql/services/scalars-explorer.service';
+import { CoreWorkflowAppOperationsSdlModule } from 'src/engine/api/graphql/workspace-graphql-schema-sdl/core-workflow-app-operations-sdl.module';
import { WorkspaceSchemaBuilderModule } from 'src/engine/api/graphql/workspace-schema-builder/workspace-schema-builder.module';
import { WorkspaceGraphqlSchemaSDLService } from 'src/engine/api/graphql/workspace-graphql-schema-sdl/workspace-graphql-schema-sdl.service';
import { WorkspaceManyOrAllFlatEntityMapsCacheModule } from 'src/engine/metadata-modules/flat-entity/services/workspace-many-or-all-flat-entity-maps-cache.module';
@@ -11,6 +12,7 @@ import { WorkspaceCacheStorageModule } from 'src/engine/workspace-cache-storage/
WorkspaceSchemaBuilderModule,
WorkspaceCacheStorageModule,
WorkspaceManyOrAllFlatEntityMapsCacheModule,
+ CoreWorkflowAppOperationsSdlModule,
],
providers: [WorkspaceGraphqlSchemaSDLService, ScalarsExplorerService],
exports: [WorkspaceGraphqlSchemaSDLService],
diff --git a/packages/twenty-server/src/engine/api/graphql/workspace-graphql-schema-sdl/workspace-graphql-schema-sdl.service.ts b/packages/twenty-server/src/engine/api/graphql/workspace-graphql-schema-sdl/workspace-graphql-schema-sdl.service.ts
index 7770663d49b..ea277cab207 100644
--- a/packages/twenty-server/src/engine/api/graphql/workspace-graphql-schema-sdl/workspace-graphql-schema-sdl.service.ts
+++ b/packages/twenty-server/src/engine/api/graphql/workspace-graphql-schema-sdl/workspace-graphql-schema-sdl.service.ts
@@ -1,10 +1,12 @@
-import { Injectable } from '@nestjs/common';
+import { Inject, Injectable } from '@nestjs/common';
import { isNonEmptyString } from '@sniptt/guards';
import { printSchema } from 'graphql';
import { isDefined } from 'twenty-shared/utils';
import { ScalarsExplorerService } from 'src/engine/api/graphql/services/scalars-explorer.service';
+import { CORE_WORKFLOW_APP_OPERATIONS_SDL_APPENDER } from 'src/engine/api/graphql/workspace-graphql-schema-sdl/core-workflow-app-operations-sdl.constants';
+import { type CoreWorkflowAppOperationsSdlAppender } from 'src/engine/api/graphql/workspace-graphql-schema-sdl/types/core-workflow-app-operations-sdl-appender.type';
import { type SchemaGenerationContext } from 'src/engine/api/graphql/workspace-schema-builder/types/schema-generation-context.type';
import { WorkspaceGraphQLSchemaGenerator } from 'src/engine/api/graphql/workspace-schema-builder/workspace-graphql-schema.factory';
import { FlatWorkspace } from 'src/engine/core-modules/workspace/types/flat-workspace.type';
@@ -38,6 +40,8 @@ export class WorkspaceGraphqlSchemaSDLService {
private readonly workspaceGraphQLSchemaGenerator: WorkspaceGraphQLSchemaGenerator,
private readonly workspaceCacheStorageService: WorkspaceCacheStorageService,
private readonly workspaceManyOrAllFlatEntityMapsCacheService: WorkspaceManyOrAllFlatEntityMapsCacheService,
+ @Inject(CORE_WORKFLOW_APP_OPERATIONS_SDL_APPENDER)
+ private readonly appendCoreWorkflowAppOperationsToSdl: CoreWorkflowAppOperationsSdlAppender,
) {}
async getOrComputeSchemaSDL(
@@ -148,7 +152,9 @@ export class WorkspaceGraphqlSchemaSDLService {
});
return {
- sdl,
+ sdl: isDefined(applicationId)
+ ? await this.appendCoreWorkflowAppOperationsToSdl(sdl)
+ : sdl,
usedScalarNames,
flatObjectMetadataMaps,
flatFieldMetadataMaps,
diff --git a/packages/twenty-server/src/engine/core-modules/actor/utils/__tests__/build-actor-metadata-from-principal.util.spec.ts b/packages/twenty-server/src/engine/core-modules/actor/utils/__tests__/build-actor-metadata-from-principal.util.spec.ts
new file mode 100644
index 00000000000..35d35863358
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/actor/utils/__tests__/build-actor-metadata-from-principal.util.spec.ts
@@ -0,0 +1,40 @@
+import { FieldActorSource } from 'twenty-shared/types';
+
+import { buildActorMetadataFromPrincipal } from 'src/engine/core-modules/actor/utils/build-actor-metadata-from-principal.util';
+import { type FlatApplication } from 'src/engine/core-modules/application/types/flat-application.type';
+import { type WorkspaceMemberWorkspaceEntity } from 'src/modules/workspace-member/standard-objects/workspace-member.workspace-entity';
+
+const WORKSPACE_MEMBER = {
+ id: '20202020-0687-4c41-b707-ed1bfca972a7',
+ name: { firstName: 'Tim', lastName: 'Apple' },
+} satisfies Pick<WorkspaceMemberWorkspaceEntity, 'id' | 'name'>;
+
+const APPLICATION = {
+ id: '20202020-1c25-4d02-bf25-6aeccf7ea419',
+ name: 'People Data Labs',
+} as FlatApplication;
+
+describe('buildActorMetadataFromPrincipal', () => {
+ it('attributes to the workspace member when there is one', () => {
+ const actor = buildActorMetadataFromPrincipal({
+ workspaceMember: WORKSPACE_MEMBER,
+ application: APPLICATION,
+ });
+
+ expect(actor?.workspaceMemberId).toBe(WORKSPACE_MEMBER.id);
+ expect(actor?.source).toBe(FieldActorSource.MANUAL);
+ });
+
+ it('falls back to the application when no workspace member is authenticated', () => {
+ const actor = buildActorMetadataFromPrincipal({
+ application: APPLICATION,
+ });
+
+ expect(actor?.workspaceMemberId).toBeNull();
+ expect(actor?.name).toBe(APPLICATION.name);
+ });
+
+ it('returns undefined when neither principal is present', () => {
+ expect(buildActorMetadataFromPrincipal({})).toBeUndefined();
+ });
+});
diff --git a/packages/twenty-server/src/engine/core-modules/actor/utils/build-actor-metadata-from-principal.util.ts b/packages/twenty-server/src/engine/core-modules/actor/utils/build-actor-metadata-from-principal.util.ts
new file mode 100644
index 00000000000..dd82bfa46a5
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/actor/utils/build-actor-metadata-from-principal.util.ts
@@ -0,0 +1,31 @@
+import { type ActorMetadata } from 'twenty-shared/types';
+import { isDefined } from 'twenty-shared/utils';
+
+import { buildCreatedByFromApplication } from 'src/engine/core-modules/actor/utils/build-created-by-from-application.util';
+import { buildCreatedByFromFullNameMetadata } from 'src/engine/core-modules/actor/utils/build-created-by-from-full-name-metadata.util';
+import { type FlatApplication } from 'src/engine/core-modules/application/types/flat-application.type';
+import { type WorkspaceMemberWorkspaceEntity } from 'src/modules/workspace-member/standard-objects/workspace-member.workspace-entity';
+
+export const buildActorMetadataFromPrincipal = ({
+ workspaceMember,
+ application,
+}: {
+ workspaceMember?: Pick<WorkspaceMemberWorkspaceEntity, 'id' | 'name'>;
+ application?: FlatApplication;
+}): ActorMetadata | undefined => {
+ if (isDefined(workspaceMember)) {
+ return buildCreatedByFromFullNameMetadata({
+ fullNameMetadata: {
+ firstName: workspaceMember.name.firstName,
+ lastName: workspaceMember.name.lastName,
+ },
+ workspaceMemberId: workspaceMember.id,
+ });
+ }
+
+ if (isDefined(application)) {
+ return buildCreatedByFromApplication({ application });
+ }
+
+ return undefined;
+};
diff --git a/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/__tests__/build-all-flat-entity-operation-record-by-metadata-name-from-from-to.util.spec.ts b/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/__tests__/build-all-flat-entity-operation-record-by-metadata-name-from-from-to.util.spec.ts
index eaeca3de976..b01170551dc 100644
--- a/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/__tests__/build-all-flat-entity-operation-record-by-metadata-name-from-from-to.util.spec.ts
+++ b/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/__tests__/build-all-flat-entity-operation-record-by-metadata-name-from-from-to.util.spec.ts
@@ -237,6 +237,19 @@ describe('buildAllFlatEntityOperationRecordByMetadataNameFromFromTo', () => {
expect(result.commandMenuItem?.flatEntityToDelete).toBeUndefined();
});
+ it('does not delete a workflow trigger command that only carries its core pointer', () => {
+ const result = inferDeletionOf(
+ withCommandMenuItem({
+ ...COMMAND_MENU_ITEM,
+ engineComponentKey: EngineComponentKey.TRIGGER_WORKFLOW_VERSION,
+ workflowVersionId: null,
+ coreWorkflowVersionId: 'a-core-workflow-version-id',
+ }),
+ );
+
+ expect(result.commandMenuItem?.flatEntityToDelete).toBeUndefined();
+ });
+
it('does not delete a command without the front component its manifest requires', () => {
const result = inferDeletionOf(withCommandMenuItem(COMMAND_MENU_ITEM));
diff --git a/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/__tests__/classify-application-flat-entities.util.spec.ts b/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/__tests__/classify-application-flat-entities.util.spec.ts
index ac8a75135f0..a1c317cb3ef 100644
--- a/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/__tests__/classify-application-flat-entities.util.spec.ts
+++ b/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/__tests__/classify-application-flat-entities.util.spec.ts
@@ -1,6 +1,11 @@
-import { FieldMetadataType } from 'twenty-shared/types';
+import {
+ CommandMenuItemAvailabilityType,
+ FieldMetadataType,
+} from 'twenty-shared/types';
import { classifyApplicationFlatEntities } from 'src/engine/core-modules/application/application-manifest/utils/classify-application-flat-entities.util';
+import { EngineComponentKey } from 'src/engine/metadata-modules/command-menu-item/enums/engine-component-key.enum';
+import { type FlatCommandMenuItem } from 'src/engine/metadata-modules/flat-command-menu-item/types/flat-command-menu-item.type';
import { ApplicationExportCoverageStatus } from 'src/engine/core-modules/application/enums/application-export-coverage-status.enum';
import { type FlatApplication } from 'src/engine/core-modules/application/types/flat-application.type';
import { createEmptyAllFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/constant/create-empty-all-flat-entity-maps.constant';
@@ -231,3 +236,90 @@ describe('classifyApplicationFlatEntities', () => {
expect(keys).toEqual([...keys].sort());
});
});
+
+const COMMAND_MENU_ITEM_UID = 'bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb';
+
+const buildWorkflowCommandMenuItem = ({
+ workflowVersionId,
+ coreWorkflowVersionId,
+}: {
+ workflowVersionId: string | null;
+ coreWorkflowVersionId: string | null;
+}): FlatCommandMenuItem =>
+ ({
+ id: 'command-menu-item-id',
+ universalIdentifier: COMMAND_MENU_ITEM_UID,
+ applicationId: APP_ID,
+ applicationUniversalIdentifier: APP_UID,
+ workflowVersionId,
+ coreWorkflowVersionId,
+ frontComponentId: null,
+ frontComponentUniversalIdentifier: null,
+ engineComponentKey: EngineComponentKey.TRIGGER_WORKFLOW_VERSION,
+ label: 'Run workflow',
+ availabilityType: CommandMenuItemAvailabilityType.GLOBAL,
+ isSystemSideEffect: false,
+ deletedAt: null,
+ createdAt: NOW,
+ updatedAt: NOW,
+ }) as unknown as FlatCommandMenuItem;
+
+const classifyCommandMenuItem = (flatCommandMenuItem: FlatCommandMenuItem) => {
+ const maps = createEmptyAllFlatEntityMaps();
+
+ maps.flatCommandMenuItemMaps = addFlatEntityToFlatEntityMapsOrThrow({
+ flatEntity: flatCommandMenuItem,
+ flatEntityMaps: maps.flatCommandMenuItemMaps,
+ });
+
+ return classifyApplicationFlatEntities({
+ flatApplication,
+ allFlatEntityMaps: maps,
+ applicationAllFlatEntityMaps: maps,
+ reconstructedCoverage: [],
+ }).find((entry) => entry.universalIdentifier === COMMAND_MENU_ITEM_UID);
+};
+
+describe('classifyApplicationFlatEntities workflow commands', () => {
+ it('should exclude a workflow command that carries both pointers', () => {
+ expect(
+ classifyCommandMenuItem(
+ buildWorkflowCommandMenuItem({
+ workflowVersionId: 'a-workflow-version-id',
+ coreWorkflowVersionId: 'a-core-workflow-version-id',
+ }),
+ ),
+ ).toMatchObject({
+ status: ApplicationExportCoverageStatus.EXCLUDED,
+ reason: 'workflow trigger command',
+ });
+ });
+
+ it('should exclude a workflow command that only carries its core pointer', () => {
+ expect(
+ classifyCommandMenuItem(
+ buildWorkflowCommandMenuItem({
+ workflowVersionId: null,
+ coreWorkflowVersionId: 'a-core-workflow-version-id',
+ }),
+ ),
+ ).toMatchObject({
+ status: ApplicationExportCoverageStatus.EXCLUDED,
+ reason: 'workflow trigger command',
+ });
+ });
+
+ it('should not treat a command without any workflow pointer as workflow-generated', () => {
+ expect(
+ classifyCommandMenuItem(
+ buildWorkflowCommandMenuItem({
+ workflowVersionId: null,
+ coreWorkflowVersionId: null,
+ }),
+ ),
+ ).toMatchObject({
+ status: ApplicationExportCoverageStatus.EXCLUDED,
+ reason: 'command without front component',
+ });
+ });
+});
diff --git a/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/can-manifest-express-flat-entity.util.ts b/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/can-manifest-express-flat-entity.util.ts
index 0e977a0bd47..706d9b4bbd5 100644
--- a/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/can-manifest-express-flat-entity.util.ts
+++ b/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/can-manifest-express-flat-entity.util.ts
@@ -9,6 +9,7 @@ const WORKSPACE_BOUND_PROPERTIES = [
'userWorkspaceId',
'apiKeyId',
'workflowVersionId',
+ 'coreWorkflowVersionId',
'targetRecordId',
] as const;
diff --git a/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/classify-application-flat-entities.util.ts b/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/classify-application-flat-entities.util.ts
index 4cdfbc9d2f1..513a355b45b 100644
--- a/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/classify-application-flat-entities.util.ts
+++ b/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/classify-application-flat-entities.util.ts
@@ -43,6 +43,14 @@ const getFlatEntities = ({
const isSoftDeleted = (flatEntity: ApplicationFlatEntity): boolean =>
'deletedAt' in flatEntity && isDefined(flatEntity.deletedAt);
+const isWorkflowTriggerCommandMenuItem = (
+ flatEntity: ApplicationFlatEntity,
+): boolean =>
+ ('workflowVersionId' in flatEntity &&
+ isDefined(flatEntity.workflowVersionId)) ||
+ ('coreWorkflowVersionId' in flatEntity &&
+ isDefined(flatEntity.coreWorkflowVersionId));
+
const classifyFlatEntity = ({
metadataName,
flatEntity,
@@ -79,10 +87,7 @@ const classifyFlatEntity = ({
}
: { status: ApplicationExportCoverageStatus.UNSUPPORTED };
case 'commandMenuItem':
- if (
- 'workflowVersionId' in flatEntity &&
- isDefined(flatEntity.workflowVersionId)
- ) {
+ if (isWorkflowTriggerCommandMenuItem(flatEntity)) {
return {
status: ApplicationExportCoverageStatus.EXCLUDED,
reason: 'workflow trigger command',
diff --git a/packages/twenty-server/src/engine/core-modules/tool-provider/providers/workflow-tool.provider.ts b/packages/twenty-server/src/engine/core-modules/tool-provider/providers/workflow-tool.provider.ts
index 4fdba2b6edc..4a8481b0974 100644
--- a/packages/twenty-server/src/engine/core-modules/tool-provider/providers/workflow-tool.provider.ts
+++ b/packages/twenty-server/src/engine/core-modules/tool-provider/providers/workflow-tool.provider.ts
@@ -94,9 +94,11 @@ export class WorkflowToolProvider implements ToolProvider {
return null;
}
- return this.workflowToolService.generateWorkflowTools(
- context.workspaceId,
- context.rolePermissionConfig,
- );
+ return this.workflowToolService.generateWorkflowTools({
+ workspaceId: context.workspaceId,
+ rolePermissionConfig: context.rolePermissionConfig,
+ actorContext: context.actorContext,
+ userWorkspaceId: context.userWorkspaceId,
+ });
}
}
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
new file mode 100644
index 00000000000..19b2d06baa6
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/workflow/core-workflow-services.module.ts
@@ -0,0 +1,69 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+
+import { CacheLockModule } from 'src/engine/core-modules/cache-lock/cache-lock.module';
+import { CacheStorageModule } from 'src/engine/core-modules/cache-storage/cache-storage.module';
+import { RecordPositionModule } from 'src/engine/core-modules/record-position/record-position.module';
+import { WorkflowVersionEntity } from 'src/engine/core-modules/workflow/entities/workflow-version.entity';
+import { WorkflowEntity } from 'src/engine/core-modules/workflow/entities/workflow.entity';
+import { CoreWorkflowAccessModule } from 'src/engine/core-modules/workflow/core-workflow-access.module';
+import { CoreWorkflowIdResolutionService } from 'src/engine/core-modules/workflow/services/core-workflow-id-resolution.service';
+import { CoreWorkflowLifecycleWorkspaceService } from 'src/engine/core-modules/workflow/services/core-workflow-lifecycle.workspace-service';
+import { CoreWorkflowListService } from 'src/engine/core-modules/workflow/services/core-workflow-list.service';
+import { CoreWorkflowMutationWorkspaceService } from 'src/engine/core-modules/workflow/services/core-workflow-mutation.workspace-service';
+import { CoreWorkflowVersionListService } from 'src/engine/core-modules/workflow/services/core-workflow-version-list.service';
+import { CoreWorkflowVersionMutationWorkspaceService } from 'src/engine/core-modules/workflow/services/core-workflow-version-mutation.workspace-service';
+import { CoreWorkflowVersionWriteService } from 'src/engine/core-modules/workflow/services/core-workflow-version-write.service';
+import { WorkflowCoreModule } from 'src/engine/core-modules/workflow/workflow-core.module';
+import { 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 { 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';
+import { WorkflowBuilderModule } from 'src/modules/workflow/workflow-builder/workflow-builder.module';
+import { WorkflowVersionValidationModule } from 'src/modules/workflow/workflow-builder/workflow-validation/workflow-version-validation.module';
+import { CodeStepBuildModule } from 'src/modules/workflow/workflow-builder/workflow-version-step/code-step/code-step-build.module';
+import { WorkflowRunnerModule } from 'src/modules/workflow/workflow-runner/workflow-runner.module';
+import { AutomatedTriggerModule } from 'src/modules/workflow/workflow-trigger/automated-trigger/automated-trigger.module';
+
+@Module({
+ imports: [
+ CoreWorkflowAccessModule,
+ TypeOrmModule.forFeature([WorkspaceEntity, WorkflowVersionEntity]),
+ AutomatedTriggerModule,
+ CacheLockModule,
+ CacheStorageModule,
+ CodeStepBuildModule,
+ CommandMenuItemModule,
+ RecordPositionModule,
+ WorkflowBuilderModule,
+ WorkflowCommonModule,
+ WorkflowCoreModule,
+ WorkflowMetadataReadModule,
+ WorkflowRunnerModule,
+ WorkflowVersionCoreModule,
+ WorkflowVersionValidationModule,
+ ],
+ providers: [
+ CoreWorkflowIdResolutionService,
+ CoreWorkflowLifecycleWorkspaceService,
+ CoreWorkflowListService,
+ CoreWorkflowMutationWorkspaceService,
+ CoreWorkflowVersionListService,
+ CoreWorkflowVersionMutationWorkspaceService,
+ CoreWorkflowVersionWriteService,
+ provideWorkspaceScopedRepository(WorkflowVersionEntity),
+ provideWorkspaceScopedRepository(WorkflowEntity),
+ ],
+ exports: [
+ CoreWorkflowIdResolutionService,
+ CoreWorkflowLifecycleWorkspaceService,
+ CoreWorkflowListService,
+ CoreWorkflowMutationWorkspaceService,
+ CoreWorkflowVersionListService,
+ CoreWorkflowVersionMutationWorkspaceService,
+ CoreWorkflowVersionWriteService,
+ ],
+})
+export class CoreWorkflowServicesModule {}
diff --git a/packages/twenty-server/src/engine/core-modules/workflow/resolvers/core-workflow-version-mutation.resolver.ts b/packages/twenty-server/src/engine/core-modules/workflow/resolvers/core-workflow-version-mutation.resolver.ts
index 8bee85ca054..4c01fbef5e6 100644
--- a/packages/twenty-server/src/engine/core-modules/workflow/resolvers/core-workflow-version-mutation.resolver.ts
+++ b/packages/twenty-server/src/engine/core-modules/workflow/resolvers/core-workflow-version-mutation.resolver.ts
@@ -37,6 +37,7 @@ import { AuthUserWorkspaceId } from 'src/engine/decorators/auth/auth-user-worksp
import { AuthWorkspace } from 'src/engine/decorators/auth/auth-workspace.decorator';
import { SettingsPermissionGuard } from 'src/engine/guards/settings-permission.guard';
import { UserAuthGuard } from 'src/engine/guards/user-auth.guard';
+import { UserOrApplicationAuthGuard } from 'src/engine/guards/user-or-application-auth.guard';
import { WorkspaceAuthGuard } from 'src/engine/guards/workspace-auth.guard';
import { PermissionsGraphqlApiExceptionFilter } from 'src/engine/metadata-modules/permissions/utils/permissions-graphql-api-exception.filter';
import { buildSystemAuthContext } from 'src/engine/twenty-orm/utils/build-system-auth-context.util';
@@ -49,7 +50,7 @@ import { CoreWorkflowRunnerService } from 'src/modules/workflow/workflow-runner/
@UsePipes(ResolverValidationPipe)
@UseGuards(
WorkspaceAuthGuard,
- UserAuthGuard,
+ UserOrApplicationAuthGuard,
SettingsPermissionGuard(PermissionFlagType.WORKFLOWS),
)
@UseFilters(
@@ -125,6 +126,7 @@ export class CoreWorkflowVersionMutationResolver {
}
@Mutation(() => RunWorkflowVersionDTO)
+ @UseGuards(UserAuthGuard)
async runCoreWorkflowVersion(
@AuthUser() user: AuthContextUser,
@AuthWorkspace() { id: workspaceId }: WorkspaceEntity,
diff --git a/packages/twenty-server/src/engine/core-modules/workflow/resolvers/core-workflow.resolver.ts b/packages/twenty-server/src/engine/core-modules/workflow/resolvers/core-workflow.resolver.ts
index 21187edf58a..1e02f9e6e55 100644
--- a/packages/twenty-server/src/engine/core-modules/workflow/resolvers/core-workflow.resolver.ts
+++ b/packages/twenty-server/src/engine/core-modules/workflow/resolvers/core-workflow.resolver.ts
@@ -1,7 +1,9 @@
import { UseFilters, UseGuards, UsePipes } from '@nestjs/common';
import { Args, Mutation, Query } from '@nestjs/graphql';
+import { msg } from '@lingui/core/macro';
import { PermissionFlagType } from 'twenty-shared/constants';
+import { type ActorMetadata } from 'twenty-shared/types';
import { CoreResolver } from 'src/engine/api/graphql/graphql-config/decorators/core-resolver.decorator';
import { PreventNestToAutoLogGraphqlErrorsFilter } from 'src/engine/core-modules/graphql/filters/prevent-nest-to-auto-log-graphql-errors.filter';
@@ -30,15 +32,22 @@ import { CoreWorkflowListService } from 'src/engine/core-modules/workflow/servic
import { CoreWorkflowMutationWorkspaceService } from 'src/engine/core-modules/workflow/services/core-workflow-mutation.workspace-service';
import { CoreWorkflowVersionListService } from 'src/engine/core-modules/workflow/services/core-workflow-version-list.service';
import { WorkspaceEntity } from 'src/engine/core-modules/workspace/workspace.entity';
-import { type AuthContextUser } from 'src/engine/core-modules/auth/types/auth-context.type';
+import { type FlatApplication } from 'src/engine/core-modules/application/types/flat-application.type';
import { AuthGraphqlApiExceptionFilter } from 'src/engine/core-modules/auth/filters/auth-graphql-api-exception.filter';
-import { AuthUser } from 'src/engine/decorators/auth/auth-user.decorator';
+import { buildActorMetadataFromPrincipal } from 'src/engine/core-modules/actor/utils/build-actor-metadata-from-principal.util';
+import {
+ WorkflowQueryValidationException,
+ WorkflowQueryValidationExceptionCode,
+} from 'src/modules/workflow/common/exceptions/workflow-query-validation.exception';
+import { type WorkspaceMemberWorkspaceEntity } from 'src/modules/workspace-member/standard-objects/workspace-member.workspace-entity';
+import { AuthApplication } from 'src/engine/decorators/auth/auth-application.decorator';
import { AuthUserWorkspaceId } from 'src/engine/decorators/auth/auth-user-workspace-id.decorator';
+import { AuthWorkspaceMember } from 'src/engine/decorators/auth/auth-workspace-member.decorator';
import { isDefined } from 'twenty-shared/utils';
import { AuthWorkspace } from 'src/engine/decorators/auth/auth-workspace.decorator';
import { SettingsPermissionGuard } from 'src/engine/guards/settings-permission.guard';
-import { UserAuthGuard } from 'src/engine/guards/user-auth.guard';
+import { UserOrApplicationAuthGuard } from 'src/engine/guards/user-or-application-auth.guard';
import { WorkspaceAuthGuard } from 'src/engine/guards/workspace-auth.guard';
import { PermissionsGraphqlApiExceptionFilter } from 'src/engine/metadata-modules/permissions/utils/permissions-graphql-api-exception.filter';
@@ -46,7 +55,7 @@ import { PermissionsGraphqlApiExceptionFilter } from 'src/engine/metadata-module
@UsePipes(ResolverValidationPipe)
@UseGuards(
WorkspaceAuthGuard,
- UserAuthGuard,
+ UserOrApplicationAuthGuard,
SettingsPermissionGuard(PermissionFlagType.WORKFLOWS),
)
@UseFilters(
@@ -62,6 +71,25 @@ export class CoreWorkflowResolver {
private readonly coreWorkflowVersionListService: CoreWorkflowVersionListService,
) {}
+ private resolveCreatedByOrThrow(principal: {
+ workspaceMember?: WorkspaceMemberWorkspaceEntity;
+ application?: FlatApplication;
+ }): ActorMetadata {
+ const createdBy = buildActorMetadataFromPrincipal(principal);
+
+ if (!isDefined(createdBy)) {
+ throw new WorkflowQueryValidationException(
+ 'No authenticated actor to attribute the workflow to',
+ WorkflowQueryValidationExceptionCode.FORBIDDEN,
+ {
+ userFriendlyMessage: msg`Authentication is required to perform this action`,
+ },
+ );
+ }
+
+ return createdBy;
+ }
+
@Mutation(() => CoreWorkflowDTO, { nullable: true })
async updateCoreWorkflow(
@AuthWorkspace() { id: workspaceId }: WorkspaceEntity,
@@ -98,9 +126,13 @@ export class CoreWorkflowResolver {
@Mutation(() => CoreWorkflowDTO)
async duplicateCoreWorkflow(
@AuthWorkspace() { id: workspaceId }: WorkspaceEntity,
+ @AuthWorkspaceMember() workspaceMember:
+ | WorkspaceMemberWorkspaceEntity
+ | undefined,
+ @AuthApplication({ allowUndefined: true })
+ application: FlatApplication | undefined,
@AuthUserWorkspaceId({ allowUndefined: true })
userWorkspaceId: string | undefined,
- @AuthUser() user: AuthContextUser,
@Args('input')
{
coreWorkflowIdToDuplicate,
@@ -109,8 +141,8 @@ export class CoreWorkflowResolver {
): Promise<CoreWorkflowDTO> {
return this.coreWorkflowMutationWorkspaceService.duplicateWorkflow({
workspaceId,
+ createdBy: this.resolveCreatedByOrThrow({ workspaceMember, application }),
userWorkspaceId,
- user,
coreWorkflowIdToDuplicate,
coreWorkflowVersionIdToCopy,
});
@@ -119,15 +151,19 @@ export class CoreWorkflowResolver {
@Mutation(() => CoreWorkflowDTO)
async createCoreWorkflow(
@AuthWorkspace() { id: workspaceId }: WorkspaceEntity,
+ @AuthWorkspaceMember() workspaceMember:
+ | WorkspaceMemberWorkspaceEntity
+ | undefined,
+ @AuthApplication({ allowUndefined: true })
+ application: FlatApplication | undefined,
@AuthUserWorkspaceId({ allowUndefined: true })
userWorkspaceId: string | undefined,
- @AuthUser() user: AuthContextUser,
@Args('input') input: CreateCoreWorkflowInput,
): Promise<CoreWorkflowDTO> {
return this.coreWorkflowMutationWorkspaceService.createWorkflow({
workspaceId,
+ createdBy: this.resolveCreatedByOrThrow({ workspaceMember, application }),
userWorkspaceId,
- user,
...input,
});
}
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 1ca49dadc81..6fa117186b6 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
@@ -2,12 +2,10 @@ import { Injectable, Logger } from '@nestjs/common';
import { Equal, In, IsNull, Or } from 'typeorm';
import { msg } from '@lingui/core/macro';
-import { WorkflowVisibility } from 'twenty-shared/types';
+import { type ActorMetadata, WorkflowVisibility } from 'twenty-shared/types';
import { isDefined } from 'twenty-shared/utils';
import { v4 as uuidv4 } from 'uuid';
-import { buildCreatedByFromFullNameMetadata } from 'src/engine/core-modules/actor/utils/build-created-by-from-full-name-metadata.util';
-import { type AuthContextUser } from 'src/engine/core-modules/auth/types/auth-context.type';
import { RecordPositionService } from 'src/engine/core-modules/record-position/services/record-position.service';
import { type CoreWorkflowDTO } from 'src/engine/core-modules/workflow/dtos/core-workflow.dto';
import { type DeletedCoreWorkflowDTO } from 'src/engine/core-modules/workflow/dtos/deleted-core-workflow.dto';
@@ -44,7 +42,6 @@ import { WorkflowCommonWorkspaceService } from 'src/modules/workflow/common/work
import { remapDuplicatedStepDestinations } from 'src/modules/workflow/workflow-builder/utils/remap-duplicated-step-destinations.util';
import { WorkflowVersionStepOperationsWorkspaceService } from 'src/modules/workflow/workflow-builder/workflow-version-step/workflow-version-step-operations.workspace-service';
import { type WorkflowAction } from 'src/modules/workflow/workflow-executor/workflow-actions/types/workflow-action.type';
-import { type WorkspaceMemberWorkspaceEntity } from 'src/modules/workspace-member/standard-objects/workspace-member.workspace-entity';
@Injectable()
export class CoreWorkflowMutationWorkspaceService {
@@ -72,14 +69,14 @@ export class CoreWorkflowMutationWorkspaceService {
async duplicateWorkflow({
workspaceId,
+ createdBy,
userWorkspaceId,
- user,
coreWorkflowIdToDuplicate,
coreWorkflowVersionIdToCopy,
}: {
workspaceId: string;
+ createdBy: ActorMetadata;
userWorkspaceId: string | undefined;
- user: AuthContextUser;
coreWorkflowIdToDuplicate: string;
coreWorkflowVersionIdToCopy: string;
}): Promise<CoreWorkflowDTO> {
@@ -131,8 +128,8 @@ export class CoreWorkflowMutationWorkspaceService {
const duplicatedWorkflow = await this.createWorkflow({
workspaceId,
+ createdBy,
userWorkspaceId,
- user,
name: `${sourceCoreWorkflow.name ?? ''} (Duplicate)`,
// duplicating a private workflow must not publish it to the workspace
visibility: sourceCoreWorkflow.visibility,
@@ -354,14 +351,14 @@ export class CoreWorkflowMutationWorkspaceService {
async createWorkflow({
workspaceId,
+ createdBy,
userWorkspaceId,
- user,
name,
visibility,
}: {
workspaceId: string;
+ createdBy: ActorMetadata;
userWorkspaceId: string | undefined;
- user: AuthContextUser;
name?: string;
visibility?: WorkflowVisibility;
}): Promise<CoreWorkflowDTO> {
@@ -372,19 +369,6 @@ export class CoreWorkflowMutationWorkspaceService {
const authContext = buildSystemAuthContext(workspaceId);
- const workspaceMember =
- await this.workspaceOrmManager.executeInWorkspaceContext(async () => {
- const workspaceMemberRepository =
- this.workspaceOrmManager.getRepository<WorkspaceMemberWorkspaceEntity>(
- 'workspaceMember',
- { shouldBypassPermissionChecks: true },
- );
-
- return workspaceMemberRepository.findOneOrFail({
- where: { userId: user.id },
- });
- }, authContext);
-
const workspaceWorkflowId = uuidv4();
const coreWorkflow = await this.coreWorkflowRepository.insertAndReturnOne(
@@ -422,13 +406,7 @@ export class CoreWorkflowMutationWorkspaceService {
name: name ?? null,
position,
coreWorkflowId: coreWorkflow.id,
- createdBy: buildCreatedByFromFullNameMetadata({
- fullNameMetadata: {
- firstName: workspaceMember.name.firstName,
- lastName: workspaceMember.name.lastName,
- },
- workspaceMemberId: workspaceMember.id,
- }),
+ createdBy,
});
}, authContext);
diff --git a/packages/twenty-server/src/engine/core-modules/workflow/services/core-workflow-version-list.service.ts b/packages/twenty-server/src/engine/core-modules/workflow/services/core-workflow-version-list.service.ts
index 175144fe070..4c837fa5a7a 100644
--- a/packages/twenty-server/src/engine/core-modules/workflow/services/core-workflow-version-list.service.ts
+++ b/packages/twenty-server/src/engine/core-modules/workflow/services/core-workflow-version-list.service.ts
@@ -4,7 +4,10 @@ import { InjectDataSource } from '@nestjs/typeorm';
import { isDefined } from 'twenty-shared/utils';
import { DataSource } from 'typeorm';
-import { WorkflowVersionEntity } from 'src/engine/core-modules/workflow/entities/workflow-version.entity';
+import {
+ WorkflowVersionEntity,
+ WorkflowVersionStatus as CoreWorkflowVersionStatus,
+} from 'src/engine/core-modules/workflow/entities/workflow-version.entity';
import { WorkflowEntity } from 'src/engine/core-modules/workflow/entities/workflow.entity';
import { type CoreWorkflowVersionDTO } from 'src/engine/core-modules/workflow/dtos/core-workflow-version.dto';
import { CoreWorkflowAccessService } from 'src/engine/core-modules/workflow/services/core-workflow-access.service';
@@ -166,6 +169,17 @@ export class CoreWorkflowVersionListService {
.reverse();
}
+ async findDraftCoreWorkflowVersions({
+ workspaceId,
+ }: {
+ workspaceId: string;
+ }): Promise<Pick<WorkflowVersionEntity, 'id' | 'steps'>[]> {
+ return this.coreWorkflowVersionRepository.find(workspaceId, {
+ where: { status: CoreWorkflowVersionStatus.DRAFT },
+ select: { id: true, steps: true },
+ });
+ }
+
async findOneByCoreWorkflowVersionId({
workspaceId,
userWorkspaceId,
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 78324f18af7..ec8fee45d29 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
@@ -35,6 +35,7 @@ import {
WorkflowVersionStepException,
WorkflowVersionStepExceptionCode,
} from 'src/modules/workflow/common/exceptions/workflow-version-step.exception';
+import { computeWorkflowStepPositions } from 'src/modules/workflow/workflow-builder/utils/compute-workflow-step-positions.util';
import { computeWorkflowVersionStepChanges } from 'src/modules/workflow/workflow-builder/utils/compute-workflow-version-step-updates.util';
import { WorkflowSchemaWorkspaceService } from 'src/modules/workflow/workflow-builder/workflow-schema/workflow-schema.workspace-service';
import {
@@ -656,6 +657,31 @@ export class CoreWorkflowVersionMutationWorkspaceService {
});
}
+ async autoLayoutCoreWorkflowVersion({
+ workspaceId,
+ userWorkspaceId,
+ coreWorkflowVersionId,
+ }: {
+ workspaceId: string;
+ userWorkspaceId: string | undefined;
+ coreWorkflowVersionId: string;
+ }): Promise<void> {
+ const { trigger, steps } =
+ await this.coreWorkflowVersionWriteService.getValidatedDraftCoreWorkflowVersion(
+ { workspaceId, userWorkspaceId, coreWorkflowVersionId },
+ );
+
+ await this.updatePositions({
+ workspaceId,
+ userWorkspaceId,
+ coreWorkflowVersionId,
+ positions: computeWorkflowStepPositions({
+ trigger,
+ steps: steps ?? [],
+ }),
+ });
+ }
+
@WithLock('coreWorkflowId')
async createDraftFromCoreWorkflowVersion({
workspaceId,
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 38baff09c01..734a296722c 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
@@ -17,14 +17,8 @@ import { WorkflowVersionResolver } from 'src/engine/core-modules/workflow/resolv
import { RecordPositionModule } from 'src/engine/core-modules/record-position/record-position.module';
import { WorkflowEntity } from 'src/engine/core-modules/workflow/entities/workflow.entity';
import { CoreWorkflowAccessModule } from 'src/engine/core-modules/workflow/core-workflow-access.module';
-import { CoreWorkflowIdResolutionService } from 'src/engine/core-modules/workflow/services/core-workflow-id-resolution.service';
-import { CoreWorkflowLifecycleWorkspaceService } from 'src/engine/core-modules/workflow/services/core-workflow-lifecycle.workspace-service';
-import { CoreWorkflowListService } from 'src/engine/core-modules/workflow/services/core-workflow-list.service';
-import { CoreWorkflowMutationWorkspaceService } from 'src/engine/core-modules/workflow/services/core-workflow-mutation.workspace-service';
-import { CoreWorkflowVersionMutationWorkspaceService } from 'src/engine/core-modules/workflow/services/core-workflow-version-mutation.workspace-service';
-import { CoreWorkflowVersionWriteService } from 'src/engine/core-modules/workflow/services/core-workflow-version-write.service';
+import { CoreWorkflowServicesModule } from 'src/engine/core-modules/workflow/core-workflow-services.module';
import { WorkflowCoreModule } from 'src/engine/core-modules/workflow/workflow-core.module';
-import { CoreWorkflowVersionListService } from 'src/engine/core-modules/workflow/services/core-workflow-version-list.service';
import { WorkflowVersionEntity } from 'src/engine/core-modules/workflow/entities/workflow-version.entity';
import { WorkflowVersionCoreModule } from 'src/engine/core-modules/workflow/workflow-version-core.module';
import { WorkspaceEntity } from 'src/engine/core-modules/workspace/workspace.entity';
@@ -69,6 +63,7 @@ import { WorkflowTriggerModule } from 'src/modules/workflow/workflow-trigger/wor
ConnectedAccountMetadataModule,
WorkflowVersionCoreModule,
WorkflowVersionValidationModule,
+ CoreWorkflowServicesModule,
],
controllers: [WorkflowTriggerController],
providers: [
@@ -79,13 +74,6 @@ import { WorkflowTriggerModule } from 'src/modules/workflow/workflow-trigger/wor
WorkflowVersionResolver,
CoreWorkflowResolver,
CoreWorkflowVersionMutationResolver,
- CoreWorkflowIdResolutionService,
- CoreWorkflowLifecycleWorkspaceService,
- CoreWorkflowListService,
- CoreWorkflowMutationWorkspaceService,
- CoreWorkflowVersionMutationWorkspaceService,
- CoreWorkflowVersionWriteService,
- CoreWorkflowVersionListService,
provideWorkspaceScopedRepository(WorkflowVersionEntity),
provideWorkspaceScopedRepository(WorkflowEntity),
],
diff --git a/packages/twenty-server/src/engine/decorators/auth/auth-workspace-member.decorator.ts b/packages/twenty-server/src/engine/decorators/auth/auth-workspace-member.decorator.ts
new file mode 100644
index 00000000000..aa85a1dcd97
--- /dev/null
+++ b/packages/twenty-server/src/engine/decorators/auth/auth-workspace-member.decorator.ts
@@ -0,0 +1,11 @@
+import { type ExecutionContext, createParamDecorator } from '@nestjs/common';
+
+import { getRequest } from 'src/utils/extract-request';
+
+export const AuthWorkspaceMember = createParamDecorator(
+ (_data: unknown, ctx: ExecutionContext) => {
+ const request = getRequest(ctx);
+
+ return request.workspaceMember;
+ },
+);
diff --git a/packages/twenty-server/src/engine/guards/user-or-application-auth.guard.ts b/packages/twenty-server/src/engine/guards/user-or-application-auth.guard.ts
new file mode 100644
index 00000000000..37e2dd74dea
--- /dev/null
+++ b/packages/twenty-server/src/engine/guards/user-or-application-auth.guard.ts
@@ -0,0 +1,17 @@
+import { type CanActivate, type ExecutionContext } from '@nestjs/common';
+
+import { isDefined } from 'twenty-shared/utils';
+
+import { getRequestOrThrowWhenUnauthenticated } from 'src/engine/guards/utils/get-request-or-throw-when-unauthenticated.util';
+
+export class UserOrApplicationAuthGuard implements CanActivate {
+ canActivate(context: ExecutionContext): boolean {
+ const request = getRequestOrThrowWhenUnauthenticated(context);
+
+ if (!request) {
+ return false;
+ }
+
+ return isDefined(request.user) || isDefined(request.application);
+ }
+}
diff --git a/packages/twenty-server/src/engine/workspace-manager/twenty-standard-application/utils/skill-metadata/create-standard-flat-skill-metadata.util.ts b/packages/twenty-server/src/engine/workspace-manager/twenty-standard-application/utils/skill-metadata/create-standard-flat-skill-metadata.util.ts
index 416acb07c6f..ca9b5edd36e 100644
--- a/packages/twenty-server/src/engine/workspace-manager/twenty-standard-application/utils/skill-metadata/create-standard-flat-skill-metadata.util.ts
+++ b/packages/twenty-server/src/engine/workspace-manager/twenty-standard-application/utils/skill-metadata/create-standard-flat-skill-metadata.util.ts
@@ -66,18 +66,18 @@ LOGIC_FUNCTION steps execute logic functions provided by installed applications.
1. Call \`list_logic_function_tools\` to discover available logic function tools with their IDs.
2. Use \`create_workflow_version_step\` with stepType "LOGIC_FUNCTION" and pass the logicFunctionId in defaultSettings:
- { "stepType": "LOGIC_FUNCTION", "workflowVersionId": "<version-id>", "defaultSettings": { "input": { "logicFunctionId": "<logic-function-id>" } } }
+ { "stepType": "LOGIC_FUNCTION", "coreWorkflowVersionId": "<core-version-id>", "defaultSettings": { "input": { "logicFunctionId": "<logic-function-id>" } } }
3. Or when using \`create_complete_workflow\`, include a step with type "LOGIC_FUNCTION" and settings.input.logicFunctionId.
## Listing Workflows
-To discover existing workflows in the workspace, use \`list_workflows\`. Use this before modifying a workflow when the user refers to it by name rather than id — resolve the \`id\` here first, then call \`get_workflow_current_version\` with it.
+To discover existing workflows in the workspace, use \`list_workflows\`. Use this before modifying a workflow when the user refers to it by name rather than id — resolve the \`coreWorkflowId\` here first, then call \`get_workflow_current_version\` with it.
## Deleting Workflows
-To delete a workflow entirely, use \`delete_workflow\` with its \`workflowId\`. This also removes the workflow's versions, runs and automated triggers, and deactivates any active version — it is a destructive, irreversible operation.
+To delete a workflow entirely, use \`delete_workflow\` with its \`coreWorkflowId\`. This also removes the workflow's versions, runs and automated triggers, and deactivates any active version — it is a destructive, irreversible operation.
-- If the user refers to the workflow by name, resolve its \`workflowId\` with \`list_workflows\` first.
+- If the user refers to the workflow by name, resolve its \`coreWorkflowId\` with \`list_workflows\` first.
- IMPORTANT : Always confirm with the user before deleting, and make sure you are deleting the correct workflow.
- To simply stop a workflow from running without removing it, prefer \`deactivate_workflow_version\` instead of deleting.
@@ -85,19 +85,19 @@ To delete a workflow entirely, use \`delete_workflow\` with its \`workflowId\`.
When a user reports a failing or misbehaving workflow, diagnose it with two read-only tools:
-- \`list_workflow_runs\`: lists runs (optional \`workflowId\`, optional \`status\`, optional \`limit\`), most recent first. Each result carries \`id\`, \`name\`, \`status\`, run-level \`error\`, \`startedAt\`, \`endedAt\`, \`workflowId\`, and \`workflowVersionId\`.
+- \`list_workflow_runs\`: lists runs (optional \`coreWorkflowId\`, optional \`status\`, optional \`limit\`), most recent first. Each result carries the run \`id\`, \`name\`, \`status\`, run-level \`error\`, \`startedAt\`, \`endedAt\`, \`coreWorkflowId\`, and \`coreWorkflowVersionId\`.
- \`get_workflow_run\`: returns full details for one run (\`workflowRunId\`) — overall status, run-level error, every step's status/error, and the execution logs of the steps that failed.
### Resolving the run when no id is given
-For requests like "fix my latest failed workflow" where no run or workflow id is provided, call \`list_workflow_runs\` with \`status\` "FAILED" and NO \`workflowId\` — this returns the most recent failed run across all workflows, and each result already carries \`workflowId\`, \`workflowVersionId\`, and a human-readable \`name\`, so you never need an id from the user. If the user names a specific workflow, resolve its \`workflowId\` first and pass it as a filter.
+For requests like "fix my latest failed workflow" where no run or workflow id is provided, call \`list_workflow_runs\` with \`status\` "FAILED" and NO \`coreWorkflowId\` — this returns the most recent failed run across all workflows, and each result already carries \`coreWorkflowId\`, \`coreWorkflowVersionId\`, and a human-readable \`name\`, so you never need an id from the user. If the user names a specific workflow, resolve its \`coreWorkflowId\` first and pass it as a filter.
### Flow
-1. Identify the run via \`list_workflow_runs\` (use \`limit\` 5 when no \`workflowId\` so you can detect multiple failing workflows).
-2. If results span multiple \`workflowId\`s, disambiguate by name with the user before editing anything.
+1. Identify the run via \`list_workflow_runs\` (use \`limit\` 5 when no \`coreWorkflowId\` so you can detect multiple failing workflows).
+2. If results span multiple \`coreWorkflowId\`s, disambiguate by name with the user before editing anything.
3. Call \`get_workflow_run\` on the chosen run id to read the failed step(s) and their error/logs.
-4. Map back to the workflow definition via \`get_workflow_current_version(workflowId)\`, then propose or apply a fix.
+4. Map back to the workflow definition via \`get_workflow_current_version(coreWorkflowId)\`, then propose or apply a fix.
## PICK_RECORD Steps
PICK_RECORD selects one record from a candidate pool (settings.input.recordIds) and outputs it for later steps to reference — useful for assignment workflows like picking an owner. Set settings.input.strategy to RANDOM, ROUND_ROBIN, or LOAD_BALANCED; LOAD_BALANCED also needs settings.input.loadBalance.{objectNameSingular, fieldName} to pick the candidate with the fewest related records.
diff --git a/packages/twenty-server/src/modules/workflow/workflow-builder/utils/compute-workflow-step-positions.util.ts b/packages/twenty-server/src/modules/workflow/workflow-builder/utils/compute-workflow-step-positions.util.ts
new file mode 100644
index 00000000000..16d377a2f1c
--- /dev/null
+++ b/packages/twenty-server/src/modules/workflow/workflow-builder/utils/compute-workflow-step-positions.util.ts
@@ -0,0 +1,36 @@
+import {
+ buildWorkflowGraph,
+ computeWorkflowLayout,
+ TRIGGER_STEP_ID,
+ WORKFLOW_DIAGRAM_DEFAULT_NODE_DIMENSIONS,
+} from 'twenty-shared/workflow';
+
+import { type WorkflowStepPositionUpdateInput } from 'src/engine/core-modules/workflow/dtos/update-workflow-step-position-update.input';
+import { type WorkflowAction } from 'src/modules/workflow/workflow-executor/workflow-actions/types/workflow-action.type';
+import { type WorkflowTrigger } from 'src/modules/workflow/workflow-trigger/types/workflow-trigger.type';
+
+export const computeWorkflowStepPositions = ({
+ trigger,
+ steps,
+}: {
+ trigger: WorkflowTrigger | null;
+ steps: WorkflowAction[];
+}): WorkflowStepPositionUpdateInput[] => {
+ const { childrenByStepId } = buildWorkflowGraph({ trigger, steps });
+
+ const nodes = [
+ { id: TRIGGER_STEP_ID, ...WORKFLOW_DIAGRAM_DEFAULT_NODE_DIMENSIONS },
+ ...steps.map((step) => ({
+ id: step.id,
+ ...WORKFLOW_DIAGRAM_DEFAULT_NODE_DIMENSIONS,
+ })),
+ ];
+
+ const edges = [...childrenByStepId.entries()].flatMap(([source, targets]) =>
+ targets.map((target) => ({ source, target })),
+ );
+
+ return computeWorkflowLayout({ nodes, edges }).map(
+ ({ id, centerPosition }) => ({ id, position: centerPosition }),
+ );
+};
diff --git a/packages/twenty-server/src/modules/workflow/workflow-builder/workflow-version/workflow-version.workspace-service.ts b/packages/twenty-server/src/modules/workflow/workflow-builder/workflow-version/workflow-version.workspace-service.ts
index 34e51e7dc18..33b7084398b 100644
--- a/packages/twenty-server/src/modules/workflow/workflow-builder/workflow-version/workflow-version.workspace-service.ts
+++ b/packages/twenty-server/src/modules/workflow/workflow-builder/workflow-version/workflow-version.workspace-service.ts
@@ -1,12 +1,7 @@
import { Injectable } from '@nestjs/common';
import { isDefined } from 'twenty-shared/utils';
-import {
- buildWorkflowGraph,
- computeWorkflowLayout,
- TRIGGER_STEP_ID,
- WORKFLOW_DIAGRAM_DEFAULT_NODE_DIMENSIONS,
-} from 'twenty-shared/workflow';
+import { TRIGGER_STEP_ID } from 'twenty-shared/workflow';
import { WithLock } from 'src/engine/core-modules/cache-lock/with-lock.decorator';
import { RecordPositionService } from 'src/engine/core-modules/record-position/services/record-position.service';
@@ -30,6 +25,7 @@ import { assertWorkflowVersionHasSteps } from 'src/modules/workflow/common/utils
import { assertWorkflowVersionIsDraft } from 'src/modules/workflow/common/utils/assert-workflow-version-is-draft.util';
import { assertWorkflowVersionTriggerIsDefined } from 'src/modules/workflow/common/utils/assert-workflow-version-trigger-is-defined.util';
import { WorkflowCommonWorkspaceService } from 'src/modules/workflow/common/workspace-services/workflow-common.workspace-service';
+import { computeWorkflowStepPositions } from 'src/modules/workflow/workflow-builder/utils/compute-workflow-step-positions.util';
import { remapDuplicatedStepDestinations } from 'src/modules/workflow/workflow-builder/utils/remap-duplicated-step-destinations.util';
import { WorkflowVersionStepOperationsWorkspaceService } from 'src/modules/workflow/workflow-builder/workflow-version-step/workflow-version-step-operations.workspace-service';
import { WorkflowVersionStepWorkspaceService } from 'src/modules/workflow/workflow-builder/workflow-version-step/workflow-version-step.workspace-service';
@@ -417,35 +413,12 @@ export class WorkflowVersionWorkspaceService {
assertWorkflowVersionIsDraft(workflowVersion);
- const steps = workflowVersion.steps ?? [];
-
- const { childrenByStepId } = buildWorkflowGraph({
- trigger: workflowVersion.trigger,
- steps,
- });
-
- const nodes = [
- {
- id: TRIGGER_STEP_ID,
- ...WORKFLOW_DIAGRAM_DEFAULT_NODE_DIMENSIONS,
- },
- ...steps.map((step) => ({
- id: step.id,
- ...WORKFLOW_DIAGRAM_DEFAULT_NODE_DIMENSIONS,
- })),
- ];
-
- const edges = [...childrenByStepId.entries()].flatMap(([source, targets]) =>
- targets.map((target) => ({ source, target })),
- );
-
- const positions = computeWorkflowLayout({ nodes, edges }).map(
- ({ id, centerPosition }) => ({ id, position: centerPosition }),
- );
-
await this.updateWorkflowVersionPositions({
workflowVersionId,
- positions,
+ positions: computeWorkflowStepPositions({
+ trigger: workflowVersion.trigger,
+ steps: workflowVersion.steps ?? [],
+ }),
workspaceId,
});
}
diff --git a/packages/twenty-server/src/modules/workflow/workflow-tools/constants/default-agent-workflow-actor.constant.ts b/packages/twenty-server/src/modules/workflow/workflow-tools/constants/default-agent-workflow-actor.constant.ts
new file mode 100644
index 00000000000..3e693ddf5f2
--- /dev/null
+++ b/packages/twenty-server/src/modules/workflow/workflow-tools/constants/default-agent-workflow-actor.constant.ts
@@ -0,0 +1,8 @@
+import { type ActorMetadata, FieldActorSource } from 'twenty-shared/types';
+
+export const DEFAULT_AGENT_WORKFLOW_ACTOR: ActorMetadata = {
+ source: FieldActorSource.AGENT,
+ workspaceMemberId: null,
+ name: 'Agent',
+ context: {},
+};
diff --git a/packages/twenty-server/src/modules/workflow/workflow-tools/services/workflow-tool.workspace-service.ts b/packages/twenty-server/src/modules/workflow/workflow-tools/services/workflow-tool.workspace-service.ts
index 86acdf15255..2a46b6aff2a 100644
--- a/packages/twenty-server/src/modules/workflow/workflow-tools/services/workflow-tool.workspace-service.ts
+++ b/packages/twenty-server/src/modules/workflow/workflow-tools/services/workflow-tool.workspace-service.ts
@@ -1,21 +1,20 @@
import { Injectable } from '@nestjs/common';
import { type ToolSet } from 'ai';
+import { type ActorMetadata } from 'twenty-shared/types';
-import { RecordPositionService } from 'src/engine/core-modules/record-position/services/record-position.service';
-import { WorkflowVersionCoreSyncService } from 'src/engine/core-modules/workflow/services/workflow-version-core-sync.service';
+import { CoreWorkflowLifecycleWorkspaceService } from 'src/engine/core-modules/workflow/services/core-workflow-lifecycle.workspace-service';
+import { CoreWorkflowListService } from 'src/engine/core-modules/workflow/services/core-workflow-list.service';
+import { CoreWorkflowMutationWorkspaceService } from 'src/engine/core-modules/workflow/services/core-workflow-mutation.workspace-service';
+import { CoreWorkflowVersionListService } from 'src/engine/core-modules/workflow/services/core-workflow-version-list.service';
+import { CoreWorkflowVersionMutationWorkspaceService } from 'src/engine/core-modules/workflow/services/core-workflow-version-mutation.workspace-service';
+import { CoreWorkflowVersionWriteService } from 'src/engine/core-modules/workflow/services/core-workflow-version-write.service';
import { AgentService } from 'src/engine/metadata-modules/ai/ai-agent/agent.service';
import { WorkspaceManyOrAllFlatEntityMapsCacheService } from 'src/engine/metadata-modules/flat-entity/services/workspace-many-or-all-flat-entity-maps-cache.service';
import { LogicFunctionFromSourceService } from 'src/engine/metadata-modules/logic-function/services/logic-function-from-source.service';
-import { WorkspaceOrmManager } from 'src/engine/twenty-orm/workspace-orm.manager';
import { type RolePermissionConfig } from 'src/engine/twenty-orm/types/role-permission-config';
-import { WorkflowCommonWorkspaceService } from 'src/modules/workflow/common/workspace-services/workflow-common.workspace-service';
+import { WorkspaceOrmManager } from 'src/engine/twenty-orm/workspace-orm.manager';
import { WorkflowSchemaWorkspaceService } from 'src/modules/workflow/workflow-builder/workflow-schema/workflow-schema.workspace-service';
-import { WorkflowVersionValidationWorkspaceService } from 'src/modules/workflow/workflow-builder/workflow-validation/workflow-version-validation.workspace-service';
-import { WorkflowVersionEdgeWorkspaceService } from 'src/modules/workflow/workflow-builder/workflow-version-edge/workflow-version-edge.workspace-service';
-import { WorkflowVersionStepHelpersWorkspaceService } from 'src/modules/workflow/workflow-builder/workflow-version-step/workflow-version-step-helpers.workspace-service';
-import { WorkflowVersionStepWorkspaceService } from 'src/modules/workflow/workflow-builder/workflow-version-step/workflow-version-step.workspace-service';
-import { WorkflowVersionWorkspaceService } from 'src/modules/workflow/workflow-builder/workflow-version/workflow-version.workspace-service';
import { createActivateWorkflowVersionTool } from 'src/modules/workflow/workflow-tools/tools/activate-workflow-version.tool';
import { createComputeStepOutputSchemaTool } from 'src/modules/workflow/workflow-tools/tools/compute-step-output-schema.tool';
import { createCreateCompleteWorkflowTool } from 'src/modules/workflow/workflow-tools/tools/create-complete-workflow.tool';
@@ -38,156 +37,86 @@ import { createUpdateWorkflowVersionPositionsTool } from 'src/modules/workflow/w
import { createUpdateWorkflowVersionStepTool } from 'src/modules/workflow/workflow-tools/tools/update-workflow-version-step.tool';
import { createUpdateWorkflowVersionTriggerTool } from 'src/modules/workflow/workflow-tools/tools/update-workflow-version-trigger.tool';
import { createValidateWorkflowTool } from 'src/modules/workflow/workflow-tools/tools/validate-workflow.tool';
-import { type WorkflowToolDependencies } from 'src/modules/workflow/workflow-tools/types/workflow-tool-dependencies.type';
-import { WorkflowTriggerWorkspaceService } from 'src/modules/workflow/workflow-trigger/workspace-services/workflow-trigger.workspace-service';
+import {
+ type WorkflowToolContext,
+ type WorkflowToolDependencies,
+} from 'src/modules/workflow/workflow-tools/types/workflow-tool-dependencies.type';
@Injectable()
export class WorkflowToolWorkspaceService {
private readonly deps: WorkflowToolDependencies;
constructor(
- workflowVersionStepService: WorkflowVersionStepWorkspaceService,
- workflowVersionStepHelpersService: WorkflowVersionStepHelpersWorkspaceService,
- workflowVersionEdgeService: WorkflowVersionEdgeWorkspaceService,
- workflowVersionService: WorkflowVersionWorkspaceService,
- workflowTriggerService: WorkflowTriggerWorkspaceService,
+ coreWorkflowListService: CoreWorkflowListService,
+ coreWorkflowVersionListService: CoreWorkflowVersionListService,
+ coreWorkflowMutationService: CoreWorkflowMutationWorkspaceService,
+ coreWorkflowVersionMutationService: CoreWorkflowVersionMutationWorkspaceService,
+ coreWorkflowVersionWriteService: CoreWorkflowVersionWriteService,
+ coreWorkflowLifecycleService: CoreWorkflowLifecycleWorkspaceService,
workflowSchemaService: WorkflowSchemaWorkspaceService,
- workflowVersionValidationWorkspaceService: WorkflowVersionValidationWorkspaceService,
workspaceOrmManager: WorkspaceOrmManager,
- recordPositionService: RecordPositionService,
logicFunctionFromSourceService: LogicFunctionFromSourceService,
flatEntityMapsCacheService: WorkspaceManyOrAllFlatEntityMapsCacheService,
agentService: AgentService,
- workflowCommonService: WorkflowCommonWorkspaceService,
- workflowVersionCoreSyncService: WorkflowVersionCoreSyncService,
) {
this.deps = {
- workflowVersionStepService,
- workflowVersionStepHelpersService,
- workflowVersionEdgeService,
- workflowVersionService,
- workflowTriggerService,
+ coreWorkflowListService,
+ coreWorkflowVersionListService,
+ coreWorkflowMutationService,
+ coreWorkflowVersionMutationService,
+ coreWorkflowVersionWriteService,
+ coreWorkflowLifecycleService,
workflowSchemaService,
- workflowVersionValidationWorkspaceService,
workspaceOrmManager,
- recordPositionService,
logicFunctionFromSourceService,
flatEntityMapsCacheService,
agentService,
- workflowCommonService,
- workflowVersionCoreSyncService,
};
}
- generateWorkflowTools(
- workspaceId: string,
- rolePermissionConfig: RolePermissionConfig,
- ): ToolSet {
- const context = { workspaceId };
- const contextWithPermissions = { workspaceId, rolePermissionConfig };
+ generateWorkflowTools({
+ workspaceId,
+ rolePermissionConfig,
+ actorContext,
+ userWorkspaceId,
+ }: {
+ workspaceId: string;
+ rolePermissionConfig: RolePermissionConfig;
+ actorContext?: ActorMetadata;
+ userWorkspaceId?: string;
+ }): ToolSet {
+ const context: WorkflowToolContext = {
+ workspaceId,
+ rolePermissionConfig,
+ actorContext,
+ userWorkspaceId,
+ };
- const createCompleteWorkflow = createCreateCompleteWorkflowTool(
- this.deps,
- contextWithPermissions,
- );
- const createWorkflowVersionStep = createCreateWorkflowVersionStepTool(
- this.deps,
- context,
- );
- const updateWorkflowVersionStep = createUpdateWorkflowVersionStepTool(
- this.deps,
- context,
- );
- const updateWorkflowVersionTrigger = createUpdateWorkflowVersionTriggerTool(
- this.deps,
- context,
- );
- const deleteWorkflowVersionStep = createDeleteWorkflowVersionStepTool(
- this.deps,
- context,
- );
- const createWorkflowVersionEdge = createCreateWorkflowVersionEdgeTool(
- this.deps,
- context,
- );
- const deleteWorkflowVersionEdge = createDeleteWorkflowVersionEdgeTool(
- this.deps,
- context,
- );
- const createDraftFromWorkflowVersion =
- createCreateDraftFromWorkflowVersionTool(this.deps, context);
- const updateWorkflowVersionPositions =
- createUpdateWorkflowVersionPositionsTool(this.deps, context);
- const activateWorkflowVersion = createActivateWorkflowVersionTool(
- this.deps,
- context,
- );
- const deactivateWorkflowVersion = createDeactivateWorkflowVersionTool(
- this.deps,
- context,
- );
- const computeStepOutputSchema = createComputeStepOutputSchemaTool(
- this.deps,
- context,
- );
- const getWorkflowCurrentVersion = createGetWorkflowCurrentVersionTool(
- this.deps,
- contextWithPermissions,
- );
- const getWorkflowRun = createGetWorkflowRunTool(
- this.deps,
- contextWithPermissions,
- );
- const listWorkflowRuns = createListWorkflowRunsTool(
- this.deps,
- contextWithPermissions,
- );
- const listWorkflows = createListWorkflowsTool(
- this.deps,
- contextWithPermissions,
- );
- const deleteWorkflow = createDeleteWorkflowTool(
- this.deps,
- contextWithPermissions,
- );
- const getLogicFunctionSource = createGetLogicFunctionSourceTool(
- this.deps,
- context,
- );
- const updateLogicFunctionSource = createUpdateLogicFunctionSourceTool(
- this.deps,
- context,
- );
- const listLogicFunctionTools = createListLogicFunctionToolsTool(
- this.deps,
- context,
- );
- const updateAgent = createUpdateAgentTool(this.deps, context);
- const validateWorkflow = createValidateWorkflowTool(this.deps, context);
+ const tools = [
+ createCreateCompleteWorkflowTool(this.deps, context),
+ createCreateWorkflowVersionStepTool(this.deps, context),
+ createUpdateWorkflowVersionStepTool(this.deps, context),
+ createUpdateWorkflowVersionTriggerTool(this.deps, context),
+ createDeleteWorkflowVersionStepTool(this.deps, context),
+ createCreateWorkflowVersionEdgeTool(this.deps, context),
+ createDeleteWorkflowVersionEdgeTool(this.deps, context),
+ createCreateDraftFromWorkflowVersionTool(this.deps, context),
+ createUpdateWorkflowVersionPositionsTool(this.deps, context),
+ createActivateWorkflowVersionTool(this.deps, context),
+ createDeactivateWorkflowVersionTool(this.deps, context),
+ createComputeStepOutputSchemaTool(this.deps, context),
+ createGetWorkflowCurrentVersionTool(this.deps, context),
+ createListWorkflowsTool(this.deps, context),
+ createDeleteWorkflowTool(this.deps, context),
+ createGetWorkflowRunTool(this.deps, context),
+ createListWorkflowRunsTool(this.deps, context),
+ createGetLogicFunctionSourceTool(this.deps, context),
+ createUpdateLogicFunctionSourceTool(this.deps, context),
+ createListLogicFunctionToolsTool(this.deps, context),
+ createUpdateAgentTool(this.deps, context),
+ createValidateWorkflowTool(this.deps, context),
+ ];
- return {
- [createCompleteWorkflow.name]: createCompleteWorkflow,
- [createWorkflowVersionStep.name]: createWorkflowVersionStep,
- [updateWorkflowVersionStep.name]: updateWorkflowVersionStep,
- [updateWorkflowVersionTrigger.name]: updateWorkflowVersionTrigger,
- [deleteWorkflowVersionStep.name]: deleteWorkflowVersionStep,
- [createWorkflowVersionEdge.name]: createWorkflowVersionEdge,
- [deleteWorkflowVersionEdge.name]: deleteWorkflowVersionEdge,
- [createDraftFromWorkflowVersion.name]: createDraftFromWorkflowVersion,
- [updateWorkflowVersionPositions.name]: updateWorkflowVersionPositions,
- [activateWorkflowVersion.name]: activateWorkflowVersion,
- [deactivateWorkflowVersion.name]: deactivateWorkflowVersion,
- [computeStepOutputSchema.name]: computeStepOutputSchema,
- [getWorkflowCurrentVersion.name]: getWorkflowCurrentVersion,
- [listWorkflows.name]: listWorkflows,
- [deleteWorkflow.name]: deleteWorkflow,
- [getWorkflowRun.name]: getWorkflowRun,
- [listWorkflowRuns.name]: listWorkflowRuns,
- [getLogicFunctionSource.name]: getLogicFunctionSource,
- [updateLogicFunctionSource.name]: updateLogicFunctionSource,
- [listLogicFunctionTools.name]: listLogicFunctionTools,
- [updateAgent.name]: updateAgent,
- [validateWorkflow.name]: validateWorkflow,
- };
+ return Object.fromEntries(tools.map((tool) => [tool.name, tool]));
}
}
diff --git a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/__tests__/delete-workflow.tool.spec.ts b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/__tests__/delete-workflow.tool.spec.ts
index 6afe8ba9862..3afea0ab37c 100644
--- a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/__tests__/delete-workflow.tool.spec.ts
+++ b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/__tests__/delete-workflow.tool.spec.ts
@@ -1,70 +1,79 @@
import { createDeleteWorkflowTool } from 'src/modules/workflow/workflow-tools/tools/delete-workflow.tool';
-const WORKFLOW_ID = 'b3b8a4f0-0000-4000-8000-000000000000';
+const CORE_WORKFLOW_ID = 'b3b8a4f0-0000-4000-8000-000000000000';
const buildTool = () => {
- const workflowRepository = {
- softDelete: jest.fn().mockResolvedValue({ affected: 1 }),
+ const coreWorkflowListService = {
+ findOneById: jest.fn().mockResolvedValue({ id: CORE_WORKFLOW_ID }),
};
- const workspaceOrmManager = {
- executeInWorkspaceContext: jest.fn((callback: () => unknown) => callback()),
- getRepository: jest.fn().mockReturnValue(workflowRepository),
- };
- const workflowCommonService = {
- handleWorkflowSubEntities: jest.fn().mockResolvedValue(undefined),
+ const coreWorkflowMutationService = {
+ deleteWorkflows: jest.fn().mockResolvedValue([]),
};
const tool = createDeleteWorkflowTool(
{
- workspaceOrmManager,
- workflowCommonService,
+ coreWorkflowListService,
+ coreWorkflowMutationService,
} as never,
{
workspaceId: 'workspace-id',
rolePermissionConfig: { shouldBypassPermissionChecks: true },
- } as never,
+ },
);
- return {
- tool,
- workflowRepository,
- workspaceOrmManager,
- workflowCommonService,
- };
+ return { tool, coreWorkflowListService, coreWorkflowMutationService };
};
-const baseInput = {
- workflowId: WORKFLOW_ID,
-} as unknown as Parameters<
- ReturnType<typeof createDeleteWorkflowTool>['execute']
->[0];
+const baseInput = { coreWorkflowId: CORE_WORKFLOW_ID };
describe('createDeleteWorkflowTool', () => {
beforeEach(() => {
jest.clearAllMocks();
});
- it('should soft delete the workflow and clean up sub-entities', async () => {
- const { tool, workflowRepository, workflowCommonService } = buildTool();
+ it('should delete the workflow through the core destroy path', async () => {
+ const { tool, coreWorkflowMutationService } = buildTool();
const result = (await tool.execute(baseInput)) as Record<string, unknown>;
- expect(workflowRepository.softDelete).toHaveBeenCalledWith(WORKFLOW_ID);
- expect(
- workflowCommonService.handleWorkflowSubEntities,
- ).toHaveBeenCalledWith({
- workflowIds: [WORKFLOW_ID],
+ expect(coreWorkflowMutationService.deleteWorkflows).toHaveBeenCalledWith({
workspaceId: 'workspace-id',
- operation: 'delete',
+ userWorkspaceId: undefined,
+ coreWorkflowIds: [CORE_WORKFLOW_ID],
});
expect(result.success).toBe(true);
- expect(result.workflowId).toBe(WORKFLOW_ID);
+ expect(result.coreWorkflowId).toBe(CORE_WORKFLOW_ID);
+ });
+
+ it('should delete a workflow that has no workspace mirror', async () => {
+ const { tool, coreWorkflowMutationService } = buildTool();
+
+ coreWorkflowMutationService.deleteWorkflows.mockResolvedValue([]);
+
+ const result = (await tool.execute(baseInput)) as Record<string, unknown>;
+
+ expect(result.success).toBe(true);
+ });
+
+ it('should report not found without deleting when the core workflow is absent', async () => {
+ const { tool, coreWorkflowListService, coreWorkflowMutationService } =
+ buildTool();
+
+ coreWorkflowListService.findOneById.mockResolvedValue(null);
+
+ const result = (await tool.execute(baseInput)) as Record<string, unknown>;
+
+ expect(coreWorkflowMutationService.deleteWorkflows).not.toHaveBeenCalled();
+ expect(result.success).toBe(false);
+ expect(result.error).toBe('Workflow not found');
});
it('should return a failure result when deletion throws', async () => {
- const { tool, workflowRepository } = buildTool();
+ const { tool, coreWorkflowMutationService } = buildTool();
- workflowRepository.softDelete.mockRejectedValue(new Error('boom'));
+ coreWorkflowMutationService.deleteWorkflows.mockRejectedValue(
+ new Error('boom'),
+ );
const result = (await tool.execute(baseInput)) as Record<string, unknown>;
diff --git a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/__tests__/get-workflow-current-version.tool.spec.ts b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/__tests__/get-workflow-current-version.tool.spec.ts
index 159d640b666..bd58bf66b31 100644
--- a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/__tests__/get-workflow-current-version.tool.spec.ts
+++ b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/__tests__/get-workflow-current-version.tool.spec.ts
@@ -1,11 +1,13 @@
-import { WorkflowVersionStatus } from 'src/modules/workflow/common/standard-objects/workflow-version.workspace-entity';
+import { WorkflowVersionStatus as CoreWorkflowVersionStatus } from 'src/engine/core-modules/workflow/entities/workflow-version.entity';
import { type WorkflowToolDependencies } from 'src/modules/workflow/workflow-tools/types/workflow-tool-dependencies.type';
import { createGetWorkflowCurrentVersionTool } from '../get-workflow-current-version.tool';
const WORKSPACE_ID = '20202020-aaaa-4d02-bf25-6aeccf7ea419';
-const WORKFLOW_ID = '20202020-bbbb-4d02-bf25-6aeccf7ea419';
+const CORE_WORKFLOW_ID = '20202020-bbbb-4d02-bf25-6aeccf7ea419';
const ROLE_ID = '20202020-cccc-4d02-bf25-6aeccf7ea419';
+const CORE_DRAFT_VERSION_ID = '20202020-dddd-4d02-bf25-6aeccf7ea419';
+const CORE_ACTIVE_VERSION_ID = '20202020-eeee-4d02-bf25-6aeccf7ea419';
const buildContext = () => ({
workspaceId: WORKSPACE_ID,
@@ -13,95 +15,82 @@ const buildContext = () => ({
});
const buildDeps = ({
- workflow,
- versions,
+ coreWorkflow,
+ coreWorkflowVersions,
}: {
- workflow: unknown;
- versions: unknown[];
-}) => {
- const getRepositoryMock = jest.fn();
-
- getRepositoryMock.mockReturnValueOnce({
- findOne: jest.fn().mockResolvedValue(workflow),
- });
-
- getRepositoryMock.mockReturnValueOnce({
- find: jest.fn().mockResolvedValue(versions),
- });
+ coreWorkflow: unknown;
+ coreWorkflowVersions: { id: string; status: CoreWorkflowVersionStatus }[];
+}) => ({
+ coreWorkflowListService: {
+ findOneById: jest.fn().mockResolvedValue(coreWorkflow),
+ },
+ coreWorkflowVersionListService: {
+ findManyByCoreWorkflowId: jest.fn().mockResolvedValue(coreWorkflowVersions),
+ findOneByCoreWorkflowVersionId: jest
+ .fn()
+ .mockImplementation(async ({ coreWorkflowVersionId }) => ({
+ id: coreWorkflowVersionId,
+ label: 'v1',
+ status: CoreWorkflowVersionStatus.DRAFT,
+ trigger: null,
+ steps: [],
+ })),
+ },
+});
- return {
- workspaceOrmManager: {
- executeInWorkspaceContext: jest
- .fn()
- .mockImplementation(async (fn) => fn()),
- getRepository: getRepositoryMock,
- },
- };
-};
+const buildTool = (deps: ReturnType<typeof buildDeps>) =>
+ createGetWorkflowCurrentVersionTool(
+ deps as unknown as Pick<
+ WorkflowToolDependencies,
+ 'coreWorkflowListService' | 'coreWorkflowVersionListService'
+ >,
+ buildContext(),
+ );
describe('get_workflow_current_version tool', () => {
- it('should pass rolePermissionConfig to both getRepository calls', async () => {
- const context = buildContext();
+ it('should read the definition from core using the core workflow id', async () => {
const deps = buildDeps({
- workflow: { id: WORKFLOW_ID },
- versions: [
+ coreWorkflow: { id: CORE_WORKFLOW_ID },
+ coreWorkflowVersions: [
{
- id: 'v1',
- status: WorkflowVersionStatus.DRAFT,
- workflowId: WORKFLOW_ID,
+ id: CORE_DRAFT_VERSION_ID,
+ status: CoreWorkflowVersionStatus.DRAFT,
},
],
});
- const tool = createGetWorkflowCurrentVersionTool(
- deps as unknown as Pick<WorkflowToolDependencies, 'workspaceOrmManager'>,
- context,
- );
-
- await tool.execute({ workflowId: WORKFLOW_ID });
+ await buildTool(deps).execute({ coreWorkflowId: CORE_WORKFLOW_ID });
- expect(deps.workspaceOrmManager.getRepository).toHaveBeenNthCalledWith(
- 1,
- 'workflow',
- context.rolePermissionConfig,
- );
- expect(deps.workspaceOrmManager.getRepository).toHaveBeenNthCalledWith(
- 2,
- 'workflowVersion',
- context.rolePermissionConfig,
- );
+ expect(deps.coreWorkflowListService.findOneById).toHaveBeenCalledWith({
+ workspaceId: WORKSPACE_ID,
+ coreWorkflowId: CORE_WORKFLOW_ID,
+ });
+ expect(
+ deps.coreWorkflowVersionListService.findManyByCoreWorkflowId,
+ ).toHaveBeenCalledWith({
+ workspaceId: WORKSPACE_ID,
+ coreWorkflowId: CORE_WORKFLOW_ID,
+ });
});
it('should return draft version over active version', async () => {
- const context = buildContext();
const deps = buildDeps({
- workflow: { id: WORKFLOW_ID },
- versions: [
+ coreWorkflow: { id: CORE_WORKFLOW_ID },
+ coreWorkflowVersions: [
{
- id: 'v-active',
- name: 'Active',
- status: WorkflowVersionStatus.ACTIVE,
- workflowId: WORKFLOW_ID,
- trigger: null,
- steps: [],
+ id: CORE_ACTIVE_VERSION_ID,
+ status: CoreWorkflowVersionStatus.ACTIVE,
},
{
- id: 'v-draft',
- name: 'Draft',
- status: WorkflowVersionStatus.DRAFT,
- workflowId: WORKFLOW_ID,
- trigger: null,
- steps: [],
+ id: CORE_DRAFT_VERSION_ID,
+ status: CoreWorkflowVersionStatus.DRAFT,
},
],
});
- const tool = createGetWorkflowCurrentVersionTool(
- deps as unknown as Pick<WorkflowToolDependencies, 'workspaceOrmManager'>,
- context,
- );
-
- const result = await tool.execute({ workflowId: WORKFLOW_ID });
+ const result = await buildTool(deps).execute({
+ coreWorkflowId: CORE_WORKFLOW_ID,
+ });
expect(result.success).toBe(true);
@@ -112,36 +101,34 @@ describe('get_workflow_current_version tool', () => {
throw new Error('Expected workflowVersion to be present in the result');
}
- expect(result.workflowVersion.id).toBe('v-draft');
+ expect(result.workflowVersion.coreWorkflowVersionId).toBe(
+ CORE_DRAFT_VERSION_ID,
+ );
+ expect(result.workflowVersion.coreWorkflowId).toBe(CORE_WORKFLOW_ID);
});
it('should return error when workflow is not found', async () => {
- const context = buildContext();
- const deps = buildDeps({ workflow: null, versions: [] });
+ const deps = buildDeps({ coreWorkflow: null, coreWorkflowVersions: [] });
- const tool = createGetWorkflowCurrentVersionTool(
- deps as unknown as Pick<WorkflowToolDependencies, 'workspaceOrmManager'>,
- context,
- );
-
- const result = await tool.execute({ workflowId: WORKFLOW_ID });
+ const result = await buildTool(deps).execute({
+ coreWorkflowId: CORE_WORKFLOW_ID,
+ });
expect(result.success).toBe(false);
- expect(result.error).toContain(WORKFLOW_ID);
+ expect(result.error).toContain(CORE_WORKFLOW_ID);
});
- it('should return error when no draft or active version exists', async () => {
- const context = buildContext();
- const deps = buildDeps({ workflow: { id: WORKFLOW_ID }, versions: [] });
-
- const tool = createGetWorkflowCurrentVersionTool(
- deps as unknown as Pick<WorkflowToolDependencies, 'workspaceOrmManager'>,
- context,
- );
+ it('should return error when no draft, active or deactivated version exists', async () => {
+ const deps = buildDeps({
+ coreWorkflow: { id: CORE_WORKFLOW_ID },
+ coreWorkflowVersions: [],
+ });
- const result = await tool.execute({ workflowId: WORKFLOW_ID });
+ const result = await buildTool(deps).execute({
+ coreWorkflowId: CORE_WORKFLOW_ID,
+ });
expect(result.success).toBe(false);
- expect(result.error).toContain('no draft or active version');
+ expect(result.error).toContain('no draft, active or deactivated version');
});
});
diff --git a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/__tests__/get-workflow-run.tool.spec.ts b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/__tests__/get-workflow-run.tool.spec.ts
index a41ae152f43..43acf56fd01 100644
--- a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/__tests__/get-workflow-run.tool.spec.ts
+++ b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/__tests__/get-workflow-run.tool.spec.ts
@@ -48,8 +48,8 @@ describe('get_workflow_run tool', () => {
startedAt: '2025-01-01T00:00:00Z',
endedAt: '2025-01-01T00:01:00Z',
enqueuedAt: null,
- workflowId: 'wf-1',
- workflowVersionId: 'wfv-1',
+ coreWorkflowId: 'core-wf-1',
+ coreWorkflowVersionId: 'core-wfv-1',
state: {
workflowRunError: 'Something went wrong',
flow: {
diff --git a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/__tests__/list-workflow-runs.tool.spec.ts b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/__tests__/list-workflow-runs.tool.spec.ts
index bc82e7c45ca..429377f8636 100644
--- a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/__tests__/list-workflow-runs.tool.spec.ts
+++ b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/__tests__/list-workflow-runs.tool.spec.ts
@@ -47,8 +47,8 @@ describe('list_workflow_runs tool', () => {
state: {},
startedAt: '2025-01-01T00:00:00Z',
endedAt: '2025-01-01T00:01:00Z',
- workflowId: 'wf-1',
- workflowVersionId: 'wfv-1',
+ coreWorkflowId: 'core-wf-1',
+ coreWorkflowVersionId: 'core-wfv-1',
},
{
id: 'run-2',
@@ -57,8 +57,8 @@ describe('list_workflow_runs tool', () => {
state: { workflowRunError: 'Timeout' },
startedAt: '2025-01-02T00:00:00Z',
endedAt: '2025-01-02T00:01:00Z',
- workflowId: 'wf-1',
- workflowVersionId: 'wfv-1',
+ coreWorkflowId: 'core-wf-1',
+ coreWorkflowVersionId: 'core-wfv-1',
},
];
@@ -80,6 +80,8 @@ describe('list_workflow_runs tool', () => {
expect(result.workflowRuns).toHaveLength(2);
expect(result.workflowRuns[0].id).toBe('run-1');
+ expect(result.workflowRuns[0].coreWorkflowId).toBe('core-wf-1');
+ expect(result.workflowRuns[0].coreWorkflowVersionId).toBe('core-wfv-1');
expect(result.workflowRuns[1].error).toBe('Timeout');
});
@@ -101,13 +103,13 @@ describe('list_workflow_runs tool', () => {
);
await tool.execute({
- workflowId: 'wf-1',
+ coreWorkflowId: 'core-wf-1',
status: WorkflowRunStatus.FAILED,
limit: 5,
});
expect(findMock).toHaveBeenCalledWith({
- where: { workflowId: 'wf-1', status: WorkflowRunStatus.FAILED },
+ where: { coreWorkflowId: 'core-wf-1', status: WorkflowRunStatus.FAILED },
order: { createdAt: 'DESC' },
take: 5,
});
diff --git a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/__tests__/update-agent.tool.spec.ts b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/__tests__/update-agent.tool.spec.ts
index 7fda9353ed3..5902ece8377 100644
--- a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/__tests__/update-agent.tool.spec.ts
+++ b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/__tests__/update-agent.tool.spec.ts
@@ -12,21 +12,20 @@ const buildAiAgentStep = (agentId: string, stepId = 'step-1') => ({
});
const buildTool = ({
- draftVersions = [],
+ draftCoreVersions = [],
}: {
- draftVersions?: { id: string; status: string; steps: unknown[] | null }[];
+ draftCoreVersions?: { id: string; steps: unknown[] | null }[];
} = {}) => {
const agentService = {
updateOneAgent: jest.fn().mockResolvedValue({ id: AGENT_ID }),
};
- const workflowVersionStepService = {
- updateWorkflowVersionStep: jest.fn().mockResolvedValue(undefined),
+ const coreWorkflowVersionMutationService = {
+ updateStep: jest.fn().mockResolvedValue(undefined),
};
- const workflowVersionRepository = {
- find: jest.fn().mockResolvedValue(draftVersions),
- };
- const workspaceOrmManager = {
- getRepository: jest.fn().mockReturnValue(workflowVersionRepository),
+ const coreWorkflowVersionListService = {
+ findDraftCoreWorkflowVersions: jest
+ .fn()
+ .mockResolvedValue(draftCoreVersions),
};
const flatEntityMapsCacheService = {
invalidateFlatEntityMaps: jest.fn().mockResolvedValue(undefined),
@@ -35,18 +34,21 @@ const buildTool = ({
const tool = createUpdateAgentTool(
{
agentService,
- workflowVersionStepService,
- workspaceOrmManager,
+ coreWorkflowVersionMutationService,
+ coreWorkflowVersionListService,
flatEntityMapsCacheService,
} as never,
- { workspaceId: WORKSPACE_ID },
+ {
+ workspaceId: WORKSPACE_ID,
+ rolePermissionConfig: { shouldBypassPermissionChecks: true },
+ },
);
return {
tool,
agentService,
- workflowVersionStepService,
- workspaceOrmManager,
+ coreWorkflowVersionMutationService,
+ coreWorkflowVersionListService,
flatEntityMapsCacheService,
};
};
@@ -58,10 +60,13 @@ describe('createUpdateAgentTool', () => {
it('should resync the linked AI_AGENT step output schema when responseFormat changes', async () => {
const step = buildAiAgentStep(AGENT_ID);
- const { tool, workflowVersionStepService, flatEntityMapsCacheService } =
- buildTool({
- draftVersions: [{ id: 'version-1', status: 'DRAFT', steps: [step] }],
- });
+ const {
+ tool,
+ coreWorkflowVersionMutationService,
+ flatEntityMapsCacheService,
+ } = buildTool({
+ draftCoreVersions: [{ id: 'core-version-1', steps: [step] }],
+ });
const result = (await tool.execute({
agentId: AGENT_ID,
@@ -81,22 +86,22 @@ describe('createUpdateAgentTool', () => {
workspaceId: WORKSPACE_ID,
flatMapsKeys: ['flatAgentMaps'],
});
- expect(
- workflowVersionStepService.updateWorkflowVersionStep,
- ).toHaveBeenCalledWith({
+ expect(coreWorkflowVersionMutationService.updateStep).toHaveBeenCalledWith({
workspaceId: WORKSPACE_ID,
- workflowVersionId: 'version-1',
+ coreWorkflowVersionId: 'core-version-1',
step,
});
});
it('should not resync when responseFormat is not provided', async () => {
const step = buildAiAgentStep(AGENT_ID);
- const { tool, workflowVersionStepService, workspaceOrmManager } = buildTool(
- {
- draftVersions: [{ id: 'version-1', status: 'DRAFT', steps: [step] }],
- },
- );
+ const {
+ tool,
+ coreWorkflowVersionMutationService,
+ coreWorkflowVersionListService,
+ } = buildTool({
+ draftCoreVersions: [{ id: 'core-version-1', steps: [step] }],
+ });
const result = (await tool.execute({
agentId: AGENT_ID,
@@ -104,18 +109,19 @@ describe('createUpdateAgentTool', () => {
} as never)) as Record<string, unknown>;
expect(result.success).toBe(true);
- expect(workspaceOrmManager.getRepository).not.toHaveBeenCalled();
expect(
- workflowVersionStepService.updateWorkflowVersionStep,
+ coreWorkflowVersionListService.findDraftCoreWorkflowVersions,
+ ).not.toHaveBeenCalled();
+ expect(
+ coreWorkflowVersionMutationService.updateStep,
).not.toHaveBeenCalled();
});
it('should skip steps referencing a different agent', async () => {
- const { tool, workflowVersionStepService } = buildTool({
- draftVersions: [
+ const { tool, coreWorkflowVersionMutationService } = buildTool({
+ draftCoreVersions: [
{
- id: 'version-1',
- status: 'DRAFT',
+ id: 'core-version-1',
steps: [buildAiAgentStep('another-agent-id')],
},
],
@@ -127,17 +133,17 @@ describe('createUpdateAgentTool', () => {
} as never);
expect(
- workflowVersionStepService.updateWorkflowVersionStep,
+ coreWorkflowVersionMutationService.updateStep,
).not.toHaveBeenCalled();
});
it('should still report agent update success when the resync fails', async () => {
const step = buildAiAgentStep(AGENT_ID);
- const { tool, workflowVersionStepService } = buildTool({
- draftVersions: [{ id: 'version-1', status: 'DRAFT', steps: [step] }],
+ const { tool, coreWorkflowVersionMutationService } = buildTool({
+ draftCoreVersions: [{ id: 'core-version-1', steps: [step] }],
});
- workflowVersionStepService.updateWorkflowVersionStep.mockRejectedValue(
+ coreWorkflowVersionMutationService.updateStep.mockRejectedValue(
new Error('boom'),
);
diff --git a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/__tests__/update-workflow-version-step.tool.spec.ts b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/__tests__/update-workflow-version-step.tool.spec.ts
index 5abe4929f99..bb2c4aae5d6 100644
--- a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/__tests__/update-workflow-version-step.tool.spec.ts
+++ b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/__tests__/update-workflow-version-step.tool.spec.ts
@@ -1,5 +1,7 @@
import { createUpdateWorkflowVersionStepTool } from 'src/modules/workflow/workflow-tools/tools/update-workflow-version-step.tool';
+const CORE_WORKFLOW_VERSION_ID = 'b3b8a4f0-0000-4000-8000-000000000000';
+
const mockStep = {
id: 'f47ac10b-58cc-4372-a567-0e02b2c3d479',
name: 'Send email',
@@ -9,20 +11,23 @@ const mockStep = {
};
const buildTool = () => {
- const workflowVersionStepService = {
- updateWorkflowVersionStep: jest.fn().mockResolvedValue(mockStep),
+ const coreWorkflowVersionMutationService = {
+ updateStep: jest.fn().mockResolvedValue(mockStep),
};
const tool = createUpdateWorkflowVersionStepTool(
- { workflowVersionStepService } as never,
- { workspaceId: 'workspace-id' },
+ { coreWorkflowVersionMutationService } as never,
+ {
+ workspaceId: 'workspace-id',
+ rolePermissionConfig: { shouldBypassPermissionChecks: true },
+ },
);
- return { tool, workflowVersionStepService };
+ return { tool, coreWorkflowVersionMutationService };
};
const baseInput = {
- workflowVersionId: 'b3b8a4f0-0000-4000-8000-000000000000',
+ coreWorkflowVersionId: CORE_WORKFLOW_VERSION_ID,
step: mockStep,
} as unknown as Parameters<
ReturnType<typeof createUpdateWorkflowVersionStepTool>['execute']
@@ -33,25 +38,23 @@ describe('createUpdateWorkflowVersionStepTool', () => {
jest.clearAllMocks();
});
- it('updates the step and returns the result', async () => {
- const { tool, workflowVersionStepService } = buildTool();
+ it('updates the step on the core version and returns the result', async () => {
+ const { tool, coreWorkflowVersionMutationService } = buildTool();
const result = await tool.execute(baseInput);
- expect(
- workflowVersionStepService.updateWorkflowVersionStep,
- ).toHaveBeenCalledWith({
+ expect(coreWorkflowVersionMutationService.updateStep).toHaveBeenCalledWith({
workspaceId: 'workspace-id',
- workflowVersionId: baseInput.workflowVersionId,
+ coreWorkflowVersionId: CORE_WORKFLOW_VERSION_ID,
step: mockStep,
});
expect(result).toEqual(mockStep);
});
it('returns a failure when the update throws', async () => {
- const { tool, workflowVersionStepService } = buildTool();
+ const { tool, coreWorkflowVersionMutationService } = buildTool();
- workflowVersionStepService.updateWorkflowVersionStep.mockRejectedValue(
+ coreWorkflowVersionMutationService.updateStep.mockRejectedValue(
new Error('boom'),
);
diff --git a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/activate-workflow-version.tool.ts b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/activate-workflow-version.tool.ts
index 2c8af2d27b9..e5620c6c29a 100644
--- a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/activate-workflow-version.tool.ts
+++ b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/activate-workflow-version.tool.ts
@@ -6,10 +6,10 @@ import {
} from 'src/modules/workflow/workflow-tools/types/workflow-tool-dependencies.type';
const activateWorkflowVersionSchema = z.object({
- workflowVersionId: z
+ coreWorkflowVersionId: z
.string()
.uuid()
- .describe('The UUID of the workflow version to activate'),
+ .describe('The core workflow version UUID to activate'),
});
type ActivateWorkflowVersionInput = z.infer<
@@ -17,7 +17,7 @@ type ActivateWorkflowVersionInput = z.infer<
>;
export const createActivateWorkflowVersionTool = (
- deps: Pick<WorkflowToolDependencies, 'workflowTriggerService'>,
+ deps: Pick<WorkflowToolDependencies, 'coreWorkflowLifecycleService'>,
context: WorkflowToolContext,
) => ({
name: 'activate_workflow_version' as const,
@@ -26,9 +26,12 @@ export const createActivateWorkflowVersionTool = (
inputSchema: activateWorkflowVersionSchema,
execute: async (parameters: ActivateWorkflowVersionInput) => {
try {
- return await deps.workflowTriggerService.activateWorkflowVersion(
- parameters.workflowVersionId,
- context.workspaceId,
+ return await deps.coreWorkflowLifecycleService.activateCoreWorkflowVersion(
+ {
+ workspaceId: context.workspaceId,
+ userWorkspaceId: context.userWorkspaceId,
+ coreWorkflowVersionId: parameters.coreWorkflowVersionId,
+ },
);
} catch (error) {
return {
diff --git a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/compute-step-output-schema.tool.ts b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/compute-step-output-schema.tool.ts
index 0ba3fae9385..4308c1318d7 100644
--- a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/compute-step-output-schema.tool.ts
+++ b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/compute-step-output-schema.tool.ts
@@ -1,3 +1,4 @@
+import { isDefined } from 'twenty-shared/utils';
import {
workflowActionSchema,
workflowTriggerSchema,
@@ -15,16 +16,16 @@ const computeStepOutputSchemaSchema = z.object({
step: z
.union([workflowTriggerSchema, workflowActionSchema])
.describe('The workflow step configuration'),
- workflowVersionId: z
+ coreWorkflowVersionId: z
.string()
.uuid()
- .describe('The UUID of the workflow version'),
+ .describe('The core workflow version UUID'),
});
export const createComputeStepOutputSchemaTool = (
deps: Pick<
WorkflowToolDependencies,
- 'workflowSchemaService' | 'workflowCommonService'
+ 'workflowSchemaService' | 'coreWorkflowVersionListService'
>,
context: WorkflowToolContext,
) => ({
@@ -34,21 +35,31 @@ export const createComputeStepOutputSchemaTool = (
inputSchema: computeStepOutputSchemaSchema,
execute: async (parameters: {
step: WorkflowTrigger | WorkflowAction;
- workflowVersionId: string;
+ coreWorkflowVersionId: string;
}) => {
try {
- const workflowVersion =
- await deps.workflowCommonService.getWorkflowVersionOrFail({
- workflowVersionId: parameters.workflowVersionId,
- workspaceId: context.workspaceId,
- });
+ const coreWorkflowVersion =
+ await deps.coreWorkflowVersionListService.findOneByCoreWorkflowVersionId(
+ {
+ workspaceId: context.workspaceId,
+ userWorkspaceId: context.userWorkspaceId,
+ coreWorkflowVersionId: parameters.coreWorkflowVersionId,
+ },
+ );
+
+ if (!isDefined(coreWorkflowVersion)) {
+ return {
+ success: false,
+ error: `Workflow version ${parameters.coreWorkflowVersionId} not found`,
+ };
+ }
return await deps.workflowSchemaService.computeStepOutputSchema({
step: parameters.step,
workspaceId: context.workspaceId,
workflowVersionContent: {
- trigger: workflowVersion.trigger,
- steps: workflowVersion.steps,
+ trigger: coreWorkflowVersion.trigger,
+ steps: coreWorkflowVersion.steps,
},
});
} catch (error) {
diff --git a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/create-complete-workflow.tool.ts b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/create-complete-workflow.tool.ts
index 04c4bb52715..16c262a38b9 100644
--- a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/create-complete-workflow.tool.ts
+++ b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/create-complete-workflow.tool.ts
@@ -1,20 +1,18 @@
+import { isDefined } from 'twenty-shared/utils';
import {
workflowActionSchema,
WorkflowActionType,
workflowTriggerSchema,
} from 'twenty-shared/workflow';
-import { v4 as uuidv4 } from 'uuid';
import { z } from 'zod';
-import { type RolePermissionConfig } from 'src/engine/twenty-orm/types/role-permission-config';
-import { buildSystemAuthContext } from 'src/engine/twenty-orm/utils/build-system-auth-context.util';
+import { WorkflowVersionStatus as CoreWorkflowVersionStatus } from 'src/engine/core-modules/workflow/entities/workflow-version.entity';
import {
WorkflowVersionStepException,
WorkflowVersionStepExceptionCode,
} from 'src/modules/workflow/common/exceptions/workflow-version-step.exception';
-import { WorkflowVersionStatus } from 'src/modules/workflow/common/standard-objects/workflow-version.workspace-entity';
-import { WorkflowStatus } from 'src/modules/workflow/common/standard-objects/workflow.workspace-entity';
import { type WorkflowAction } from 'src/modules/workflow/workflow-executor/workflow-actions/types/workflow-action.type';
+import { DEFAULT_AGENT_WORKFLOW_ACTOR } from 'src/modules/workflow/workflow-tools/constants/default-agent-workflow-actor.constant';
import { workflowStepConnectionOptionsSchema } from 'src/modules/workflow/workflow-tools/tools/schemas/workflow-step-connection-options.schema';
import {
type WorkflowToolContext,
@@ -54,21 +52,16 @@ const createCompleteWorkflowSchema = z.object({
type CreateCompleteWorkflowToolDeps = Pick<
WorkflowToolDependencies,
- | 'workflowVersionService'
- | 'workflowVersionEdgeService'
- | 'workflowTriggerService'
- | 'workspaceOrmManager'
- | 'recordPositionService'
- | 'workflowVersionCoreSyncService'
+ | 'coreWorkflowMutationService'
+ | 'coreWorkflowVersionListService'
+ | 'coreWorkflowVersionMutationService'
+ | 'coreWorkflowVersionWriteService'
+ | 'coreWorkflowLifecycleService'
>;
-type CreateCompleteWorkflowToolContext = WorkflowToolContext & {
- rolePermissionConfig: RolePermissionConfig;
-};
-
export const createCreateCompleteWorkflowTool = (
deps: CreateCompleteWorkflowToolDeps,
- context: CreateCompleteWorkflowToolContext,
+ context: WorkflowToolContext,
) => ({
name: 'create_complete_workflow' as const,
description: `Create a complete workflow with trigger, steps, and connections in a single operation.
@@ -105,6 +98,8 @@ IMPORTANT: The tool schema provides comprehensive field descriptions, examples,
This is the most efficient way for AI to create workflows as it handles all the complexity in one call.
+Returns the core workflow ID and core workflow version ID, which every other workflow tool expects.
+
Call validate_workflow once when the workflow is complete, before activating.`,
inputSchema: createCompleteWorkflowSchema,
execute: async (parameters: {
@@ -122,69 +117,66 @@ Call validate_workflow once when the workflow is complete, before activating.`,
activate?: boolean;
}) => {
try {
- const codeSteps = parameters.steps.filter(
- (step) => step.type === ('CODE' as string),
- );
+ const { workspaceId } = context;
- if (codeSteps.length > 0) {
- throw new WorkflowVersionStepException(
- 'CODE steps cannot be created via create_complete_workflow because it does not create the underlying logic function. Use create_workflow_version_step instead.',
- WorkflowVersionStepExceptionCode.INVALID_REQUEST,
- );
- }
+ assertStepTypesAreSupported(parameters.steps);
- const aiAgentSteps = parameters.steps.filter(
- (step) => step.type === WorkflowActionType.AI_AGENT,
- );
+ const coreWorkflow =
+ await deps.coreWorkflowMutationService.createWorkflow({
+ workspaceId,
+ createdBy: context.actorContext ?? DEFAULT_AGENT_WORKFLOW_ACTOR,
+ userWorkspaceId: undefined,
+ name: parameters.name,
+ });
- if (aiAgentSteps.length > 0) {
- throw new WorkflowVersionStepException(
- 'AI_AGENT steps cannot be created via create_complete_workflow because it does not create the underlying agent. Use create_workflow_version_step instead, then call update_agent to configure the agent.',
- WorkflowVersionStepExceptionCode.INVALID_REQUEST,
- );
- }
- const workflowId = await createWorkflow({
+ const coreWorkflowVersionId = await findInitialDraftCoreVersionIdOrThrow({
deps,
- context,
- name: parameters.name,
+ workspaceId,
+ userWorkspaceId: context.userWorkspaceId,
+ coreWorkflowId: coreWorkflow.id,
});
- const workflowVersionId = await createWorkflowVersion({
- deps,
- context,
- workflowId,
+ const { coreWorkflowVersion } =
+ await deps.coreWorkflowVersionWriteService.getValidatedDraftCoreWorkflowVersion(
+ {
+ workspaceId,
+ userWorkspaceId: context.userWorkspaceId,
+ coreWorkflowVersionId,
+ },
+ );
+
+ await deps.coreWorkflowVersionWriteService.writeContentAndMirror({
+ workspaceId,
+ coreWorkflowVersionId,
+ expectedVersion: coreWorkflowVersion,
trigger: parameters.trigger,
steps: parameters.steps,
});
- if (parameters.edges && parameters.edges.length > 0) {
- for (const edge of parameters.edges) {
- await deps.workflowVersionEdgeService.createWorkflowVersionEdge({
- source: edge.source === 'trigger' ? 'trigger' : edge.source,
- target: edge.target,
- sourceConnectionOptions: edge.sourceConnectionOptions,
- workflowVersionId,
- workspaceId: context.workspaceId,
- });
- }
+ for (const edge of parameters.edges ?? []) {
+ await deps.coreWorkflowVersionMutationService.createEdge({
+ userWorkspaceId: context.userWorkspaceId,
+ source: edge.source,
+ target: edge.target,
+ sourceConnectionOptions: edge.sourceConnectionOptions,
+ coreWorkflowVersionId,
+ workspaceId,
+ });
}
- await deps.workflowVersionService.autoLayoutWorkflowVersion({
- workflowVersionId,
- workspaceId: context.workspaceId,
- });
+ await deps.coreWorkflowVersionMutationService.autoLayoutCoreWorkflowVersion(
+ {
+ workspaceId,
+ userWorkspaceId: context.userWorkspaceId,
+ coreWorkflowVersionId,
+ },
+ );
if (parameters.activate) {
- await deps.workflowTriggerService.activateWorkflowVersion(
- workflowVersionId,
- context.workspaceId,
- );
-
- await updateWorkflowStatus({
- deps,
- context,
- workflowId,
- workflowVersionId,
+ await deps.coreWorkflowLifecycleService.activateCoreWorkflowVersion({
+ workspaceId,
+ userWorkspaceId: context.userWorkspaceId,
+ coreWorkflowVersionId,
});
}
@@ -192,18 +184,20 @@ Call validate_workflow once when the workflow is complete, before activating.`,
success: true,
message: `Workflow "${parameters.name}" created successfully with ${parameters.steps.length} steps`,
result: {
- workflowId,
- workflowVersionId,
+ coreWorkflowId: coreWorkflow.id,
+ coreWorkflowVersionId,
name: parameters.name,
stepIds: parameters.steps.map((step) => step.id),
},
- recordReferences: [
- {
- objectNameSingular: 'workflow',
- recordId: workflowId,
- displayName: parameters.name,
- },
- ],
+ recordReferences: isDefined(coreWorkflow.workspaceWorkflowId)
+ ? [
+ {
+ objectNameSingular: 'workflow',
+ recordId: coreWorkflow.workspaceWorkflowId,
+ displayName: parameters.name,
+ },
+ ]
+ : [],
};
} catch (error) {
return {
@@ -215,113 +209,50 @@ Call validate_workflow once when the workflow is complete, before activating.`,
},
});
-const createWorkflow = async ({
- deps,
- context,
- name,
-}: {
- deps: CreateCompleteWorkflowToolDeps;
- context: CreateCompleteWorkflowToolContext;
- name: string;
-}): Promise<string> => {
- const authContext = buildSystemAuthContext(context.workspaceId);
-
- return deps.workspaceOrmManager.executeInWorkspaceContext(async () => {
- const workflowRepository = deps.workspaceOrmManager.getRepository(
- 'workflow',
- context.rolePermissionConfig,
+const assertStepTypesAreSupported = (steps: WorkflowAction[]): void => {
+ if (steps.some((step) => step.type === WorkflowActionType.CODE)) {
+ throw new WorkflowVersionStepException(
+ 'CODE steps cannot be created via create_complete_workflow because it does not create the underlying logic function. Use create_workflow_version_step instead.',
+ WorkflowVersionStepExceptionCode.INVALID_REQUEST,
);
+ }
- const workflowPosition =
- await deps.recordPositionService.buildRecordPosition({
- value: 'first',
- objectMetadata: {
- isCustom: false,
- nameSingular: 'workflow',
- },
- workspaceId: context.workspaceId,
- });
-
- const workflow = {
- id: uuidv4(),
- name,
- statuses: [WorkflowStatus.DRAFT],
- position: workflowPosition,
- };
-
- await workflowRepository.insert(workflow);
-
- return workflow.id;
- }, authContext);
+ if (steps.some((step) => step.type === WorkflowActionType.AI_AGENT)) {
+ throw new WorkflowVersionStepException(
+ 'AI_AGENT steps cannot be created via create_complete_workflow because it does not create the underlying agent. Use create_workflow_version_step instead, then call update_agent to configure the agent.',
+ WorkflowVersionStepExceptionCode.INVALID_REQUEST,
+ );
+ }
};
-const createWorkflowVersion = async ({
+const findInitialDraftCoreVersionIdOrThrow = async ({
deps,
- context,
- workflowId,
- trigger,
- steps,
+ workspaceId,
+ userWorkspaceId,
+ coreWorkflowId,
}: {
deps: CreateCompleteWorkflowToolDeps;
- context: CreateCompleteWorkflowToolContext;
- workflowId: string;
- trigger: WorkflowTrigger;
- steps: WorkflowAction[];
+ workspaceId: string;
+ userWorkspaceId: string | undefined;
+ coreWorkflowId: string;
}): Promise<string> => {
- const workflowVersionId = uuidv4();
-
- await deps.workflowVersionCoreSyncService.writeWorkflowVersionAndMirror(
- context.workspaceId,
- async (workflowVersionRepository) => {
- const versionPosition =
- await deps.recordPositionService.buildRecordPosition({
- value: 'first',
- objectMetadata: {
- isCustom: false,
- nameSingular: 'workflowVersion',
- },
- workspaceId: context.workspaceId,
- });
-
- await workflowVersionRepository.insert({
- id: workflowVersionId,
- workflowId,
- name: 'v1',
- status: WorkflowVersionStatus.DRAFT,
- trigger,
- steps,
- position: versionPosition,
- });
+ const coreWorkflowVersions =
+ await deps.coreWorkflowVersionListService.findManyByCoreWorkflowId({
+ workspaceId,
+ userWorkspaceId,
+ coreWorkflowId,
+ });
- return workflowVersionId;
- },
+ const draftVersion = coreWorkflowVersions.find(
+ (version) => version.status === CoreWorkflowVersionStatus.DRAFT,
);
- return workflowVersionId;
-};
-
-const updateWorkflowStatus = async ({
- deps,
- context,
- workflowId,
- workflowVersionId,
-}: {
- deps: CreateCompleteWorkflowToolDeps;
- context: CreateCompleteWorkflowToolContext;
- workflowId: string;
- workflowVersionId: string;
-}) => {
- const authContext = buildSystemAuthContext(context.workspaceId);
-
- await deps.workspaceOrmManager.executeInWorkspaceContext(async () => {
- const workflowRepository = deps.workspaceOrmManager.getRepository(
- 'workflow',
- context.rolePermissionConfig,
+ if (!isDefined(draftVersion)) {
+ throw new WorkflowVersionStepException(
+ `Created workflow '${coreWorkflowId}' has no initial draft version`,
+ WorkflowVersionStepExceptionCode.NOT_FOUND,
);
+ }
- await workflowRepository.update(workflowId, {
- statuses: [WorkflowStatus.ACTIVE],
- lastPublishedVersionId: workflowVersionId,
- });
- }, authContext);
+ return draftVersion.id;
};
diff --git a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/create-draft-from-workflow-version.tool.ts b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/create-draft-from-workflow-version.tool.ts
index 642df1d192b..08b76221012 100644
--- a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/create-draft-from-workflow-version.tool.ts
+++ b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/create-draft-from-workflow-version.tool.ts
@@ -6,11 +6,11 @@ import {
} from 'src/modules/workflow/workflow-tools/types/workflow-tool-dependencies.type';
const createDraftFromWorkflowVersionSchema = z.object({
- workflowId: z.string().uuid().describe('The UUID of the workflow'),
- workflowVersionIdToCopy: z
+ coreWorkflowId: z.string().uuid().describe('The core workflow UUID'),
+ coreWorkflowVersionIdToCopy: z
.string()
.uuid()
- .describe('The UUID of the workflow version to create a draft from'),
+ .describe('The core workflow version UUID to create a draft from'),
});
type CreateDraftFromWorkflowVersionInput = z.infer<
@@ -18,20 +18,32 @@ type CreateDraftFromWorkflowVersionInput = z.infer<
>;
export const createCreateDraftFromWorkflowVersionTool = (
- deps: Pick<WorkflowToolDependencies, 'workflowVersionService'>,
+ deps: Pick<WorkflowToolDependencies, 'coreWorkflowVersionMutationService'>,
context: WorkflowToolContext,
) => ({
name: 'create_draft_from_workflow_version' as const,
description:
- 'Create a new draft workflow version from an existing one. This allows for iterative workflow development.',
+ 'Create a new draft workflow version from an existing one. This allows for iterative workflow development. Returns the new core workflow version.',
inputSchema: createDraftFromWorkflowVersionSchema,
execute: async (parameters: CreateDraftFromWorkflowVersionInput) => {
try {
- return await deps.workflowVersionService.createDraftFromWorkflowVersion({
- workspaceId: context.workspaceId,
- workflowId: parameters.workflowId,
- workflowVersionIdToCopy: parameters.workflowVersionIdToCopy,
- });
+ const coreWorkflowVersion =
+ await deps.coreWorkflowVersionMutationService.createDraftFromCoreWorkflowVersion(
+ {
+ workspaceId: context.workspaceId,
+ userWorkspaceId: context.userWorkspaceId,
+ coreWorkflowId: parameters.coreWorkflowId,
+ coreWorkflowVersionIdToCopy: parameters.coreWorkflowVersionIdToCopy,
+ },
+ );
+
+ return {
+ success: true,
+ coreWorkflowVersionId: coreWorkflowVersion.id,
+ coreWorkflowId: parameters.coreWorkflowId,
+ status: coreWorkflowVersion.status,
+ name: coreWorkflowVersion.label,
+ };
} catch (error) {
return {
success: false,
diff --git a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/create-workflow-version-edge.tool.ts b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/create-workflow-version-edge.tool.ts
index 227296ad1bd..8c201fdbfcf 100644
--- a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/create-workflow-version-edge.tool.ts
+++ b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/create-workflow-version-edge.tool.ts
@@ -7,10 +7,10 @@ import {
} from 'src/modules/workflow/workflow-tools/types/workflow-tool-dependencies.type';
const createWorkflowVersionEdgeSchema = z.object({
- workflowVersionId: z
+ coreWorkflowVersionId: z
.string()
.uuid()
- .describe('The UUID of the workflow version'),
+ .describe('The core workflow version UUID'),
source: z
.union([z.literal('trigger'), z.string().uuid()])
.describe('The source step: "trigger" or a step UUID'),
@@ -23,7 +23,7 @@ type CreateWorkflowVersionEdgeInput = z.infer<
>;
export const createCreateWorkflowVersionEdgeTool = (
- deps: Pick<WorkflowToolDependencies, 'workflowVersionEdgeService'>,
+ deps: Pick<WorkflowToolDependencies, 'coreWorkflowVersionMutationService'>,
context: WorkflowToolContext,
) => ({
name: 'create_workflow_version_edge' as const,
@@ -32,11 +32,12 @@ export const createCreateWorkflowVersionEdgeTool = (
inputSchema: createWorkflowVersionEdgeSchema,
execute: async (parameters: CreateWorkflowVersionEdgeInput) => {
try {
- return await deps.workflowVersionEdgeService.createWorkflowVersionEdge({
+ return await deps.coreWorkflowVersionMutationService.createEdge({
source: parameters.source,
target: parameters.target,
- workflowVersionId: parameters.workflowVersionId,
+ coreWorkflowVersionId: parameters.coreWorkflowVersionId,
workspaceId: context.workspaceId,
+ userWorkspaceId: context.userWorkspaceId,
sourceConnectionOptions: parameters.sourceConnectionOptions,
});
} catch (error) {
diff --git a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/create-workflow-version-step.tool.ts b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/create-workflow-version-step.tool.ts
index c5c94697ee7..85451ca024a 100644
--- a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/create-workflow-version-step.tool.ts
+++ b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/create-workflow-version-step.tool.ts
@@ -2,7 +2,7 @@ import { isDefined } from 'twenty-shared/utils';
import { TRIGGER_STEP_ID, WorkflowActionType } from 'twenty-shared/workflow';
import { z } from 'zod';
-import type { CreateWorkflowVersionStepInput } from 'src/engine/core-modules/workflow/dtos/create-workflow-version-step.input';
+import { type CreateCoreWorkflowVersionStepInput } from 'src/engine/core-modules/workflow/dtos/create-core-workflow-version-step.input';
import { type WorkflowVersionStepChangesDTO } from 'src/engine/core-modules/workflow/dtos/workflow-version-step-changes.dto';
import {
type WorkflowToolContext,
@@ -10,10 +10,10 @@ import {
} from 'src/modules/workflow/workflow-tools/types/workflow-tool-dependencies.type';
const baseStepFields = {
- workflowVersionId: z
+ coreWorkflowVersionId: z
.string()
.uuid()
- .describe('The UUID of the workflow version to add the step to'),
+ .describe('The core workflow version UUID to add the step to'),
parentStepId: z
.string()
.optional()
@@ -93,9 +93,7 @@ const enrichResultWithNextStep = ({
export const createCreateWorkflowVersionStepTool = (
deps: Pick<
WorkflowToolDependencies,
- | 'workflowVersionStepService'
- | 'workflowVersionStepHelpersService'
- | 'workflowVersionService'
+ 'coreWorkflowVersionMutationService' | 'coreWorkflowVersionWriteService'
>,
context: WorkflowToolContext,
) => ({
@@ -103,51 +101,55 @@ export const createCreateWorkflowVersionStepTool = (
description:
'Create a new step in a workflow version. This adds a step to the specified workflow version with the given configuration. If parentStepId is not provided, the step will be appended at the end of the workflow.',
inputSchema: createWorkflowVersionStepSchema,
- execute: async (parameters: CreateWorkflowVersionStepInput) => {
+ execute: async (parameters: CreateCoreWorkflowVersionStepInput) => {
try {
+ const { workspaceId } = context;
+ const { coreWorkflowVersionId } = parameters;
+
let effectiveParentStepId = parameters.parentStepId;
if (!isDefined(effectiveParentStepId)) {
- const workflowVersion =
- await deps.workflowVersionStepHelpersService.getValidatedDraftWorkflowVersion(
+ const { steps } =
+ await deps.coreWorkflowVersionWriteService.getValidatedDraftCoreWorkflowVersion(
{
- workflowVersionId: parameters.workflowVersionId,
- workspaceId: context.workspaceId,
+ workspaceId,
+ userWorkspaceId: context.userWorkspaceId,
+ coreWorkflowVersionId,
},
);
- const steps = workflowVersion.steps ?? [];
+ const existingSteps = steps ?? [];
- if (steps.length === 0) {
+ if (existingSteps.length === 0) {
effectiveParentStepId = TRIGGER_STEP_ID;
} else {
- const leafStep = steps.filter(
+ const leafSteps = existingSteps.filter(
(step) =>
!isDefined(step.nextStepIds) || step.nextStepIds.length === 0,
);
- if (leafStep.length > 1) {
- effectiveParentStepId = undefined;
- } else {
- effectiveParentStepId = leafStep[0]?.id;
- }
+ effectiveParentStepId =
+ leafSteps.length > 1 ? undefined : leafSteps[0]?.id;
}
}
- const result =
- await deps.workflowVersionStepService.createWorkflowVersionStep({
- workspaceId: context.workspaceId,
- input: {
- ...parameters,
- parentStepId: effectiveParentStepId,
- },
- });
-
- await deps.workflowVersionService.autoLayoutWorkflowVersion({
- workflowVersionId: parameters.workflowVersionId,
- workspaceId: context.workspaceId,
+ const result = await deps.coreWorkflowVersionMutationService.createStep({
+ workspaceId,
+ userWorkspaceId: context.userWorkspaceId,
+ input: {
+ ...parameters,
+ parentStepId: effectiveParentStepId,
+ },
});
+ await deps.coreWorkflowVersionMutationService.autoLayoutCoreWorkflowVersion(
+ {
+ workspaceId,
+ userWorkspaceId: context.userWorkspaceId,
+ coreWorkflowVersionId,
+ },
+ );
+
return enrichResultWithNextStep({
result,
stepType: parameters.stepType,
diff --git a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/deactivate-workflow-version.tool.ts b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/deactivate-workflow-version.tool.ts
index 23e38b42b43..75040d8e1a3 100644
--- a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/deactivate-workflow-version.tool.ts
+++ b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/deactivate-workflow-version.tool.ts
@@ -6,10 +6,10 @@ import {
} from 'src/modules/workflow/workflow-tools/types/workflow-tool-dependencies.type';
const deactivateWorkflowVersionSchema = z.object({
- workflowVersionId: z
+ coreWorkflowVersionId: z
.string()
.uuid()
- .describe('The UUID of the workflow version to deactivate'),
+ .describe('The core workflow version UUID to deactivate'),
});
type DeactivateWorkflowVersionInput = z.infer<
@@ -17,7 +17,7 @@ type DeactivateWorkflowVersionInput = z.infer<
>;
export const createDeactivateWorkflowVersionTool = (
- deps: Pick<WorkflowToolDependencies, 'workflowTriggerService'>,
+ deps: Pick<WorkflowToolDependencies, 'coreWorkflowLifecycleService'>,
context: WorkflowToolContext,
) => ({
name: 'deactivate_workflow_version' as const,
@@ -26,9 +26,12 @@ export const createDeactivateWorkflowVersionTool = (
inputSchema: deactivateWorkflowVersionSchema,
execute: async (parameters: DeactivateWorkflowVersionInput) => {
try {
- return await deps.workflowTriggerService.deactivateWorkflowVersion(
- parameters.workflowVersionId,
- context.workspaceId,
+ return await deps.coreWorkflowLifecycleService.deactivateCoreWorkflowVersion(
+ {
+ workspaceId: context.workspaceId,
+ userWorkspaceId: context.userWorkspaceId,
+ coreWorkflowVersionId: parameters.coreWorkflowVersionId,
+ },
);
} catch (error) {
return {
diff --git a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/delete-workflow-version-edge.tool.ts b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/delete-workflow-version-edge.tool.ts
index 0447eedb71e..f23117df62d 100644
--- a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/delete-workflow-version-edge.tool.ts
+++ b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/delete-workflow-version-edge.tool.ts
@@ -7,10 +7,10 @@ import {
} from 'src/modules/workflow/workflow-tools/types/workflow-tool-dependencies.type';
const deleteWorkflowVersionEdgeSchema = z.object({
- workflowVersionId: z
+ coreWorkflowVersionId: z
.string()
.uuid()
- .describe('The UUID of the workflow version'),
+ .describe('The core workflow version UUID'),
source: z
.union([z.literal('trigger'), z.string().uuid()])
.describe('The source step: "trigger" or a step UUID'),
@@ -23,7 +23,7 @@ type DeleteWorkflowVersionEdgeInput = z.infer<
>;
export const createDeleteWorkflowVersionEdgeTool = (
- deps: Pick<WorkflowToolDependencies, 'workflowVersionEdgeService'>,
+ deps: Pick<WorkflowToolDependencies, 'coreWorkflowVersionMutationService'>,
context: WorkflowToolContext,
) => ({
name: 'delete_workflow_version_edge' as const,
@@ -31,11 +31,12 @@ export const createDeleteWorkflowVersionEdgeTool = (
inputSchema: deleteWorkflowVersionEdgeSchema,
execute: async (parameters: DeleteWorkflowVersionEdgeInput) => {
try {
- return await deps.workflowVersionEdgeService.deleteWorkflowVersionEdge({
+ return await deps.coreWorkflowVersionMutationService.deleteEdge({
source: parameters.source,
target: parameters.target,
- workflowVersionId: parameters.workflowVersionId,
+ coreWorkflowVersionId: parameters.coreWorkflowVersionId,
workspaceId: context.workspaceId,
+ userWorkspaceId: context.userWorkspaceId,
sourceConnectionOptions: parameters.sourceConnectionOptions,
});
} catch (error) {
diff --git a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/delete-workflow-version-step.tool.ts b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/delete-workflow-version-step.tool.ts
index c3cba2c0165..64948ac6458 100644
--- a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/delete-workflow-version-step.tool.ts
+++ b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/delete-workflow-version-step.tool.ts
@@ -6,10 +6,10 @@ import {
} from 'src/modules/workflow/workflow-tools/types/workflow-tool-dependencies.type';
const deleteWorkflowVersionStepSchema = z.object({
- workflowVersionId: z
+ coreWorkflowVersionId: z
.string()
.uuid()
- .describe('The UUID of the workflow version containing the step'),
+ .describe('The core workflow version UUID containing the step'),
stepId: z.string().uuid().describe('The UUID of the step to delete'),
});
@@ -18,7 +18,7 @@ type DeleteWorkflowVersionStepInput = z.infer<
>;
export const createDeleteWorkflowVersionStepTool = (
- deps: Pick<WorkflowToolDependencies, 'workflowVersionStepService'>,
+ deps: Pick<WorkflowToolDependencies, 'coreWorkflowVersionMutationService'>,
context: WorkflowToolContext,
) => ({
name: 'delete_workflow_version_step' as const,
@@ -27,9 +27,10 @@ export const createDeleteWorkflowVersionStepTool = (
inputSchema: deleteWorkflowVersionStepSchema,
execute: async (parameters: DeleteWorkflowVersionStepInput) => {
try {
- return await deps.workflowVersionStepService.deleteWorkflowVersionStep({
+ return await deps.coreWorkflowVersionMutationService.deleteStep({
workspaceId: context.workspaceId,
- workflowVersionId: parameters.workflowVersionId,
+ userWorkspaceId: context.userWorkspaceId,
+ coreWorkflowVersionId: parameters.coreWorkflowVersionId,
stepIdToDelete: parameters.stepId,
});
} catch (error) {
diff --git a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/delete-workflow.tool.ts b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/delete-workflow.tool.ts
index c104731f8bd..ff6dea81bb4 100644
--- a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/delete-workflow.tool.ts
+++ b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/delete-workflow.tool.ts
@@ -1,20 +1,16 @@
+import { isDefined } from 'twenty-shared/utils';
import { z } from 'zod';
-import { type RolePermissionConfig } from 'src/engine/twenty-orm/types/role-permission-config';
-import { buildSystemAuthContext } from 'src/engine/twenty-orm/utils/build-system-auth-context.util';
-import { type WorkflowWorkspaceEntity } from 'src/modules/workflow/common/standard-objects/workflow.workspace-entity';
import {
type WorkflowToolContext,
type WorkflowToolDependencies,
} from 'src/modules/workflow/workflow-tools/types/workflow-tool-dependencies.type';
-import { isDefined } from 'twenty-shared/utils';
-
-type DeleteWorkflowToolContext = WorkflowToolContext & {
- rolePermissionConfig: RolePermissionConfig;
-};
const deleteWorkflowSchema = z.object({
- workflowId: z.string().uuid().describe('The UUID of the workflow to delete'),
+ coreWorkflowId: z
+ .string()
+ .uuid()
+ .describe('The core workflow UUID to delete'),
});
type DeleteWorkflowInput = z.infer<typeof deleteWorkflowSchema>;
@@ -22,50 +18,43 @@ type DeleteWorkflowInput = z.infer<typeof deleteWorkflowSchema>;
export const createDeleteWorkflowTool = (
deps: Pick<
WorkflowToolDependencies,
- 'workspaceOrmManager' | 'workflowCommonService'
+ 'coreWorkflowListService' | 'coreWorkflowMutationService'
>,
- context: DeleteWorkflowToolContext,
+ context: WorkflowToolContext,
) => ({
name: 'delete_workflow' as const,
description:
- 'Delete a workflow by its ID. This also removes its versions, runs and automated triggers, and deactivates any active version. Use list_workflows to find the workflowId.',
+ 'Delete a workflow by its core workflow ID. This also removes its versions, runs and automated triggers, and deactivates any active version. Use list_workflows to find the coreWorkflowId.',
inputSchema: deleteWorkflowSchema,
execute: async (parameters: DeleteWorkflowInput) => {
try {
- const { workflowId } = parameters;
+ const { coreWorkflowId } = parameters;
const { workspaceId } = context;
- const authContext = buildSystemAuthContext(workspaceId);
-
- const deleteResult =
- await deps.workspaceOrmManager.executeInWorkspaceContext(async () => {
- const workflowRepository =
- deps.workspaceOrmManager.getRepository<WorkflowWorkspaceEntity>(
- 'workflow',
- context.rolePermissionConfig,
- );
-
- return workflowRepository.softDelete(workflowId);
- }, authContext);
+ const coreWorkflow = await deps.coreWorkflowListService.findOneById({
+ workspaceId,
+ userWorkspaceId: context.userWorkspaceId,
+ coreWorkflowId,
+ });
- if (!isDefined(deleteResult.affected)) {
+ if (!isDefined(coreWorkflow)) {
return {
success: false,
error: 'Workflow not found',
- message: `No workflow found with ID ${workflowId}`,
+ message: `No workflow found with core ID ${coreWorkflowId}`,
};
}
- await deps.workflowCommonService.handleWorkflowSubEntities({
- workflowIds: [workflowId],
+ await deps.coreWorkflowMutationService.deleteWorkflows({
workspaceId,
- operation: 'delete',
+ userWorkspaceId: context.userWorkspaceId,
+ coreWorkflowIds: [coreWorkflowId],
});
return {
success: true,
- message: `Successfully deleted workflow ${workflowId}`,
- workflowId,
+ message: `Successfully deleted workflow ${coreWorkflowId}`,
+ coreWorkflowId,
};
} catch (error) {
const errorMessage =
diff --git a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/get-workflow-current-version.tool.ts b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/get-workflow-current-version.tool.ts
index 6c44bb57b45..0a0d2f2ddf1 100644
--- a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/get-workflow-current-version.tool.ts
+++ b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/get-workflow-current-version.tool.ts
@@ -1,27 +1,19 @@
import { isDefined } from 'twenty-shared/utils';
import { z } from 'zod';
-import { type RolePermissionConfig } from 'src/engine/twenty-orm/types/role-permission-config';
-import { buildSystemAuthContext } from 'src/engine/twenty-orm/utils/build-system-auth-context.util';
-import {
- WorkflowVersionStatus,
- type WorkflowVersionWorkspaceEntity,
-} from 'src/modules/workflow/common/standard-objects/workflow-version.workspace-entity';
-import { type WorkflowWorkspaceEntity } from 'src/modules/workflow/common/standard-objects/workflow.workspace-entity';
+import { WorkflowVersionStatus as CoreWorkflowVersionStatus } from 'src/engine/core-modules/workflow/entities/workflow-version.entity';
import {
type WorkflowToolContext,
type WorkflowToolDependencies,
} from 'src/modules/workflow/workflow-tools/types/workflow-tool-dependencies.type';
-type GetWorkflowCurrentVersionToolContext = WorkflowToolContext & {
- rolePermissionConfig: RolePermissionConfig;
-};
-
const getWorkflowCurrentVersionSchema = z.object({
- workflowId: z
+ coreWorkflowId: z
.string()
.uuid()
- .describe('The UUID of the workflow to get the current version for'),
+ .describe(
+ 'The core workflow UUID to get the current version for, as returned by list_workflows',
+ ),
});
type GetWorkflowCurrentVersionInput = z.infer<
@@ -29,85 +21,86 @@ type GetWorkflowCurrentVersionInput = z.infer<
>;
export const createGetWorkflowCurrentVersionTool = (
- deps: Pick<WorkflowToolDependencies, 'workspaceOrmManager'>,
- context: GetWorkflowCurrentVersionToolContext,
+ deps: Pick<
+ WorkflowToolDependencies,
+ 'coreWorkflowListService' | 'coreWorkflowVersionListService'
+ >,
+ context: WorkflowToolContext,
) => ({
name: 'get_workflow_current_version' as const,
description:
- 'Get the current version of a workflow. Returns the draft version if one exists, otherwise the last published version.',
+ 'Get the current version of a workflow. Returns the draft version if one exists, otherwise the last published version. Returns a core workflow version ID (coreWorkflowVersionId), which the editing tools expect.',
inputSchema: getWorkflowCurrentVersionSchema,
execute: async (parameters: GetWorkflowCurrentVersionInput) => {
try {
- const authContext = buildSystemAuthContext(context.workspaceId);
-
- return await deps.workspaceOrmManager.executeInWorkspaceContext(
- async () => {
- const workflowRepository =
- deps.workspaceOrmManager.getRepository<WorkflowWorkspaceEntity>(
- 'workflow',
- context.rolePermissionConfig,
- );
+ const { workspaceId } = context;
+ const { coreWorkflowId } = parameters;
- const workflow = await workflowRepository.findOne({
- where: { id: parameters.workflowId },
- });
+ const coreWorkflow = await deps.coreWorkflowListService.findOneById({
+ workspaceId,
+ userWorkspaceId: context.userWorkspaceId,
+ coreWorkflowId,
+ });
- if (!isDefined(workflow)) {
- return {
- success: false,
- error: `Workflow ${parameters.workflowId} not found`,
- };
- }
+ if (!isDefined(coreWorkflow)) {
+ return {
+ success: false,
+ error: `Workflow ${coreWorkflowId} not found`,
+ };
+ }
- const workflowVersionRepository =
- deps.workspaceOrmManager.getRepository<WorkflowVersionWorkspaceEntity>(
- 'workflowVersion',
- context.rolePermissionConfig,
- );
+ const coreWorkflowVersions =
+ await deps.coreWorkflowVersionListService.findManyByCoreWorkflowId({
+ workspaceId,
+ userWorkspaceId: context.userWorkspaceId,
+ coreWorkflowId,
+ });
- const versions = await workflowVersionRepository.find({
- where: [
- {
- workflowId: parameters.workflowId,
- status: WorkflowVersionStatus.DRAFT,
- },
- {
- workflowId: parameters.workflowId,
- status: WorkflowVersionStatus.ACTIVE,
- },
- ],
- });
+ const currentVersion =
+ coreWorkflowVersions.find(
+ (version) => version.status === CoreWorkflowVersionStatus.DRAFT,
+ ) ??
+ coreWorkflowVersions.find(
+ (version) => version.status === CoreWorkflowVersionStatus.ACTIVE,
+ ) ??
+ coreWorkflowVersions.find(
+ (version) => version.status === CoreWorkflowVersionStatus.DEACTIVATED,
+ );
- const draftVersion = versions.find(
- (version) => version.status === WorkflowVersionStatus.DRAFT,
- );
- const activeVersion = versions.find(
- (version) => version.status === WorkflowVersionStatus.ACTIVE,
- );
+ if (!isDefined(currentVersion)) {
+ return {
+ success: false,
+ error: `Workflow ${coreWorkflowId} has no draft, active or deactivated version`,
+ };
+ }
- const currentVersion = draftVersion ?? activeVersion;
+ const coreWorkflowVersion =
+ await deps.coreWorkflowVersionListService.findOneByCoreWorkflowVersionId(
+ {
+ workspaceId,
+ userWorkspaceId: context.userWorkspaceId,
+ coreWorkflowVersionId: currentVersion.id,
+ },
+ );
- if (!isDefined(currentVersion)) {
- return {
- success: false,
- error: `Workflow ${parameters.workflowId} has no draft or active version`,
- };
- }
+ if (!isDefined(coreWorkflowVersion)) {
+ return {
+ success: false,
+ error: `Workflow version ${currentVersion.id} not found`,
+ };
+ }
- return {
- success: true,
- workflowVersion: {
- id: currentVersion.id,
- name: currentVersion.name,
- status: currentVersion.status,
- trigger: currentVersion.trigger,
- steps: currentVersion.steps,
- workflowId: currentVersion.workflowId,
- },
- };
+ return {
+ success: true,
+ workflowVersion: {
+ coreWorkflowVersionId: coreWorkflowVersion.id,
+ name: coreWorkflowVersion.label,
+ status: coreWorkflowVersion.status,
+ trigger: coreWorkflowVersion.trigger,
+ steps: coreWorkflowVersion.steps,
+ coreWorkflowId,
},
- authContext,
- );
+ };
} catch (error) {
return {
success: false,
diff --git a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/get-workflow-run.tool.ts b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/get-workflow-run.tool.ts
index 81f6c0e5e85..0fbbf49395e 100644
--- a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/get-workflow-run.tool.ts
+++ b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/get-workflow-run.tool.ts
@@ -2,7 +2,6 @@ import { isDefined } from 'twenty-shared/utils';
import { StepStatus } from 'twenty-shared/workflow';
import { z } from 'zod';
-import { type RolePermissionConfig } from 'src/engine/twenty-orm/types/role-permission-config';
import { buildSystemAuthContext } from 'src/engine/twenty-orm/utils/build-system-auth-context.util';
import { type WorkflowRunWorkspaceEntity } from 'src/modules/workflow/common/standard-objects/workflow-run.workspace-entity';
import {
@@ -10,10 +9,6 @@ import {
type WorkflowToolDependencies,
} from 'src/modules/workflow/workflow-tools/types/workflow-tool-dependencies.type';
-type GetWorkflowRunToolContext = WorkflowToolContext & {
- rolePermissionConfig: RolePermissionConfig;
-};
-
const getWorkflowRunSchema = z.object({
workflowRunId: z.uuid().describe('The UUID of the workflow run to inspect'),
});
@@ -27,7 +22,7 @@ const FAILED_STEP_STATUSES: StepStatus[] = [
export const createGetWorkflowRunTool = (
deps: Pick<WorkflowToolDependencies, 'workspaceOrmManager'>,
- context: GetWorkflowRunToolContext,
+ context: WorkflowToolContext,
) => ({
name: 'get_workflow_run' as const,
description:
@@ -92,8 +87,8 @@ export const createGetWorkflowRunTool = (
startedAt: workflowRun.startedAt,
endedAt: workflowRun.endedAt,
enqueuedAt: workflowRun.enqueuedAt,
- workflowId: workflowRun.workflowId,
- workflowVersionId: workflowRun.workflowVersionId,
+ coreWorkflowId: workflowRun.coreWorkflowId,
+ coreWorkflowVersionId: workflowRun.coreWorkflowVersionId,
steps,
failedStepLogs,
},
diff --git a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/list-workflow-runs.tool.ts b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/list-workflow-runs.tool.ts
index eb4f7ece63a..324ff665850 100644
--- a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/list-workflow-runs.tool.ts
+++ b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/list-workflow-runs.tool.ts
@@ -2,7 +2,6 @@ import { isDefined } from 'twenty-shared/utils';
import { type FindOptionsWhere } from 'typeorm';
import { z } from 'zod';
-import { type RolePermissionConfig } from 'src/engine/twenty-orm/types/role-permission-config';
import { buildSystemAuthContext } from 'src/engine/twenty-orm/utils/build-system-auth-context.util';
import {
WorkflowRunStatus,
@@ -13,18 +12,16 @@ import {
type WorkflowToolDependencies,
} from 'src/modules/workflow/workflow-tools/types/workflow-tool-dependencies.type';
-type ListWorkflowRunsToolContext = WorkflowToolContext & {
- rolePermissionConfig: RolePermissionConfig;
-};
-
const DEFAULT_LIMIT = 10;
const MAX_LIMIT = 50;
const listWorkflowRunsSchema = z.object({
- workflowId: z
+ coreWorkflowId: z
.uuid()
.optional()
- .describe('Filter runs by the UUID of the workflow they belong to'),
+ .describe(
+ 'Filter runs by the core workflow UUID they belong to, as returned by list_workflows',
+ ),
status: z
.nativeEnum(WorkflowRunStatus)
.optional()
@@ -44,11 +41,11 @@ type ListWorkflowRunsInput = z.infer<typeof listWorkflowRunsSchema>;
export const createListWorkflowRunsTool = (
deps: Pick<WorkflowToolDependencies, 'workspaceOrmManager'>,
- context: ListWorkflowRunsToolContext,
+ context: WorkflowToolContext,
) => ({
name: 'list_workflow_runs' as const,
description:
- 'List workflow runs, optionally filtered by workflow and/or status, ordered from most to least recent. Use this to find the relevant run (for example the latest failed run of a workflow) before inspecting it in detail with get_workflow_run.',
+ 'List workflow runs, optionally filtered by core workflow and/or status, ordered from most to least recent. Use this to find the relevant run (for example the latest failed run of a workflow) before inspecting it in detail with get_workflow_run.',
inputSchema: listWorkflowRunsSchema,
execute: async (parameters: ListWorkflowRunsInput) => {
try {
@@ -64,8 +61,8 @@ export const createListWorkflowRunsTool = (
const where: FindOptionsWhere<WorkflowRunWorkspaceEntity> = {};
- if (isDefined(parameters.workflowId)) {
- where.workflowId = parameters.workflowId;
+ if (isDefined(parameters.coreWorkflowId)) {
+ where.coreWorkflowId = parameters.coreWorkflowId;
}
if (isDefined(parameters.status)) {
@@ -87,8 +84,8 @@ export const createListWorkflowRunsTool = (
error: workflowRun.state?.workflowRunError,
startedAt: workflowRun.startedAt,
endedAt: workflowRun.endedAt,
- workflowId: workflowRun.workflowId,
- workflowVersionId: workflowRun.workflowVersionId,
+ coreWorkflowId: workflowRun.coreWorkflowId,
+ coreWorkflowVersionId: workflowRun.coreWorkflowVersionId,
})),
};
},
diff --git a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/list-workflows.tool.ts b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/list-workflows.tool.ts
index 879f4b96ada..abb41a4fd4b 100644
--- a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/list-workflows.tool.ts
+++ b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/list-workflows.tool.ts
@@ -1,84 +1,89 @@
import { z } from 'zod';
-import { type RolePermissionConfig } from 'src/engine/twenty-orm/types/role-permission-config';
-import { buildSystemAuthContext } from 'src/engine/twenty-orm/utils/build-system-auth-context.util';
import {
- WorkflowStatus,
- type WorkflowWorkspaceEntity,
-} from 'src/modules/workflow/common/standard-objects/workflow.workspace-entity';
+ CoreWorkflowFilterFieldKey,
+ CoreWorkflowFilterLogicalOperator,
+ CoreWorkflowFilterOperand,
+} from 'src/engine/core-modules/workflow/dtos/core-workflow-filter.input';
+import {
+ CoreWorkflowOrderByDirection,
+ CoreWorkflowOrderByField,
+} from 'src/engine/core-modules/workflow/dtos/core-workflows.input';
+import { WorkflowStatus } from 'src/modules/workflow/common/standard-objects/workflow.workspace-entity';
import {
type WorkflowToolContext,
type WorkflowToolDependencies,
} from 'src/modules/workflow/workflow-tools/types/workflow-tool-dependencies.type';
-type ListWorkflowsToolContext = WorkflowToolContext & {
- rolePermissionConfig: RolePermissionConfig;
-};
+const DEFAULT_LIST_WORKFLOWS_LIMIT = 50;
const listWorkflowsSchema = z.object({
status: z
.nativeEnum(WorkflowStatus)
.optional()
.describe('Filter by status (DRAFT, ACTIVE, DEACTIVATED)'),
- limit: z.number().int().min(1).max(100).optional().default(50),
- offset: z.number().int().min(0).optional().default(0),
+ limit: z
+ .number()
+ .int()
+ .min(1)
+ .max(100)
+ .optional()
+ .default(DEFAULT_LIST_WORKFLOWS_LIMIT),
+ after: z
+ .string()
+ .optional()
+ .describe(
+ 'Cursor returned as endCursor by a previous call, to fetch the next page',
+ ),
});
type ListWorkflowsInput = z.infer<typeof listWorkflowsSchema>;
export const createListWorkflowsTool = (
- deps: Pick<WorkflowToolDependencies, 'workspaceOrmManager'>,
- context: ListWorkflowsToolContext,
+ deps: Pick<WorkflowToolDependencies, 'coreWorkflowListService'>,
+ context: WorkflowToolContext,
) => ({
name: 'list_workflows' as const,
description:
- 'List all workflows in the workspace. Supports filtering by status and pagination.',
+ 'List all workflows in the workspace. Supports filtering by status and cursor pagination. Returns core workflow IDs (coreWorkflowId), which every other workflow tool expects. Use get_workflow_current_version to get the workflow current core version.',
inputSchema: listWorkflowsSchema,
execute: async (parameters: ListWorkflowsInput) => {
try {
- const authContext = buildSystemAuthContext(context.workspaceId);
-
- return await deps.workspaceOrmManager.executeInWorkspaceContext(
- async () => {
- const workflowRepository =
- deps.workspaceOrmManager.getRepository<WorkflowWorkspaceEntity>(
- 'workflow',
- context.rolePermissionConfig,
- );
-
- const queryBuilder =
- workflowRepository.createQueryBuilder('workflow');
+ const { edges, pageInfo, totalCount } =
+ await deps.coreWorkflowListService.findManyByWorkspaceId({
+ workspaceId: context.workspaceId,
+ userWorkspaceId: context.userWorkspaceId,
+ first: parameters.limit ?? DEFAULT_LIST_WORKFLOWS_LIMIT,
+ after: parameters.after,
+ orderBy: CoreWorkflowOrderByField.UPDATED_AT,
+ orderByDirection: CoreWorkflowOrderByDirection.DESC,
+ filter: parameters.status
+ ? {
+ logicalOperator: CoreWorkflowFilterLogicalOperator.AND,
+ rules: [
+ {
+ fieldKey: CoreWorkflowFilterFieldKey.STATUSES,
+ operand: CoreWorkflowFilterOperand.CONTAINS,
+ value: JSON.stringify([parameters.status]),
+ },
+ ],
+ }
+ : undefined,
+ });
- if (parameters.status) {
- queryBuilder.where(':status = ANY(workflow.statuses)', {
- status: parameters.status,
- });
- }
-
- queryBuilder
- .orderBy('workflow.createdAt', 'DESC')
- .take(parameters.limit)
- .skip(parameters.offset);
-
- const workflows =
- await queryBuilder.getMany<WorkflowWorkspaceEntity>();
- const totalCount = await queryBuilder.getCount();
-
- return {
- success: true,
- workflows: workflows.map((workflow) => ({
- id: workflow.id,
- name: workflow.name,
- statuses: workflow.statuses,
- lastPublishedVersionId: workflow.lastPublishedVersionId,
- createdAt: workflow.createdAt,
- updatedAt: workflow.updatedAt,
- })),
- totalCount,
- };
- },
- authContext,
- );
+ return {
+ success: true,
+ workflows: edges.map(({ node }) => ({
+ coreWorkflowId: node.id,
+ name: node.name,
+ statuses: node.statuses,
+ createdAt: node.createdAt,
+ updatedAt: node.updatedAt,
+ })),
+ totalCount,
+ endCursor: pageInfo.endCursor,
+ hasNextPage: pageInfo.hasNextPage,
+ };
} catch (error) {
const errorMessage =
error instanceof Error ? error.message : String(error);
diff --git a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/update-agent.tool.ts b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/update-agent.tool.ts
index 55caa9b8cd4..ea821db1164 100644
--- a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/update-agent.tool.ts
+++ b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/update-agent.tool.ts
@@ -4,10 +4,6 @@ import { z } from 'zod';
import { type AgentResponseFormat } from 'src/engine/metadata-modules/ai/ai-agent/types/agent-response-format.type';
import { type ModelId } from 'src/engine/metadata-modules/ai/ai-models/types/model-id.type';
-import {
- WorkflowVersionStatus,
- type WorkflowVersionWorkspaceEntity,
-} from 'src/modules/workflow/common/standard-objects/workflow-version.workspace-entity';
import {
type WorkflowToolContext,
type WorkflowToolDependencies,
@@ -61,35 +57,32 @@ const updateAgentSchema = z.object({
const resyncAiAgentStepOutputSchemas = async (
deps: Pick<
WorkflowToolDependencies,
- | 'workflowVersionStepService'
- | 'workspaceOrmManager'
+ | 'coreWorkflowVersionListService'
+ | 'coreWorkflowVersionMutationService'
| 'flatEntityMapsCacheService'
>,
- { workspaceId, agentId }: { workspaceId: string; agentId: string },
+ {
+ workspaceId,
+ userWorkspaceId,
+ agentId,
+ }: {
+ workspaceId: string;
+ userWorkspaceId: string | undefined;
+ agentId: string;
+ },
): Promise<void> => {
await deps.flatEntityMapsCacheService.invalidateFlatEntityMaps({
workspaceId,
flatMapsKeys: ['flatAgentMaps'],
});
- const workflowVersionRepository =
- deps.workspaceOrmManager.getRepository<WorkflowVersionWorkspaceEntity>(
- 'workflowVersion',
- { shouldBypassPermissionChecks: true },
- );
-
- const draftVersions = await workflowVersionRepository.find({
- where: { status: WorkflowVersionStatus.DRAFT },
- });
-
- for (const version of draftVersions) {
- const steps = version.steps;
-
- if (!isDefined(steps)) {
- continue;
- }
+ const draftCoreVersions =
+ await deps.coreWorkflowVersionListService.findDraftCoreWorkflowVersions({
+ workspaceId,
+ });
- const matchingStep = steps.find(
+ for (const draftCoreVersion of draftCoreVersions) {
+ const matchingStep = draftCoreVersion.steps?.find(
(step) =>
step.type === WorkflowActionType.AI_AGENT &&
step.settings?.input?.agentId === agentId,
@@ -99,9 +92,10 @@ const resyncAiAgentStepOutputSchemas = async (
continue;
}
- await deps.workflowVersionStepService.updateWorkflowVersionStep({
+ await deps.coreWorkflowVersionMutationService.updateStep({
workspaceId,
- workflowVersionId: version.id,
+ userWorkspaceId,
+ coreWorkflowVersionId: draftCoreVersion.id,
step: matchingStep,
});
}
@@ -111,8 +105,8 @@ export const createUpdateAgentTool = (
deps: Pick<
WorkflowToolDependencies,
| 'agentService'
- | 'workflowVersionStepService'
- | 'workspaceOrmManager'
+ | 'coreWorkflowVersionListService'
+ | 'coreWorkflowVersionMutationService'
| 'flatEntityMapsCacheService'
>,
context: WorkflowToolContext,
@@ -150,7 +144,11 @@ To find the agentId, look at the AI_AGENT step's settings.input.agentId field.`,
if (isDefined(responseFormat)) {
try {
- await resyncAiAgentStepOutputSchemas(deps, { workspaceId, agentId });
+ await resyncAiAgentStepOutputSchemas(deps, {
+ workspaceId,
+ userWorkspaceId: context.userWorkspaceId,
+ agentId,
+ });
} catch (resyncError) {
return {
success: true,
diff --git a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/update-workflow-version-positions.tool.ts b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/update-workflow-version-positions.tool.ts
index 4985426f67f..a65e464122b 100644
--- a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/update-workflow-version-positions.tool.ts
+++ b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/update-workflow-version-positions.tool.ts
@@ -1,16 +1,16 @@
import { z } from 'zod';
-import type { UpdateWorkflowVersionPositionsInput } from 'src/engine/core-modules/workflow/dtos/update-workflow-version-positions.input';
+import { type WorkflowStepPositionUpdateInput } from 'src/engine/core-modules/workflow/dtos/update-workflow-step-position-update.input';
import {
type WorkflowToolContext,
type WorkflowToolDependencies,
} from 'src/modules/workflow/workflow-tools/types/workflow-tool-dependencies.type';
const updateWorkflowVersionPositionsSchema = z.object({
- workflowVersionId: z
+ coreWorkflowVersionId: z
.string()
.uuid()
- .describe('The UUID of the workflow version'),
+ .describe('The core workflow version UUID'),
positions: z
.array(
z.object({
@@ -25,19 +25,23 @@ const updateWorkflowVersionPositionsSchema = z.object({
});
export const createUpdateWorkflowVersionPositionsTool = (
- deps: Pick<WorkflowToolDependencies, 'workflowVersionService'>,
+ deps: Pick<WorkflowToolDependencies, 'coreWorkflowVersionMutationService'>,
context: WorkflowToolContext,
) => ({
name: 'update_workflow_version_positions' as const,
description:
'Update the positions of multiple workflow steps. This is useful for reorganizing the workflow layout.',
inputSchema: updateWorkflowVersionPositionsSchema,
- execute: async (parameters: UpdateWorkflowVersionPositionsInput) => {
+ execute: async (parameters: {
+ coreWorkflowVersionId: string;
+ positions: WorkflowStepPositionUpdateInput[];
+ }) => {
try {
- return await deps.workflowVersionService.updateWorkflowVersionPositions({
- workflowVersionId: parameters.workflowVersionId,
+ return await deps.coreWorkflowVersionMutationService.updatePositions({
+ coreWorkflowVersionId: parameters.coreWorkflowVersionId,
positions: parameters.positions,
workspaceId: context.workspaceId,
+ userWorkspaceId: context.userWorkspaceId,
});
} catch (error) {
return {
diff --git a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/update-workflow-version-step.tool.ts b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/update-workflow-version-step.tool.ts
index 1e9f722e0bc..d15141a2050 100644
--- a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/update-workflow-version-step.tool.ts
+++ b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/update-workflow-version-step.tool.ts
@@ -1,35 +1,39 @@
import { workflowActionSchema } from 'twenty-shared/workflow';
import { z } from 'zod';
-import type { UpdateWorkflowVersionStepInput } from 'src/engine/core-modules/workflow/dtos/update-workflow-version-step.input';
+import { type WorkflowAction } from 'src/modules/workflow/workflow-executor/workflow-actions/types/workflow-action.type';
import {
type WorkflowToolContext,
type WorkflowToolDependencies,
} from 'src/modules/workflow/workflow-tools/types/workflow-tool-dependencies.type';
const updateWorkflowVersionStepSchema = z.object({
- workflowVersionId: z
+ coreWorkflowVersionId: z
.string()
.uuid()
- .describe('The UUID of the workflow version containing the step'),
+ .describe('The core workflow version UUID containing the step'),
step: z
.union([workflowActionSchema])
.describe('The updated step configuration'),
});
export const createUpdateWorkflowVersionStepTool = (
- deps: Pick<WorkflowToolDependencies, 'workflowVersionStepService'>,
+ deps: Pick<WorkflowToolDependencies, 'coreWorkflowVersionMutationService'>,
context: WorkflowToolContext,
) => ({
name: 'update_workflow_version_step' as const,
description:
'Update an existing step in a workflow version. This modifies the step configuration. Call validate_workflow once after your edits are done, not after every change.',
inputSchema: updateWorkflowVersionStepSchema,
- execute: async (parameters: UpdateWorkflowVersionStepInput) => {
+ execute: async (parameters: {
+ coreWorkflowVersionId: string;
+ step: WorkflowAction;
+ }) => {
try {
- return await deps.workflowVersionStepService.updateWorkflowVersionStep({
+ return await deps.coreWorkflowVersionMutationService.updateStep({
workspaceId: context.workspaceId,
- workflowVersionId: parameters.workflowVersionId,
+ userWorkspaceId: context.userWorkspaceId,
+ coreWorkflowVersionId: parameters.coreWorkflowVersionId,
step: parameters.step,
});
} catch (error) {
diff --git a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/update-workflow-version-trigger.tool.ts b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/update-workflow-version-trigger.tool.ts
index 9c2d5eb2697..0b1fe9986f3 100644
--- a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/update-workflow-version-trigger.tool.ts
+++ b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/update-workflow-version-trigger.tool.ts
@@ -1,46 +1,42 @@
import { workflowTriggerSchema } from 'twenty-shared/workflow';
import { z } from 'zod';
-import type { UpdateWorkflowVersionTriggerInput } from 'src/engine/core-modules/workflow/dtos/update-workflow-version-trigger.input';
import {
type WorkflowToolContext,
type WorkflowToolDependencies,
} from 'src/modules/workflow/workflow-tools/types/workflow-tool-dependencies.type';
+import { type WorkflowTrigger } from 'src/modules/workflow/workflow-trigger/types/workflow-trigger.type';
const updateWorkflowVersionTriggerSchema = z.object({
- workflowVersionId: z
+ coreWorkflowVersionId: z
.string()
.uuid()
- .describe('The UUID of the workflow version containing the trigger'),
+ .describe('The core workflow version UUID containing the trigger'),
trigger: workflowTriggerSchema.describe('The updated trigger configuration'),
});
export const createUpdateWorkflowVersionTriggerTool = (
- deps: Pick<WorkflowToolDependencies, 'workflowVersionStepHelpersService'>,
+ deps: Pick<WorkflowToolDependencies, 'coreWorkflowVersionMutationService'>,
context: WorkflowToolContext,
) => ({
name: 'update_workflow_version_trigger' as const,
description:
'Update the trigger of a workflow version. This modifies the trigger configuration (e.g., changing trigger type, settings, or conditions).',
inputSchema: updateWorkflowVersionTriggerSchema,
- execute: async (parameters: UpdateWorkflowVersionTriggerInput) => {
+ execute: async (parameters: {
+ coreWorkflowVersionId: string;
+ trigger: WorkflowTrigger;
+ }) => {
try {
- await deps.workflowVersionStepHelpersService.getValidatedDraftWorkflowVersion(
- {
- workflowVersionId: parameters.workflowVersionId,
+ const { trigger } =
+ await deps.coreWorkflowVersionMutationService.updateTrigger({
workspaceId: context.workspaceId,
- },
- );
-
- await deps.workflowVersionStepHelpersService.updateWorkflowVersionStepsAndTrigger(
- {
- workspaceId: context.workspaceId,
- workflowVersionId: parameters.workflowVersionId,
+ userWorkspaceId: context.userWorkspaceId,
+ coreWorkflowVersionId: parameters.coreWorkflowVersionId,
trigger: parameters.trigger,
- },
- );
+ });
- return parameters.trigger;
+ return trigger;
} catch (error) {
return {
success: false,
diff --git a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/validate-workflow.tool.ts b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/validate-workflow.tool.ts
index d74215dd346..10315e602c1 100644
--- a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/validate-workflow.tool.ts
+++ b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/validate-workflow.tool.ts
@@ -1,24 +1,22 @@
import { z } from 'zod';
-import { type WorkflowCommonWorkspaceService } from 'src/modules/workflow/common/workspace-services/workflow-common.workspace-service';
import { WorkflowVersionValidationException } from 'src/modules/workflow/workflow-builder/workflow-validation/exceptions/workflow-version-validation.exception';
-import { type WorkflowVersionValidationWorkspaceService } from 'src/modules/workflow/workflow-builder/workflow-validation/workflow-version-validation.workspace-service';
-import { type WorkflowToolContext } from 'src/modules/workflow/workflow-tools/types/workflow-tool-dependencies.type';
+import {
+ type WorkflowToolContext,
+ type WorkflowToolDependencies,
+} from 'src/modules/workflow/workflow-tools/types/workflow-tool-dependencies.type';
const validateWorkflowSchema = z.object({
- workflowVersionId: z
+ coreWorkflowVersionId: z
.string()
.uuid()
- .describe('The UUID of the workflow version to validate'),
+ .describe('The core workflow version UUID to validate'),
});
type ValidateWorkflowInput = z.infer<typeof validateWorkflowSchema>;
export const createValidateWorkflowTool = (
- deps: {
- workflowCommonService: WorkflowCommonWorkspaceService;
- workflowVersionValidationWorkspaceService: WorkflowVersionValidationWorkspaceService;
- },
+ deps: Pick<WorkflowToolDependencies, 'coreWorkflowLifecycleService'>,
context: WorkflowToolContext,
) => ({
name: 'validate_workflow' as const,
@@ -27,19 +25,11 @@ export const createValidateWorkflowTool = (
inputSchema: validateWorkflowSchema,
execute: async (parameters: ValidateWorkflowInput) => {
try {
- const workflowVersion =
- await deps.workflowCommonService.getWorkflowVersionOrFail({
- workspaceId: context.workspaceId,
- workflowVersionId: parameters.workflowVersionId,
- });
-
- await deps.workflowVersionValidationWorkspaceService.assertWorkflowVersionIsActivableOrThrow(
- {
- workspaceId: context.workspaceId,
- trigger: workflowVersion.trigger,
- steps: workflowVersion.steps,
- },
- );
+ await deps.coreWorkflowLifecycleService.validateCoreWorkflowVersion({
+ workspaceId: context.workspaceId,
+ userWorkspaceId: context.userWorkspaceId,
+ coreWorkflowVersionId: parameters.coreWorkflowVersionId,
+ });
return {
success: true,
diff --git a/packages/twenty-server/src/modules/workflow/workflow-tools/types/workflow-tool-dependencies.type.ts b/packages/twenty-server/src/modules/workflow/workflow-tools/types/workflow-tool-dependencies.type.ts
index 2bf02d53551..a875148f4fe 100644
--- a/packages/twenty-server/src/modules/workflow/workflow-tools/types/workflow-tool-dependencies.type.ts
+++ b/packages/twenty-server/src/modules/workflow/workflow-tools/types/workflow-tool-dependencies.type.ts
@@ -1,35 +1,35 @@
-import type { RecordPositionService } from 'src/engine/core-modules/record-position/services/record-position.service';
-import type { WorkflowVersionCoreSyncService } from 'src/engine/core-modules/workflow/services/workflow-version-core-sync.service';
+import type { ActorMetadata } from 'twenty-shared/types';
+
+import type { CoreWorkflowLifecycleWorkspaceService } from 'src/engine/core-modules/workflow/services/core-workflow-lifecycle.workspace-service';
+import type { CoreWorkflowListService } from 'src/engine/core-modules/workflow/services/core-workflow-list.service';
+import type { CoreWorkflowMutationWorkspaceService } from 'src/engine/core-modules/workflow/services/core-workflow-mutation.workspace-service';
+import type { CoreWorkflowVersionListService } from 'src/engine/core-modules/workflow/services/core-workflow-version-list.service';
+import type { CoreWorkflowVersionMutationWorkspaceService } from 'src/engine/core-modules/workflow/services/core-workflow-version-mutation.workspace-service';
+import type { CoreWorkflowVersionWriteService } from 'src/engine/core-modules/workflow/services/core-workflow-version-write.service';
import type { AgentService } from 'src/engine/metadata-modules/ai/ai-agent/agent.service';
-import type { LogicFunctionFromSourceService } from 'src/engine/metadata-modules/logic-function/services/logic-function-from-source.service';
import type { WorkspaceManyOrAllFlatEntityMapsCacheService } from 'src/engine/metadata-modules/flat-entity/services/workspace-many-or-all-flat-entity-maps-cache.service';
+import type { LogicFunctionFromSourceService } from 'src/engine/metadata-modules/logic-function/services/logic-function-from-source.service';
+import type { RolePermissionConfig } from 'src/engine/twenty-orm/types/role-permission-config';
import type { WorkspaceOrmManager } from 'src/engine/twenty-orm/workspace-orm.manager';
-import type { WorkflowCommonWorkspaceService } from 'src/modules/workflow/common/workspace-services/workflow-common.workspace-service';
import type { WorkflowSchemaWorkspaceService } from 'src/modules/workflow/workflow-builder/workflow-schema/workflow-schema.workspace-service';
-import type { WorkflowVersionValidationWorkspaceService } from 'src/modules/workflow/workflow-builder/workflow-validation/workflow-version-validation.workspace-service';
-import type { WorkflowVersionEdgeWorkspaceService } from 'src/modules/workflow/workflow-builder/workflow-version-edge/workflow-version-edge.workspace-service';
-import type { WorkflowVersionStepHelpersWorkspaceService } from 'src/modules/workflow/workflow-builder/workflow-version-step/workflow-version-step-helpers.workspace-service';
-import type { WorkflowVersionStepWorkspaceService } from 'src/modules/workflow/workflow-builder/workflow-version-step/workflow-version-step.workspace-service';
-import type { WorkflowVersionWorkspaceService } from 'src/modules/workflow/workflow-builder/workflow-version/workflow-version.workspace-service';
-import type { WorkflowTriggerWorkspaceService } from 'src/modules/workflow/workflow-trigger/workspace-services/workflow-trigger.workspace-service';
export type WorkflowToolDependencies = {
- workflowVersionStepService: WorkflowVersionStepWorkspaceService;
- workflowVersionStepHelpersService: WorkflowVersionStepHelpersWorkspaceService;
- workflowVersionEdgeService: WorkflowVersionEdgeWorkspaceService;
- workflowVersionService: WorkflowVersionWorkspaceService;
- workflowTriggerService: WorkflowTriggerWorkspaceService;
+ coreWorkflowListService: CoreWorkflowListService;
+ coreWorkflowVersionListService: CoreWorkflowVersionListService;
+ coreWorkflowMutationService: CoreWorkflowMutationWorkspaceService;
+ coreWorkflowVersionMutationService: CoreWorkflowVersionMutationWorkspaceService;
+ coreWorkflowVersionWriteService: CoreWorkflowVersionWriteService;
+ coreWorkflowLifecycleService: CoreWorkflowLifecycleWorkspaceService;
workflowSchemaService: WorkflowSchemaWorkspaceService;
- workflowVersionValidationWorkspaceService: WorkflowVersionValidationWorkspaceService;
workspaceOrmManager: WorkspaceOrmManager;
- recordPositionService: RecordPositionService;
logicFunctionFromSourceService: LogicFunctionFromSourceService;
flatEntityMapsCacheService: WorkspaceManyOrAllFlatEntityMapsCacheService;
agentService: AgentService;
- workflowCommonService: WorkflowCommonWorkspaceService;
- workflowVersionCoreSyncService: WorkflowVersionCoreSyncService;
};
export type WorkflowToolContext = {
workspaceId: string;
+ rolePermissionConfig: RolePermissionConfig;
+ actorContext?: ActorMetadata;
+ userWorkspaceId?: string;
};
diff --git a/packages/twenty-server/src/modules/workflow/workflow-tools/workflow-tools.module.ts b/packages/twenty-server/src/modules/workflow/workflow-tools/workflow-tools.module.ts
index bca6621d143..35294b972cd 100644
--- a/packages/twenty-server/src/modules/workflow/workflow-tools/workflow-tools.module.ts
+++ b/packages/twenty-server/src/modules/workflow/workflow-tools/workflow-tools.module.ts
@@ -1,18 +1,11 @@
import { Global, Module } from '@nestjs/common';
-import { RecordPositionModule } from 'src/engine/core-modules/record-position/record-position.module';
import { WORKFLOW_TOOL_SERVICE_TOKEN } from 'src/engine/core-modules/tool-provider/constants/workflow-tool-service.token';
+import { CoreWorkflowServicesModule } from 'src/engine/core-modules/workflow/core-workflow-services.module';
import { AiAgentModule } from 'src/engine/metadata-modules/ai/ai-agent/ai-agent.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 { WorkflowVersionCoreModule } from 'src/engine/core-modules/workflow/workflow-version-core.module';
-import { WorkflowCommonModule } from 'src/modules/workflow/common/workflow-common.module';
import { WorkflowSchemaModule } from 'src/modules/workflow/workflow-builder/workflow-schema/workflow-schema.module';
-import { WorkflowVersionValidationModule } from 'src/modules/workflow/workflow-builder/workflow-validation/workflow-version-validation.module';
-import { WorkflowVersionEdgeModule } from 'src/modules/workflow/workflow-builder/workflow-version-edge/workflow-version-edge.module';
-import { WorkflowVersionStepModule } from 'src/modules/workflow/workflow-builder/workflow-version-step/workflow-version-step.module';
-import { WorkflowVersionModule } from 'src/modules/workflow/workflow-builder/workflow-version/workflow-version.module';
-import { WorkflowTriggerModule } from 'src/modules/workflow/workflow-trigger/workflow-trigger.module';
import { WorkflowToolWorkspaceService } from './services/workflow-tool.workspace-service';
@@ -21,18 +14,11 @@ import { WorkflowToolWorkspaceService } from './services/workflow-tool.workspace
@Global()
@Module({
imports: [
- WorkflowVersionStepModule,
- WorkflowVersionEdgeModule,
- WorkflowVersionModule,
- WorkflowTriggerModule,
- WorkflowCommonModule,
+ CoreWorkflowServicesModule,
WorkflowSchemaModule,
- WorkflowVersionValidationModule,
- RecordPositionModule,
LogicFunctionModule,
WorkspaceManyOrAllFlatEntityMapsCacheModule,
AiAgentModule,
- WorkflowVersionCoreModule,
],
providers: [
WorkflowToolWorkspaceService,
diff --git a/packages/twenty-server/test/integration/ai/suites/workflow-tools-core-ids.integration-spec.ts b/packages/twenty-server/test/integration/ai/suites/workflow-tools-core-ids.integration-spec.ts
new file mode 100644
index 00000000000..9035717abb3
--- /dev/null
+++ b/packages/twenty-server/test/integration/ai/suites/workflow-tools-core-ids.integration-spec.ts
@@ -0,0 +1,447 @@
+import { randomUUID } from 'node:crypto';
+
+import request from 'supertest';
+
+const TEST_WORKSPACE_SCHEMA = 'workspace_1wgvd1injqtife6y4rvfbu3h5';
+
+type McpToolCallResult = {
+ content?: Array<{ type: string; text: string }>;
+ isError?: boolean;
+};
+
+const baseUrl = `http://localhost:${APP_PORT}`;
+
+const postMcp = (body: Record<string, unknown>) =>
+ request(baseUrl)
+ .post('/mcp')
+ .set('Authorization', `Bearer ${API_KEY_ACCESS_TOKEN}`)
+ .set('Content-Type', 'application/json')
+ .set('Accept', 'application/json')
+ .send(JSON.stringify(body));
+
+const callWorkflowTool = async <TResult>(
+ toolName: string,
+ args: Record<string, unknown>,
+): Promise<TResult> => {
+ const response = await postMcp({
+ jsonrpc: '2.0',
+ method: 'tools/call',
+ id: `call-${randomUUID()}`,
+ params: {
+ name: 'execute_tool',
+ arguments: { toolName, arguments: args },
+ },
+ }).expect(200);
+
+ expect(response.body.error).toBeUndefined();
+
+ const result = response.body.result as McpToolCallResult;
+ const raw = result.content?.[0]?.text;
+
+ expect(raw).toBeDefined();
+
+ return JSON.parse(raw as string) as TResult;
+};
+
+const TRIGGER_ID = 'trigger';
+
+const buildManualTrigger = () => ({
+ name: 'Manual Trigger',
+ type: 'MANUAL',
+ settings: { outputSchema: {} },
+ nextStepIds: [],
+ position: { x: 0, y: 0 },
+});
+
+const buildIteratorStep = (id: string) => ({
+ id,
+ name: 'Loop over items',
+ type: 'ITERATOR',
+ valid: true,
+ settings: {
+ input: { items: ['a', 'b'] },
+ outputSchema: {},
+ errorHandlingOptions: {
+ retryOnFailure: { value: 0 },
+ continueOnFailure: { value: false },
+ },
+ },
+ nextStepIds: [],
+});
+
+const buildCodeFreeStep = (id: string, name: string) => ({
+ id,
+ name,
+ type: 'CREATE_RECORD',
+ valid: true,
+ settings: {
+ input: {
+ objectName: 'company',
+ objectRecord: { name: `${name} ${randomUUID()}` },
+ },
+ outputSchema: {},
+ errorHandlingOptions: {
+ retryOnFailure: { value: 0 },
+ continueOnFailure: { value: false },
+ },
+ },
+ nextStepIds: [],
+});
+
+const readCoreWorkflowRow = async (coreWorkflowId: string) => {
+ const rows = await global.testDataSource.query(
+ `SELECT id, "workspaceWorkflowId" FROM core."workflow" WHERE id = $1`,
+ [coreWorkflowId],
+ );
+
+ return rows[0] as { id: string; workspaceWorkflowId: string | null };
+};
+
+const readCoreVersionRow = async (coreWorkflowVersionId: string) => {
+ const rows = await global.testDataSource.query(
+ `SELECT id, "workspaceWorkflowVersionId", steps, triggers, status
+ FROM core."workflowVersion" WHERE id = $1`,
+ [coreWorkflowVersionId],
+ );
+
+ return rows[0] as {
+ id: string;
+ workspaceWorkflowVersionId: string | null;
+ steps: unknown[] | null;
+ triggers: unknown[] | null;
+ status: string;
+ };
+};
+
+const readWorkspaceVersionRow = async (workspaceWorkflowVersionId: string) => {
+ const rows = await global.testDataSource.query(
+ `SELECT id, steps, trigger FROM "${TEST_WORKSPACE_SCHEMA}"."workflowVersion" WHERE id = $1`,
+ [workspaceWorkflowVersionId],
+ );
+
+ return rows[0] as {
+ id: string;
+ steps: { id: string; name: string }[] | null;
+ trigger: { type: string } | null;
+ };
+};
+
+describe('workflow MCP tools on core identities (integration)', () => {
+ const coreWorkflowIdsToDelete: string[] = [];
+
+ afterAll(async () => {
+ for (const coreWorkflowId of coreWorkflowIdsToDelete) {
+ await callWorkflowTool('delete_workflow', { coreWorkflowId });
+ }
+ });
+
+ describe('create → inspect → edit → validate → activate', () => {
+ const iteratorStepId = randomUUID();
+ const loopBodyStepId = randomUUID();
+ const afterLoopStepId = randomUUID();
+ const workflowName = `MCP core workflow ${randomUUID()}`;
+
+ let coreWorkflowId: string;
+ let coreWorkflowVersionId: string;
+
+ it('should create a complete workflow and return core identifiers', async () => {
+ const created = await callWorkflowTool<{
+ success: boolean;
+ result: { coreWorkflowId: string; coreWorkflowVersionId: string };
+ }>('create_complete_workflow', {
+ name: workflowName,
+ trigger: buildManualTrigger(),
+ steps: [
+ buildIteratorStep(iteratorStepId),
+ buildCodeFreeStep(loopBodyStepId, 'Inside loop'),
+ buildCodeFreeStep(afterLoopStepId, 'After loop'),
+ ],
+ edges: [
+ { source: TRIGGER_ID, target: iteratorStepId },
+ {
+ source: iteratorStepId,
+ target: loopBodyStepId,
+ sourceConnectionOptions: {
+ connectedStepType: 'ITERATOR',
+ settings: { isConnectedToLoop: true },
+ },
+ },
+ { source: loopBodyStepId, target: iteratorStepId },
+ { source: iteratorStepId, target: afterLoopStepId },
+ ],
+ });
+
+ expect(created.success).toBe(true);
+
+ coreWorkflowId = created.result.coreWorkflowId;
+ coreWorkflowVersionId = created.result.coreWorkflowVersionId;
+
+ coreWorkflowIdsToDelete.push(coreWorkflowId);
+
+ expect(coreWorkflowId).toBeDefined();
+ expect(coreWorkflowVersionId).toBeDefined();
+ });
+
+ it('should key the returned identifiers on core rows whose ids differ from the workspace mirrors', async () => {
+ const coreWorkflow = await readCoreWorkflowRow(coreWorkflowId);
+ const coreVersion = await readCoreVersionRow(coreWorkflowVersionId);
+
+ expect(coreWorkflow.workspaceWorkflowId).toBeDefined();
+ expect(coreWorkflow.workspaceWorkflowId).not.toBe(coreWorkflowId);
+ expect(coreVersion.workspaceWorkflowVersionId).toBeDefined();
+ expect(coreVersion.workspaceWorkflowVersionId).not.toBe(
+ coreWorkflowVersionId,
+ );
+ });
+
+ it('should preserve the iterator loop connection and the step after the loop', async () => {
+ const coreVersion = await readCoreVersionRow(coreWorkflowVersionId);
+ const steps = (coreVersion.steps ?? []) as {
+ id: string;
+ type: string;
+ nextStepIds?: string[];
+ settings?: { input?: { initialLoopStepIds?: string[] } };
+ }[];
+
+ const iteratorStep = steps.find((step) => step.id === iteratorStepId);
+ const loopBodyStep = steps.find((step) => step.id === loopBodyStepId);
+
+ expect(iteratorStep?.settings?.input?.initialLoopStepIds).toEqual([
+ loopBodyStepId,
+ ]);
+ expect(iteratorStep?.nextStepIds).toEqual([afterLoopStepId]);
+ expect(loopBodyStep?.nextStepIds).toEqual([iteratorStepId]);
+ });
+
+ it('should read the current version back by core workflow id', async () => {
+ const current = await callWorkflowTool<{
+ success: boolean;
+ workflowVersion: {
+ coreWorkflowVersionId: string;
+ coreWorkflowId: string;
+ steps: { id: string }[];
+ };
+ }>('get_workflow_current_version', { coreWorkflowId });
+
+ expect(current.success).toBe(true);
+ expect(current.workflowVersion.coreWorkflowVersionId).toBe(
+ coreWorkflowVersionId,
+ );
+ expect(current.workflowVersion.coreWorkflowId).toBe(coreWorkflowId);
+ expect(current.workflowVersion.steps.map(({ id }) => id)).toEqual(
+ expect.arrayContaining([iteratorStepId, loopBodyStepId]),
+ );
+ });
+
+ it('should list the workflow by its core id', async () => {
+ const listed = await callWorkflowTool<{
+ success: boolean;
+ workflows: { coreWorkflowId: string; name: string }[];
+ }>('list_workflows', { limit: 100 });
+
+ expect(listed.success).toBe(true);
+ expect(
+ listed.workflows.some(
+ (workflow) => workflow.coreWorkflowId === coreWorkflowId,
+ ),
+ ).toBe(true);
+ });
+
+ it('should list the workflow when filtering by status', async () => {
+ const listed = await callWorkflowTool<{
+ success: boolean;
+ workflows: { coreWorkflowId: string }[];
+ }>('list_workflows', { limit: 100, status: 'DRAFT' });
+
+ expect(listed.success).toBe(true);
+ expect(
+ listed.workflows.some(
+ (workflow) => workflow.coreWorkflowId === coreWorkflowId,
+ ),
+ ).toBe(true);
+ });
+
+ it('should list the workflow when no limit is passed', async () => {
+ const listed = await callWorkflowTool<{
+ success: boolean;
+ workflows: { coreWorkflowId: string }[];
+ }>('list_workflows', {});
+
+ expect(listed.success).toBe(true);
+ expect(listed.workflows.length).toBeGreaterThan(0);
+ });
+
+ it('should write an edit through the shared writer so the rollback mirror follows', async () => {
+ const renamedStepName = `Renamed ${randomUUID()}`;
+ const coreVersion = await readCoreVersionRow(coreWorkflowVersionId);
+ const stepToUpdate = (
+ coreVersion.steps as { id: string; name: string }[]
+ ).find((step) => step.id === loopBodyStepId);
+
+ await callWorkflowTool('update_workflow_version_step', {
+ coreWorkflowVersionId,
+ step: { ...stepToUpdate, name: renamedStepName },
+ });
+
+ const updatedCoreVersion = await readCoreVersionRow(
+ coreWorkflowVersionId,
+ );
+ const mirrorVersion = await readWorkspaceVersionRow(
+ updatedCoreVersion.workspaceWorkflowVersionId as string,
+ );
+
+ expect(
+ (updatedCoreVersion.steps as { id: string; name: string }[]).find(
+ (step) => step.id === loopBodyStepId,
+ )?.name,
+ ).toBe(renamedStepName);
+ expect(
+ mirrorVersion.steps?.find((step) => step.id === loopBodyStepId)?.name,
+ ).toBe(renamedStepName);
+ });
+
+ it('should read core content even after the workspace mirror content diverges', async () => {
+ const coreVersion = await readCoreVersionRow(coreWorkflowVersionId);
+
+ await global.testDataSource.query(
+ `UPDATE "${TEST_WORKSPACE_SCHEMA}"."workflowVersion"
+ SET steps = '[]'::jsonb WHERE id = $1`,
+ [coreVersion.workspaceWorkflowVersionId],
+ );
+
+ const current = await callWorkflowTool<{
+ success: boolean;
+ workflowVersion: { steps: { id: string }[] };
+ }>('get_workflow_current_version', { coreWorkflowId });
+
+ expect(current.success).toBe(true);
+ expect(current.workflowVersion.steps).toHaveLength(3);
+ });
+
+ it('should validate and activate using the core version id', async () => {
+ const validated = await callWorkflowTool<{
+ success: boolean;
+ issues?: unknown[];
+ }>('validate_workflow', { coreWorkflowVersionId });
+
+ expect(validated).toMatchObject({ success: true });
+
+ await callWorkflowTool('activate_workflow_version', {
+ coreWorkflowVersionId,
+ });
+
+ const activatedCoreVersion = await readCoreVersionRow(
+ coreWorkflowVersionId,
+ );
+
+ expect(activatedCoreVersion.status).toBe('ACTIVE');
+ });
+
+ it('should filter runs by core workflow id', async () => {
+ const runs = await callWorkflowTool<{
+ success: boolean;
+ workflowRuns: { coreWorkflowId: string }[];
+ }>('list_workflow_runs', { coreWorkflowId });
+
+ expect(runs.success).toBe(true);
+ expect(
+ runs.workflowRuns.every((run) => run.coreWorkflowId === coreWorkflowId),
+ ).toBe(true);
+ });
+ });
+
+ describe('reads without a workspace definition mirror', () => {
+ let coreWorkflowId: string;
+ let coreWorkflowVersionId: string;
+
+ beforeAll(async () => {
+ const created = await callWorkflowTool<{
+ result: { coreWorkflowId: string; coreWorkflowVersionId: string };
+ }>('create_complete_workflow', {
+ name: `Mirrorless core workflow ${randomUUID()}`,
+ trigger: buildManualTrigger(),
+ steps: [buildCodeFreeStep(randomUUID(), 'Only step')],
+ edges: [],
+ });
+
+ coreWorkflowId = created.result.coreWorkflowId;
+ coreWorkflowVersionId = created.result.coreWorkflowVersionId;
+ coreWorkflowIdsToDelete.push(coreWorkflowId);
+
+ const coreVersion = await readCoreVersionRow(coreWorkflowVersionId);
+ const coreWorkflow = await readCoreWorkflowRow(coreWorkflowId);
+
+ await global.testDataSource.query(
+ `DELETE FROM "${TEST_WORKSPACE_SCHEMA}"."workflowVersion" WHERE id = $1`,
+ [coreVersion.workspaceWorkflowVersionId],
+ );
+ await global.testDataSource.query(
+ `DELETE FROM "${TEST_WORKSPACE_SCHEMA}"."workflow" WHERE id = $1`,
+ [coreWorkflow.workspaceWorkflowId],
+ );
+ });
+
+ it('should still return the definition from core', async () => {
+ const current = await callWorkflowTool<{
+ success: boolean;
+ workflowVersion: { coreWorkflowVersionId: string };
+ }>('get_workflow_current_version', { coreWorkflowId });
+
+ expect(current.success).toBe(true);
+ expect(current.workflowVersion.coreWorkflowVersionId).toBe(
+ coreWorkflowVersionId,
+ );
+ });
+
+ it('should still list the workflow', async () => {
+ const listed = await callWorkflowTool<{
+ workflows: { coreWorkflowId: string }[];
+ }>('list_workflows', { limit: 100 });
+
+ expect(
+ listed.workflows.some(
+ (workflow) => workflow.coreWorkflowId === coreWorkflowId,
+ ),
+ ).toBe(true);
+ });
+ });
+
+ describe('deletion', () => {
+ it('should report a missing core workflow instead of reporting a deletion', async () => {
+ const result = await callWorkflowTool<{
+ success: boolean;
+ error?: string;
+ }>('delete_workflow', { coreWorkflowId: randomUUID() });
+
+ expect(result.success).toBe(false);
+ expect(result.error).toBe('Workflow not found');
+ });
+
+ it('should delete a workflow by its core id', async () => {
+ const created = await callWorkflowTool<{
+ result: { coreWorkflowId: string };
+ }>('create_complete_workflow', {
+ name: `Deletable core workflow ${randomUUID()}`,
+ trigger: buildManualTrigger(),
+ steps: [buildCodeFreeStep(randomUUID(), 'Only step')],
+ edges: [],
+ });
+
+ const result = await callWorkflowTool<{
+ success: boolean;
+ coreWorkflowId: string;
+ }>('delete_workflow', {
+ coreWorkflowId: created.result.coreWorkflowId,
+ });
+
+ expect(result.success).toBe(true);
+
+ const remaining = await global.testDataSource.query(
+ `SELECT id FROM core."workflow" WHERE id = $1`,
+ [created.result.coreWorkflowId],
+ );
+
+ expect(remaining).toHaveLength(0);
+ });
+ });
+});
diff --git a/packages/twenty-server/test/integration/graphql/suites/workflow/core-workflow-application-auth.integration-spec.ts b/packages/twenty-server/test/integration/graphql/suites/workflow/core-workflow-application-auth.integration-spec.ts
new file mode 100644
index 00000000000..d4e79faa563
--- /dev/null
+++ b/packages/twenty-server/test/integration/graphql/suites/workflow/core-workflow-application-auth.integration-spec.ts
@@ -0,0 +1,492 @@
+import crypto from 'crypto';
+
+import bcrypt from 'bcrypt';
+import request from 'supertest';
+import { buildBaseManifest } from 'test/integration/metadata/suites/application/utils/build-base-manifest.util';
+import { cleanupApplicationAndAppRegistration } from 'test/integration/metadata/suites/application/utils/cleanup-application-and-app-registration.util';
+import { generateApplicationToken } from 'test/integration/metadata/suites/application/utils/generate-application-token.util';
+import { setupApplicationForSync } from 'test/integration/metadata/suites/application/utils/setup-application-for-sync.util';
+import { syncApplication } from 'test/integration/metadata/suites/application/utils/sync-application.util';
+import { SystemPermissionFlag } from 'twenty-shared/constants';
+
+import {
+ SEED_APPLE_WORKSPACE_ID,
+ SEED_YCOMBINATOR_WORKSPACE_ID,
+} from 'src/engine/workspace-manager/dev-seeder/core/constants/seeder-workspaces.constant';
+
+const APPLE_WORKSPACE_SCHEMA = 'workspace_1wgvd1injqtife6y4rvfbu3h5';
+
+const baseUrl = `http://localhost:${APP_PORT}`;
+
+type InstalledTestApplication = {
+ applicationUniversalIdentifier: string;
+ applicationId: string;
+ accessToken: string;
+};
+
+const graphqlAs = (token: string, query: string, variables?: object) =>
+ request(baseUrl)
+ .post('/graphql')
+ .set('Authorization', `Bearer ${token}`)
+ .send({ query, variables });
+
+const installApplicationWithoutUser = async ({
+ name,
+ grantsWorkflowsPermission,
+}: {
+ name: string;
+ grantsWorkflowsPermission: boolean;
+}): Promise<InstalledTestApplication> => {
+ const applicationUniversalIdentifier = crypto.randomUUID();
+ const roleUniversalIdentifier = crypto.randomUUID();
+
+ await setupApplicationForSync({
+ applicationUniversalIdentifier,
+ name,
+ description: name,
+ sourcePath: name,
+ });
+
+ await syncApplication({
+ manifest: buildBaseManifest({
+ appId: applicationUniversalIdentifier,
+ roleId: roleUniversalIdentifier,
+ overrides: {
+ roles: [
+ {
+ universalIdentifier: roleUniversalIdentifier,
+ label: `${name} role`,
+ description: 'Role used by the workflow application auth suite',
+ canUpdateAllSettings: false,
+ canReadAllObjectRecords: true,
+ canUpdateAllObjectRecords: true,
+ permissionFlagUniversalIdentifiers: grantsWorkflowsPermission
+ ? [SystemPermissionFlag.WORKFLOWS]
+ : [],
+ },
+ ],
+ },
+ }),
+ });
+
+ const [{ id: applicationId, applicationRegistrationId }] =
+ await global.testDataSource.query(
+ `SELECT id, "applicationRegistrationId" FROM core."application"
+ WHERE "universalIdentifier" = $1 AND "workspaceId" = $2`,
+ [applicationUniversalIdentifier, SEED_APPLE_WORKSPACE_ID],
+ );
+
+ const clientSecret = crypto.randomBytes(32).toString('hex');
+
+ await global.testDataSource.query(
+ `UPDATE core."applicationRegistration"
+ SET "oAuthClientSecretHash" = $1, "oAuthScopes" = $2
+ WHERE id = $3`,
+ [
+ await bcrypt.hash(clientSecret, 10),
+ ['read', 'write'],
+ applicationRegistrationId,
+ ],
+ );
+
+ const [{ oAuthClientId }] = await global.testDataSource.query(
+ `SELECT "oAuthClientId" FROM core."applicationRegistration" WHERE id = $1`,
+ [applicationRegistrationId],
+ );
+
+ const tokenResponse = await request(baseUrl).post('/oauth/token').send({
+ grant_type: 'client_credentials',
+ client_id: oAuthClientId,
+ client_secret: clientSecret,
+ });
+
+ if (tokenResponse.status !== 200) {
+ throw new Error(
+ `client_credentials grant failed (${tokenResponse.status}): ${JSON.stringify(tokenResponse.body)}`,
+ );
+ }
+
+ return {
+ applicationUniversalIdentifier,
+ applicationId,
+ accessToken: tokenResponse.body.access_token as string,
+ };
+};
+
+const CREATE_CORE_WORKFLOW = `
+ mutation CreateCoreWorkflow($input: CreateCoreWorkflowInput!) {
+ createCoreWorkflow(input: $input) {
+ id
+ workspaceWorkflowId
+ }
+ }
+`;
+
+const CORE_WORKFLOW_VERSIONS = `
+ query CoreWorkflowVersionsByCoreWorkflowId($coreWorkflowId: UUID!) {
+ coreWorkflowVersionsByCoreWorkflowId(coreWorkflowId: $coreWorkflowId) {
+ id
+ status
+ }
+ }
+`;
+
+const CORE_WORKFLOW_BY_ID = `
+ query CoreWorkflowById($coreWorkflowId: UUID!) {
+ coreWorkflowById(coreWorkflowId: $coreWorkflowId) {
+ id
+ name
+ }
+ }
+`;
+
+const UPDATE_CORE_TRIGGER = `
+ mutation UpdateCoreWorkflowVersionTrigger($input: UpdateCoreWorkflowVersionTriggerInput!) {
+ updateCoreWorkflowVersionTrigger(input: $input) {
+ trigger
+ }
+ }
+`;
+
+const MANUAL_TRIGGER = {
+ name: 'Manual Trigger',
+ type: 'MANUAL',
+ settings: { outputSchema: {} },
+ nextStepIds: [],
+ position: { x: 0, y: 0 },
+};
+
+const APP_SCHEMA_INTROSPECTION = `
+ query AppSchema {
+ __schema {
+ queryType {
+ fields {
+ name
+ }
+ }
+ mutationType {
+ fields {
+ name
+ }
+ }
+ }
+ }
+`;
+
+const CORE_WORKFLOW_SEEDING_QUERY_FIELDS = [
+ 'coreWorkflows',
+ 'coreWorkflowVersionsByCoreWorkflowId',
+];
+
+const CORE_WORKFLOW_SEEDING_MUTATION_FIELDS = [
+ 'createCoreWorkflow',
+ 'createCoreWorkflowVersionStep',
+ 'updateCoreWorkflowVersionStep',
+ 'updateCoreWorkflowVersionTrigger',
+ 'activateCoreWorkflowVersion',
+];
+
+describe('core workflow API with application credentials (integration)', () => {
+ let authorizedApplication: InstalledTestApplication;
+ let deniedApplication: InstalledTestApplication;
+
+ const coreWorkflowIdsToDelete: string[] = [];
+
+ beforeAll(async () => {
+ authorizedApplication = await installApplicationWithoutUser({
+ name: `Authorized workflow app ${crypto.randomUUID().slice(0, 8)}`,
+ grantsWorkflowsPermission: true,
+ });
+
+ deniedApplication = await installApplicationWithoutUser({
+ name: `Denied workflow app ${crypto.randomUUID().slice(0, 8)}`,
+ grantsWorkflowsPermission: false,
+ });
+ });
+
+ afterAll(async () => {
+ if (coreWorkflowIdsToDelete.length > 0) {
+ await graphqlAs(
+ authorizedApplication.accessToken,
+ `
+ mutation DeleteCoreWorkflows($input: DeleteCoreWorkflowsInput!) {
+ deleteCoreWorkflows(input: $input) {
+ id
+ }
+ }
+ `,
+ { input: { coreWorkflowIds: coreWorkflowIdsToDelete } },
+ );
+ }
+
+ await cleanupApplicationAndAppRegistration({
+ applicationUniversalIdentifier:
+ authorizedApplication.applicationUniversalIdentifier,
+ });
+ await cleanupApplicationAndAppRegistration({
+ applicationUniversalIdentifier:
+ deniedApplication.applicationUniversalIdentifier,
+ });
+ });
+
+ it('should let an application without a human user create and configure a workflow', async () => {
+ const createResponse = await graphqlAs(
+ authorizedApplication.accessToken,
+ CREATE_CORE_WORKFLOW,
+ { input: { name: `App seeded workflow ${crypto.randomUUID()}` } },
+ );
+
+ expect(createResponse.body.errors).toBeUndefined();
+
+ const coreWorkflowId = createResponse.body.data.createCoreWorkflow.id;
+
+ coreWorkflowIdsToDelete.push(coreWorkflowId);
+
+ const versionsResponse = await graphqlAs(
+ authorizedApplication.accessToken,
+ CORE_WORKFLOW_VERSIONS,
+ { coreWorkflowId },
+ );
+
+ expect(versionsResponse.body.errors).toBeUndefined();
+
+ const versions =
+ versionsResponse.body.data.coreWorkflowVersionsByCoreWorkflowId;
+
+ expect(versions).toHaveLength(1);
+ expect(versions[0].status).toBe('DRAFT');
+
+ const triggerResponse = await graphqlAs(
+ authorizedApplication.accessToken,
+ UPDATE_CORE_TRIGGER,
+ {
+ input: {
+ coreWorkflowVersionId: versions[0].id,
+ trigger: MANUAL_TRIGGER,
+ },
+ },
+ );
+
+ expect(triggerResponse.body.errors).toBeUndefined();
+ });
+
+ it('should attribute the created workflow to the application rather than to a workspace member', async () => {
+ const createResponse = await graphqlAs(
+ authorizedApplication.accessToken,
+ CREATE_CORE_WORKFLOW,
+ { input: { name: `App attributed workflow ${crypto.randomUUID()}` } },
+ );
+
+ expect(createResponse.body.errors).toBeUndefined();
+
+ const { id: coreWorkflowId, workspaceWorkflowId } =
+ createResponse.body.data.createCoreWorkflow;
+
+ coreWorkflowIdsToDelete.push(coreWorkflowId);
+
+ const [mirror] = await global.testDataSource.query(
+ `SELECT "createdBySource", "createdByWorkspaceMemberId"
+ FROM "${APPLE_WORKSPACE_SCHEMA}"."workflow" WHERE id = $1`,
+ [workspaceWorkflowId],
+ );
+
+ expect(mirror.createdBySource).toBe('APPLICATION');
+ expect(mirror.createdByWorkspaceMemberId).toBeNull();
+ });
+
+ it('should attribute the workflow to the workspace member when a user creates it', async () => {
+ const createResponse = await graphqlAs(
+ APPLE_JANE_ADMIN_ACCESS_TOKEN,
+ CREATE_CORE_WORKFLOW,
+ { input: { name: `User created workflow ${crypto.randomUUID()}` } },
+ );
+
+ expect(createResponse.body.errors).toBeUndefined();
+
+ const { id: coreWorkflowId, workspaceWorkflowId } =
+ createResponse.body.data.createCoreWorkflow;
+
+ coreWorkflowIdsToDelete.push(coreWorkflowId);
+
+ const [mirror] = await global.testDataSource.query(
+ `SELECT "createdBySource", "createdByWorkspaceMemberId", "createdByName"
+ FROM "${APPLE_WORKSPACE_SCHEMA}"."workflow" WHERE id = $1`,
+ [workspaceWorkflowId],
+ );
+
+ expect(mirror.createdBySource).toBe('MANUAL');
+ expect(mirror.createdByWorkspaceMemberId).not.toBeNull();
+ });
+
+ it('should keep the application role when a user acts through the application', async () => {
+ const { data } = await generateApplicationToken({
+ applicationId: authorizedApplication.applicationId,
+ });
+
+ const delegatedToken =
+ data.generateApplicationToken.applicationAccessToken.token;
+
+ const createResponse = await graphqlAs(
+ delegatedToken,
+ CREATE_CORE_WORKFLOW,
+ { input: { name: `Delegated workflow ${crypto.randomUUID()}` } },
+ );
+
+ expect(createResponse.body.errors).toBeUndefined();
+
+ const { id: coreWorkflowId, workspaceWorkflowId } =
+ createResponse.body.data.createCoreWorkflow;
+
+ coreWorkflowIdsToDelete.push(coreWorkflowId);
+
+ const [mirror] = await global.testDataSource.query(
+ `SELECT "createdBySource", "createdByWorkspaceMemberId"
+ FROM "${APPLE_WORKSPACE_SCHEMA}"."workflow" WHERE id = $1`,
+ [workspaceWorkflowId],
+ );
+
+ expect(mirror.createdBySource).toBe('MANUAL');
+ expect(mirror.createdByWorkspaceMemberId).not.toBeNull();
+ });
+
+ it('should refuse an API key, which is neither a user nor an application', async () => {
+ const response = await graphqlAs(
+ API_KEY_ACCESS_TOKEN,
+ CREATE_CORE_WORKFLOW,
+ { input: { name: `Api key workflow ${crypto.randomUUID()}` } },
+ );
+
+ expect(response.body.errors?.[0]?.extensions?.code).toBe('FORBIDDEN');
+ expect(response.body.data?.createCoreWorkflow).toBeFalsy();
+ });
+
+ it('should refuse an API key on a read, where no actor has to be resolved', async () => {
+ const response = await graphqlAs(
+ API_KEY_ACCESS_TOKEN,
+ CORE_WORKFLOW_VERSIONS,
+ {
+ coreWorkflowId: crypto.randomUUID(),
+ },
+ );
+
+ expect(response.body.errors?.[0]?.extensions?.code).toBe('FORBIDDEN');
+ expect(
+ response.body.data?.coreWorkflowVersionsByCoreWorkflowId,
+ ).toBeFalsy();
+ });
+
+ it('should deny an application whose role does not grant the workflows permission', async () => {
+ const response = await graphqlAs(
+ deniedApplication.accessToken,
+ CREATE_CORE_WORKFLOW,
+ { input: { name: `Denied workflow ${crypto.randomUUID()}` } },
+ );
+
+ expect(response.body.errors?.[0]?.extensions?.code).toBe('FORBIDDEN');
+ expect(response.body.data?.createCoreWorkflow).toBeFalsy();
+ });
+
+ it('should not expose a core workflow that belongs to another workspace', async () => {
+ const otherWorkspaceCoreWorkflowId = crypto.randomUUID();
+
+ const [{ id: otherWorkspaceApplicationId }] =
+ await global.testDataSource.query(
+ `SELECT id FROM core."application" WHERE "workspaceId" = $1 LIMIT 1`,
+ [SEED_YCOMBINATOR_WORKSPACE_ID],
+ );
+
+ await global.testDataSource.query(
+ `INSERT INTO core."workflow" (id, "workspaceId", name, "universalIdentifier", "applicationId")
+ VALUES ($1, $2, 'Other workspace workflow', $3, $4)`,
+ [
+ otherWorkspaceCoreWorkflowId,
+ SEED_YCOMBINATOR_WORKSPACE_ID,
+ crypto.randomUUID(),
+ otherWorkspaceApplicationId,
+ ],
+ );
+
+ try {
+ const response = await graphqlAs(
+ authorizedApplication.accessToken,
+ CORE_WORKFLOW_BY_ID,
+ { coreWorkflowId: otherWorkspaceCoreWorkflowId },
+ );
+
+ expect(response.body.errors).toBeUndefined();
+ expect(response.body.data?.coreWorkflowById).toBeNull();
+ } finally {
+ await global.testDataSource.query(
+ `DELETE FROM core."workflow" WHERE id = $1`,
+ [otherWorkspaceCoreWorkflowId],
+ );
+ }
+ });
+
+ it('should keep refusing an unauthenticated request', async () => {
+ const response = await request(baseUrl)
+ .post('/graphql')
+ .send({
+ query: CREATE_CORE_WORKFLOW,
+ variables: { input: { name: 'Unauthenticated workflow' } },
+ });
+
+ expect(response.body.errors).toBeDefined();
+ expect(response.body.data?.createCoreWorkflow).toBeFalsy();
+ });
+
+ it('should expose the core workflow operations the app SDK client seeds with', async () => {
+ const response = await graphqlAs(
+ authorizedApplication.accessToken,
+ APP_SCHEMA_INTROSPECTION,
+ );
+
+ expect(response.body.errors).toBeUndefined();
+
+ const queryFieldNames = (
+ response.body.data?.__schema?.queryType?.fields ?? []
+ ).map((field: { name: string }) => field.name);
+ const mutationFieldNames = (
+ response.body.data?.__schema?.mutationType?.fields ?? []
+ ).map((field: { name: string }) => field.name);
+
+ for (const fieldName of CORE_WORKFLOW_SEEDING_QUERY_FIELDS) {
+ expect(queryFieldNames).toContain(fieldName);
+ }
+
+ for (const fieldName of CORE_WORKFLOW_SEEDING_MUTATION_FIELDS) {
+ expect(mutationFieldNames).toContain(fieldName);
+ }
+ });
+
+ it('should let the application read back a workflow it just created', async () => {
+ const workflowName = `Seeded enrichment workflow ${crypto.randomUUID()}`;
+
+ const createResponse = await graphqlAs(
+ authorizedApplication.accessToken,
+ CREATE_CORE_WORKFLOW,
+ { input: { name: workflowName } },
+ );
+
+ expect(createResponse.body.errors).toBeUndefined();
+
+ const createdCoreWorkflowId =
+ createResponse.body.data?.createCoreWorkflow?.id;
+
+ expect(createdCoreWorkflowId).toBeDefined();
+
+ coreWorkflowIdsToDelete.push(createdCoreWorkflowId);
+
+ const readResponse = await graphqlAs(
+ authorizedApplication.accessToken,
+ CORE_WORKFLOW_BY_ID,
+ { coreWorkflowId: createdCoreWorkflowId },
+ );
+
+ expect(readResponse.body.errors).toBeUndefined();
+ expect(readResponse.body.data?.coreWorkflowById?.id).toBe(
+ createdCoreWorkflowId,
+ );
+ expect(readResponse.body.data?.coreWorkflowById?.name).toBe(workflowName);
+ });
+});
diff --git a/packages/twenty-server/test/integration/graphql/suites/workflow/workflow-ai-tool-malformed-validation.integration-spec.ts b/packages/twenty-server/test/integration/graphql/suites/workflow/workflow-ai-tool-malformed-validation.integration-spec.ts
index 31b629b3a8a..60b6475c9c3 100644
--- a/packages/twenty-server/test/integration/graphql/suites/workflow/workflow-ai-tool-malformed-validation.integration-spec.ts
+++ b/packages/twenty-server/test/integration/graphql/suites/workflow/workflow-ai-tool-malformed-validation.integration-spec.ts
@@ -1,7 +1,6 @@
import { randomUUID } from 'node:crypto';
import request from 'supertest';
-import { deleteRecordsByIds } from 'test/integration/utils/delete-records-by-ids';
const baseUrl = `http://localhost:${APP_PORT}`;
@@ -73,18 +72,21 @@ const createCompleteWorkflow = (
type ToolPayload = {
success: boolean;
error?: string;
- result?: { workflowId?: string };
+ result?: { coreWorkflowId?: string };
};
const parsePayload = (result: McpToolCallResult): ToolPayload =>
JSON.parse(result.content?.[0]?.text ?? '{}') as ToolPayload;
describe('Workflow AI tool validation (e2e)', () => {
- const createdWorkflowIds: string[] = [];
+ const createdCoreWorkflowIds: string[] = [];
afterAll(async () => {
- if (createdWorkflowIds.length > 0) {
- await deleteRecordsByIds('workflow', createdWorkflowIds);
+ for (const coreWorkflowId of createdCoreWorkflowIds) {
+ await callMcpTool('execute_tool', {
+ toolName: 'delete_workflow',
+ arguments: { coreWorkflowId },
+ });
}
});
@@ -109,10 +111,10 @@ describe('Workflow AI tool validation (e2e)', () => {
const payload = parsePayload(result);
expect(payload.success).toBe(true);
- expect(payload.result?.workflowId).toBeDefined();
+ expect(payload.result?.coreWorkflowId).toBeDefined();
- if (payload.result?.workflowId) {
- createdWorkflowIds.push(payload.result.workflowId);
+ if (payload.result?.coreWorkflowId) {
+ createdCoreWorkflowIds.push(payload.result.coreWorkflowId);
}
});
@@ -122,10 +124,10 @@ describe('Workflow AI tool validation (e2e)', () => {
const payload = parsePayload(result);
expect(payload.success).toBe(true);
- expect(payload.result?.workflowId).toBeDefined();
+ expect(payload.result?.coreWorkflowId).toBeDefined();
- if (payload.result?.workflowId) {
- createdWorkflowIds.push(payload.result.workflowId);
+ if (payload.result?.coreWorkflowId) {
+ createdCoreWorkflowIds.push(payload.result.coreWorkflowId);
}
});
});