@shipfox/api-definitions 13.1.0 → 14.0.0

package/src/presentation/inter-module.ts

@@ -1,11 +1,26 @@
+import type {AgentInterModuleClient} from '@shipfox/api-agent-dto/inter-module';
 import {createWorkflowModelSnapshot} from '@shipfox/api-definitions-dto';
 import {definitionsInterModuleContract} from '@shipfox/api-definitions-dto/inter-module';
-import {defineInterModulePresentation, type InterModulePresentation} from '@shipfox/inter-module';
+import type {IntegrationsModuleClient} from '@shipfox/api-integration-core-dto/inter-module';
+import type {ProjectsModuleClient} from '@shipfox/api-projects-dto/inter-module';
+import {
+  createInterModuleKnownError,
+  defineInterModulePresentation,
+  type InterModuleMethodContract,
+  type InterModulePresentation,
+} from '@shipfox/inter-module';
+import {DefinitionAtRefError, listDefinitionsAtRef, resolveDefinitionAtRef} from '#core/index.js';
 import {getDefinitionById} from '#db/definitions.js';
 
-export function createDefinitionsInterModulePresentation(): InterModulePresentation<
-  typeof definitionsInterModuleContract
-> {
+export interface CreateDefinitionsInterModulePresentationParams {
+  projects: ProjectsModuleClient;
+  agent: AgentInterModuleClient;
+  integrations: IntegrationsModuleClient;
+}
+
+export function createDefinitionsInterModulePresentation(
+  params: CreateDefinitionsInterModulePresentationParams,
+): InterModulePresentation<typeof definitionsInterModuleContract> {
   return defineInterModulePresentation(definitionsInterModuleContract, {
     getDefinitionForWorkflowRun: async ({definitionId}) => {
       const definition = await getDefinitionById(definitionId);
@@ -14,6 +29,7 @@ export function createDefinitionsInterModulePresentation(): InterModulePresentat
       return {
         definition: {
           id: definition.id,
+          workflowId: definition.workflowId,
           projectId: definition.projectId,
           name: definition.name,
           model: createWorkflowModelSnapshot(definition.model),
@@ -21,5 +37,62 @@ export function createDefinitionsInterModulePresentation(): InterModulePresentat
         },
       };
     },
+    resolveDefinitionAtRef: async (input, context) => {
+      try {
+        return await resolveDefinitionAtRef({...input, ...params, signal: context.signal});
+      } catch (error) {
+        throw toDefinitionAtRefKnownError(
+          definitionsInterModuleContract.methods.resolveDefinitionAtRef,
+          error,
+        );
+      }
+    },
+    listDefinitionsAtRef: async (input, context) => {
+      try {
+        return await listDefinitionsAtRef({...input, ...params, signal: context.signal});
+      } catch (error) {
+        throw toDefinitionAtRefKnownError(
+          definitionsInterModuleContract.methods.listDefinitionsAtRef,
+          error,
+        );
+      }
+    },
   });
 }
+
+function toDefinitionAtRefKnownError(method: InterModuleMethodContract, error: unknown): unknown {
+  if (!(error instanceof DefinitionAtRefError)) return error;
+  const {code, details} = error;
+  switch (code) {
+    case 'project-not-found':
+      return createInterModuleKnownError(method, 'project-not-found', {
+        projectId: String(details.projectId),
+      });
+    case 'ref-not-found':
+      return createInterModuleKnownError(method, 'ref-not-found', {ref: String(details.ref)});
+    case 'ref-invalid':
+      return createInterModuleKnownError(method, 'ref-invalid', {ref: String(details.ref)});
+    case 'ref-moved':
+      return createInterModuleKnownError(method, 'ref-moved', {
+        ref: String(details.ref),
+        expectedCommit: String(details.expectedCommit),
+      });
+    case 'file-not-found':
+      return createInterModuleKnownError(method, 'file-not-found', {
+        ref: String(details.ref),
+        configPath: String(details.configPath),
+      });
+    case 'content-too-large':
+      return createInterModuleKnownError(method, 'content-too-large', {
+        configPath: String(details.configPath),
+      });
+    case 'invalid-definition':
+      return createInterModuleKnownError(method, 'invalid-definition', {
+        errors: details.errors as Array<{message: string; path?: string}>,
+      });
+    case 'too-many-files':
+      return createInterModuleKnownError(method, 'too-many-files', {});
+    case 'source-unavailable':
+      return createInterModuleKnownError(method, 'source-unavailable', {});
+  }
+}

package/src/presentation/routes/create-definition.test.ts

@@ -149,6 +149,8 @@ jobs:
             capabilities: ['agent_tools' as const],
           },
         ],
+        eventCatalogs: [],
+        fixedEventProviders: [],
         defaultConnection: {
           id: sourceConnectionId,
           slug: 'github-main',
@@ -240,6 +242,42 @@ jobs:
     expect(res.json().code).toBe('invalid-workflow-definition');
   });
 
+  test('trigger-scoped validation errors remain client errors on create', async () => {
+    const res = await app.inject({
+      method: 'POST',
+      url: '/api/definitions',
+      payload: {
+        project_id: projectId,
+        config_path: 'test.yml',
+        yaml: `
+name: Broken trigger
+runner: ubuntu-latest
+triggers:
+  nightly:
+    source: cron
+    event: tick
+    config:
+      schedule: "not a cron"
+jobs:
+  build:
+    steps:
+      - run: echo hello
+`,
+      },
+    });
+
+    expect(res.statusCode).toBe(400);
+    expect(res.json()).toMatchObject({
+      code: 'invalid-workflow-definition',
+      details: [
+        {
+          message: 'Cron trigger schedule must be a valid 5-field cron expression.',
+          path: 'triggers.nightly.config.schedule',
+        },
+      ],
+    });
+  });
+
   test('cyclic DAG returns 400 with dag error code', async () => {
     const cyclicYaml = `
 name: Cyclic

package/src/presentation/routes/create-definition.ts

@@ -11,7 +11,11 @@ import {z} from 'zod';
 import {DefinitionParseError} from '#core/errors.js';
 import {hasAgentStepIntegrations} from '#core/has-agent-step-integrations.js';
 import {loadIntegrationValidationContext} from '#core/integrations.js';
-import {parseDefinition} from '#core/parse-definition.js';
+import {
+  type ParseDefinitionOptions,
+  parseDefinitionWithDiagnostics,
+  stripDefinitionDiagnostics,
+} from '#core/parse-definition.js';
 import {upsertDefinition} from '#db/definitions.js';
 import {toDefinitionDto} from '#presentation/dto/index.js';
 import {requireProjectAccess} from './project-access.js';
@@ -53,11 +57,11 @@ export function buildCreateDefinitionRoute(options: CreateDefinitionRouteOptions
       const project = await requireProjectAccess(request, projectId, options.projects);
 
       const agentValidationCatalog = await options.agent.getValidationCatalog({});
-      const structurallyParsed = parseDefinition(yamlString, {agentValidationCatalog});
+      const structurallyParsed = parseDefinitionForCreate(yamlString, {agentValidationCatalog});
       const {integrations} = options;
       const parsed =
         integrations !== undefined && hasAgentStepIntegrations(structurallyParsed.document)
-          ? parseDefinition(yamlString, {
+          ? parseDefinitionForCreate(yamlString, {
               agentValidationCatalog,
               integrationValidationContext: await loadIntegrationValidationContext(
                 integrations,
@@ -84,3 +88,16 @@ export function buildCreateDefinitionRoute(options: CreateDefinitionRouteOptions
     },
   });
 }
+
+function parseDefinitionForCreate(yamlString: string, options: ParseDefinitionOptions) {
+  const parsed = parseDefinitionWithDiagnostics(yamlString, options);
+  const errors = parsed.diagnostics
+    .filter((diagnostic) => diagnostic.severity === 'error')
+    .map(({message, path}) => ({message, ...(path === undefined ? {} : {path})}));
+
+  if (errors.length > 0) {
+    throw new DefinitionParseError(errors[0]?.message ?? 'Invalid definition', errors);
+  }
+
+  return stripDefinitionDiagnostics(parsed);
+}

package/src/presentation/routes/get-definition.test.ts

@@ -3,23 +3,27 @@ import type {ProjectsModuleClient} from '@shipfox/api-projects-dto/inter-module'
 import type {FastifyInstance} from 'fastify';
 import Fastify from 'fastify';
 import {serializerCompiler, validatorCompiler} from 'fastify-type-provider-zod';
+import {softDeleteVcsDefinitionsNotIn} from '#db/definitions.js';
 import {definitionFactory} from '#test/index.js';
 import {buildGetDefinitionRoute} from './get-definition.js';
 
 const projectAccessState = vi.hoisted(() => ({workspaceId: ''}));
 
+const getProjectById = vi.fn<ProjectsModuleClient['getProjectById']>(({projectId}) =>
+  Promise.resolve({
+    project: {
+      id: projectId,
+      workspaceId: projectAccessState.workspaceId,
+      sourceConnectionId: crypto.randomUUID(),
+      sourceExternalRepositoryId: 'repo',
+      sourceDefaultBranch: 'main',
+      name: 'Project',
+    },
+  }),
+);
+
 const projects = {
-  getProjectById: vi.fn(({projectId}) =>
-    Promise.resolve({
-      project: {
-        id: projectId,
-        workspaceId: projectAccessState.workspaceId,
-        sourceConnectionId: crypto.randomUUID(),
-        sourceExternalRepositoryId: 'repo',
-        name: 'Project',
-      },
-    }),
-  ),
+  getProjectById,
   requireProjectForWorkspace: vi.fn(),
 } as unknown as ProjectsModuleClient;
 
@@ -74,6 +78,116 @@ describe('GET /api/definitions/:id', () => {
     expect(res.json().code).toBe('not-found');
   });
 
+  test('returns 200 with the synced row when the id is a lineage id with a synced row', async () => {
+    const definition = await definitionFactory.create({
+      source: 'vcs',
+      ref: 'main',
+      configPath: '.shipfox/workflows/lineage.yml',
+    });
+    expect(definition.workflowId).not.toBe(definition.id);
+
+    const res = await app.inject({
+      method: 'GET',
+      url: `/api/definitions/${definition.workflowId}`,
+    });
+
+    expect(res.statusCode).toBe(200);
+    expect(res.json().id).toBe(definition.id);
+    expect(res.json().ref).toBe('main');
+  });
+
+  test('returns 404 when the id is a lineage id without a synced row', async () => {
+    const definition = await definitionFactory.create({
+      source: 'vcs',
+      ref: 'main',
+      configPath: '.shipfox/workflows/removed.yml',
+    });
+    await softDeleteVcsDefinitionsNotIn({
+      projectId: definition.projectId,
+      workspaceId,
+      ref: 'main',
+      keepConfigPaths: [],
+    });
+
+    const res = await app.inject({
+      method: 'GET',
+      url: `/api/definitions/${definition.workflowId}`,
+    });
+
+    expect(res.statusCode).toBe(404);
+    expect(res.json().code).toBe('not-found');
+  });
+
+  test('returns 404 when a lineage only has a non-default branch row', async () => {
+    const definition = await definitionFactory.create({
+      source: 'vcs',
+      ref: 'feature/lineage',
+      configPath: '.shipfox/workflows/non-default.yml',
+    });
+
+    const res = await app.inject({
+      method: 'GET',
+      url: `/api/definitions/${definition.workflowId}`,
+    });
+
+    expect(res.statusCode).toBe(404);
+    expect(res.json().code).toBe('not-found');
+  });
+
+  test('returns the row from the project default branch when a lineage has multiple refs', async () => {
+    const projectId = crypto.randomUUID();
+    const main = await definitionFactory.create({
+      projectId,
+      source: 'vcs',
+      ref: 'main',
+      configPath: '.shipfox/workflows/multi-ref.yml',
+      name: 'Main Workflow',
+    });
+    await definitionFactory.create({
+      projectId,
+      source: 'vcs',
+      ref: 'feature/lineage',
+      configPath: '.shipfox/workflows/multi-ref.yml',
+      name: 'Feature Workflow',
+    });
+
+    const res = await app.inject({
+      method: 'GET',
+      url: `/api/definitions/${main.workflowId}`,
+    });
+
+    expect(res.statusCode).toBe(200);
+    expect(res.json().id).toBe(main.id);
+    expect(res.json().name).toBe('Main Workflow');
+    expect(res.json().ref).toBe('main');
+  });
+
+  test('returns 403 through the project-access gate for a lineage in another workspace', async () => {
+    const definition = await definitionFactory.create({
+      source: 'vcs',
+      ref: 'main',
+      configPath: '.shipfox/workflows/elsewhere.yml',
+    });
+    getProjectById.mockResolvedValueOnce({
+      project: {
+        id: definition.projectId,
+        workspaceId: crypto.randomUUID(),
+        sourceConnectionId: crypto.randomUUID(),
+        sourceExternalRepositoryId: 'repo',
+        sourceDefaultBranch: 'main',
+        name: 'Project',
+      },
+    });
+
+    const res = await app.inject({
+      method: 'GET',
+      url: `/api/definitions/${definition.workflowId}`,
+    });
+
+    expect(res.statusCode).toBe(403);
+    expect(res.json().code).toBe('forbidden');
+  });
+
   test('returns 400 for invalid UUID', async () => {
     const res = await app.inject({
       method: 'GET',

package/src/presentation/routes/get-definition.ts

@@ -2,7 +2,11 @@ import {definitionResponseSchema} from '@shipfox/api-definitions-dto';
 import type {ProjectsModuleClient} from '@shipfox/api-projects-dto/inter-module';
 import {ClientError, defineRoute} from '@shipfox/node-fastify';
 import {z} from 'zod';
-import {getDefinitionById} from '#db/definitions.js';
+import {
+  getDefinitionById,
+  getDefinitionByWorkflowId,
+  getWorkflowLineageById,
+} from '#db/definitions.js';
 import {toDefinitionDto} from '#presentation/dto/index.js';
 import {requireProjectAccess} from './project-access.js';
 
@@ -23,12 +27,25 @@ export function buildGetDefinitionRoute(projects: ProjectsModuleClient) {
       const {id} = request.params;
       const definition = await getDefinitionById(id);
 
-      if (!definition) {
+      if (definition) {
+        await requireProjectAccess(request, definition.projectId, projects);
+        return toDefinitionDto(definition);
+      }
+
+      const lineage = await getWorkflowLineageById(id);
+      if (!lineage) {
+        throw new ClientError('Definition not found', 'not-found', {status: 404});
+      }
+
+      const project = await requireProjectAccess(request, lineage.projectId, projects);
+      const syncedDefinition = project.sourceDefaultBranch
+        ? await getDefinitionByWorkflowId({workflowId: id, ref: project.sourceDefaultBranch})
+        : undefined;
+      if (!syncedDefinition) {
         throw new ClientError('Definition not found', 'not-found', {status: 404});
       }
-      await requireProjectAccess(request, definition.projectId, projects);
 
-      return toDefinitionDto(definition);
+      return toDefinitionDto(syncedDefinition);
     },
   });
 }

package/src/presentation/routes/list-definitions.test.ts

@@ -99,7 +99,7 @@ describe('GET /api/definitions', () => {
       finished_at: finishedAt.toISOString(),
       last_error_code: null,
       last_error_message: null,
-      warnings: [],
+      diagnostics: [],
     });
   });
 

package/src/presentation/routes/validate-definition.test.ts

@@ -39,7 +39,7 @@ jobs:
     expect(res.statusCode).toBe(200);
     const body = res.json();
     expect(body.valid).toBe(true);
-    expect(body.warnings).toEqual([]);
+    expect(body.diagnostics).toEqual([]);
     expect(body.workflow_document.name).toBe('Test');
     expect(body.workflow_model.kind).toBe('workflow');
   });

package/src/presentation/routes/validate-definition.ts

@@ -1,8 +1,8 @@
 import type {AgentInterModuleClient} from '@shipfox/api-agent-dto/inter-module';
 import {
   definitionDtoSchema,
+  definitionValidationDiagnosticSchema,
   definitionValidationErrorSchema,
-  definitionValidationWarningSchema,
 } from '@shipfox/api-definitions-dto';
 import {defineRoute} from '@shipfox/node-fastify';
 import {z} from 'zod';
@@ -17,7 +17,7 @@ const validationResultSchema = z.union([
     valid: z.literal(true),
     workflow_document: definitionDtoSchema.shape.workflow_document,
     workflow_model: definitionDtoSchema.shape.workflow_model,
-    warnings: z.array(definitionValidationWarningSchema),
+    diagnostics: z.array(definitionValidationDiagnosticSchema),
   }),
   z.object({
     valid: z.literal(false),
@@ -47,7 +47,7 @@ export function buildValidateDefinitionRoute(agent: AgentInterModuleClient) {
           valid: true as const,
           workflow_document: result.definition.document,
           workflow_model: result.definition.model,
-          warnings: result.warnings,
+          diagnostics: result.diagnostics,
         };
       }
 

package/src/presentation/subscribers/on-integration-connection-available.test.ts

@@ -40,6 +40,7 @@ describe('onIntegrationConnectionAvailable', () => {
       workspaceId: first.workspaceId,
       connectionId: crypto.randomUUID(),
       slug: 'linear_shipfox',
+      capabilities: ['agent_tools'],
     };
     const event: DomainEvent<IntegrationConnectionAvailableEvent> = {
       id: crypto.randomUUID(),
@@ -96,6 +97,7 @@ describe('onIntegrationConnectionAvailable', () => {
       workspaceId,
       connectionId: crypto.randomUUID(),
       slug: 'linear_shipfox',
+      capabilities: ['agent_tools'],
     };
 
     await expect(
@@ -118,6 +120,7 @@ describe('onIntegrationConnectionAvailable', () => {
       workspaceId: crypto.randomUUID(),
       connectionId: crypto.randomUUID(),
       slug: 'linear_shipfox',
+      capabilities: ['agent_tools'],
     };
 
     await expect(

package/src/temporal/activities/sync-activities.test.ts

@@ -26,6 +26,18 @@ jobs:
       - run: pnpm test
 `;
 
+const warningEventInterpolation = '$'.concat('{{ event.x }}');
+const warningYaml = [
+  'name: Warning only',
+  'runner: ubuntu-latest',
+  'jobs:',
+  '  build:',
+  '    steps:',
+  '      - env:',
+  `          MSG: '${warningEventInterpolation}'`,
+  '        run: eval "$MSG"',
+].join('\n');
+
 function sourceControl(
   overrides: Partial<DefinitionsSourceControl> = {},
 ): DefinitionsSourceControl {
@@ -224,7 +236,37 @@ describe('definition sync activities', () => {
 
       expect(result.appliedCount).toBe(1);
       expect(result.deletedCount).toBe(0);
-      expect(result.warnings).toEqual([]);
+      expect(result.diagnostics).toEqual([]);
+    });
+
+    it('adds the workflow file path to persisted diagnostics', async () => {
+      const source = sourceControl({
+        fetchFile: vi.fn(() =>
+          Promise.resolve({
+            path: '.shipfox/workflows/warning.yml',
+            ref: 'main',
+            content: warningYaml,
+          }),
+        ),
+      });
+      const activities = createDefinitionSyncActivities(source, agent);
+
+      const result = await activities.fetchAndApplyDefinitionWorkflows({
+        projectId,
+        workspaceId: crypto.randomUUID(),
+        sourceConnectionId,
+        sourceExternalRepositoryId: 'gitea:gitea-owner/platform',
+        sourceRef: 'main',
+        paths: ['.shipfox/workflows/warning.yml'],
+      });
+
+      expect(result.diagnostics).toHaveLength(1);
+      expect(result.diagnostics[0]).toMatchObject({
+        code: 're-evaluating-command',
+        path: 'jobs.build.steps.0.run',
+        severity: 'warning',
+        filePath: '.shipfox/workflows/warning.yml',
+      });
     });
 
     it('translates DefinitionSyncPermanentError into a non-retryable ApplicationFailure', async () => {
@@ -364,11 +406,12 @@ describe('definition sync activities', () => {
         sourceConnectionId,
         sourceExternalRepositoryId: 'gitea:gitea-owner/platform',
         sourceRef: 'main',
-        warnings: [
+        diagnostics: [
           {
             code: 're-evaluating-command',
             message: 'Workflow data is re-executed as shell code.',
             path: 'jobs.build.steps.0.run',
+            severity: 'warning',
           },
         ],
       });
@@ -386,6 +429,7 @@ describe('definition sync activities', () => {
           code: 're-evaluating-command',
           message: 'Workflow data is re-executed as shell code.',
           path: 'jobs.build.steps.0.run',
+          severity: 'warning',
         },
       ]);
     });

package/src/temporal/activities/sync-activities.ts

@@ -3,7 +3,7 @@ import type {IntegrationsModuleClient} from '@shipfox/api-integration-core-dto/i
 import {markErrorReported} from '@shipfox/node-error-monitoring';
 import {Context} from '@temporalio/activity';
 import {ApplicationFailure} from '@temporalio/common';
-import type {DefinitionSyncErrorCode, DefinitionSyncWarning} from '#core/entities/sync-state.js';
+import type {DefinitionSyncDiagnostic, DefinitionSyncErrorCode} from '#core/entities/sync-state.js';
 import {
   classifySyncFailure,
   discoverWorkflowFiles,
@@ -50,11 +50,11 @@ export interface DiscoverWorkflowsActivityResult {
 export interface FetchAndApplyActivityResult {
   appliedCount: number;
   deletedCount: number;
-  warnings: DefinitionSyncWarning[];
+  diagnostics: DefinitionSyncDiagnostic[];
 }
 
 export interface MarkSyncSucceededActivityInput extends SyncRefScopedInput {
-  warnings?: readonly DefinitionSyncWarning[] | undefined;
+  diagnostics?: readonly DefinitionSyncDiagnostic[] | undefined;
 }
 
 export interface DefinitionSyncActivityOptions {
@@ -98,7 +98,7 @@ function createPrepareDefinitionSyncActivity(sourceControl: DefinitionsSourceCon
         status: 'syncing',
         lastErrorCode: null,
         lastErrorMessage: null,
-        warnings: [],
+        diagnostics: [],
         startedAt: new Date(),
         finishedAt: null,
       });
@@ -169,7 +169,9 @@ function createFetchAndApplyActivity(
 
       return {
         ...result,
-        warnings: definitions.flatMap((entry) => entry.warnings),
+        diagnostics: definitions.flatMap((entry) =>
+          entry.diagnostics.map((diagnostic) => ({...diagnostic, filePath: entry.path})),
+        ),
       };
     });
   };
@@ -187,7 +189,7 @@ function createMarkSyncSucceededActivity() {
       status: 'succeeded',
       lastErrorCode: null,
       lastErrorMessage: null,
-      warnings: input.warnings ?? [],
+      diagnostics: input.diagnostics ?? [],
       finishedAt: new Date(),
     });
   };
@@ -205,7 +207,7 @@ function createMarkSyncFailedActivity() {
       status: 'failed',
       lastErrorCode: input.code,
       lastErrorMessage: input.message,
-      warnings: [],
+      diagnostics: [],
       finishedAt: new Date(),
     });
   };

package/src/temporal/workflows/definition-sync.ts

@@ -65,7 +65,7 @@ export async function definitionSyncWorkflow(
     const {paths} = await discoverDefinitionWorkflows(source);
     const applied = await fetchAndApplyDefinitionWorkflows({...source, paths});
 
-    await markDefinitionSyncSucceeded({...source, warnings: applied.warnings});
+    await markDefinitionSyncSucceeded({...source, diagnostics: applied.diagnostics});
 
     return {
       sourceRef,

package/test/factories/definition.ts

@@ -48,6 +48,7 @@ export const definitionFactory = Factory.define<WorkflowDefinition, DefinitionTr
 
     return {
       id: crypto.randomUUID(),
+      workflowId: crypto.randomUUID(),
       projectId,
       configPath: `.shipfox/workflows/test-${sequence}.yml`,
       source: 'manual',

package/test/globalSetup.ts

@@ -8,6 +8,7 @@ export async function setup() {
   createPostgresClient();
 
   await db().execute(sql`DROP TABLE IF EXISTS definitions_workflow_definitions CASCADE`);
+  await db().execute(sql`DROP TABLE IF EXISTS definitions_workflows CASCADE`);
   await db().execute(sql`DROP TABLE IF EXISTS definitions_sync_states CASCADE`);
   await db().execute(sql`DROP TABLE IF EXISTS definitions_outbox CASCADE`);
   await db().execute(sql`DROP TYPE IF EXISTS definitions_sync_status CASCADE`);
@@ -17,6 +18,7 @@ export async function setup() {
   await db().execute(sql`DROP TABLE IF EXISTS drizzle.__drizzle_migrations_definitions CASCADE`);
   await runMigrations(db(), migrationsPath, '__drizzle_migrations_definitions');
   await db().execute(sql`TRUNCATE TABLE definitions_workflow_definitions CASCADE`);
+  await db().execute(sql`TRUNCATE TABLE definitions_workflows CASCADE`);
   await db().execute(sql`TRUNCATE TABLE definitions_sync_states CASCADE`);
   await db().execute(sql`TRUNCATE TABLE definitions_outbox CASCADE`);