@shipfox/api-definitions 12.3.0 → 14.0.0

package/src/core/workflow-model/normalize-workflow-document.ts

@@ -23,7 +23,7 @@ export function normalizeWorkflowDocument(
     integrationValidationContext?: IntegrationValidationContext | undefined;
     stepSourceLocations?: WorkflowStepSourceLocationMap | undefined;
     /** Provide a fresh array for each call to collect non-fatal validation issues. */
-    warnings?: WorkflowModelValidationIssue[] | undefined;
+    diagnostics?: WorkflowModelValidationIssue[] | undefined;
   },
 ): WorkflowModel {
   const issues: WorkflowModelValidationIssue[] = [];
@@ -65,10 +65,14 @@ export function normalizeWorkflowDocument(
 
   validateCycles(document.jobs, jobIdBySourceName, issues);
 
-  const warnings = issues.filter((issue) => issue.severity === 'warning');
-  options.warnings?.push(...warnings);
+  const diagnostics = issues.filter(
+    (issue) => !(issue.severity === 'error' && issue.scope === 'definition'),
+  );
+  options.diagnostics?.push(...diagnostics);
 
-  const errors = issues.filter((issue) => issue.severity !== 'warning');
+  const errors = issues.filter(
+    (issue) => issue.severity === 'error' && issue.scope === 'definition',
+  );
   if (errors.length > 0) throw new InvalidWorkflowModelError(errors);
 
   return {

package/src/core/workflow-model/parse-interpolation-field.ts

@@ -26,10 +26,10 @@ import {
 import type {WorkflowFieldTemplate} from '../entities/workflow-model.js';
 import type {
   WorkflowModelValidationIssue,
-  WorkflowModelValidationIssueCode,
   WorkflowModelValidationIssuePathSegment,
 } from './invalid-workflow-model-error.js';
 import {validateDirectJobReferences} from './validate-job-references.js';
+import {issue} from './validation-issue.js';
 
 export type StoredInterpolationField =
   | 'run'
@@ -513,25 +513,3 @@ function formatList(values: readonly string[]): string {
 function fieldLabel(field: WorkflowInterpolationField): string {
   return `Workflow ${field}`;
 }
-
-function issue(params: {
-  code: WorkflowModelValidationIssueCode;
-  message: string;
-  path: readonly WorkflowModelValidationIssuePathSegment[];
-  details?: Readonly<Record<string, unknown>>;
-}): WorkflowModelValidationIssue {
-  if (params.details === undefined) {
-    return {
-      code: params.code,
-      message: params.message,
-      path: params.path,
-    };
-  }
-
-  return {
-    code: params.code,
-    message: params.message,
-    path: params.path,
-    details: params.details,
-  };
-}

package/src/core/workflow-model/validate-predicate-expression.ts

@@ -21,6 +21,7 @@ import type {
   WorkflowModelValidationIssue,
   WorkflowModelValidationIssueCode,
   WorkflowModelValidationIssuePathSegment,
+  WorkflowModelValidationIssueScope,
 } from './invalid-workflow-model-error.js';
 import {validateDirectJobReferences} from './validate-job-references.js';
 import {issue} from './validation-issue.js';
@@ -35,6 +36,8 @@ export function validatePredicateExpression(params: {
   issues: WorkflowModelValidationIssue[];
   allowedJobReferences?: ReadonlySet<string>;
   typeOverlay?: ExpressionTypeEnvironment | undefined;
+  /** Scope for the invalidCode issue; other issues keep the definition scope. */
+  scope?: WorkflowModelValidationIssueScope | undefined;
 }): WorkflowExpression | undefined {
   const site = getWorkflowPredicateFieldMinimumFillTarget(params.field);
   const syntaxExpression = createSyntaxExpression(params);
@@ -150,6 +153,7 @@ function createSyntaxExpression(params: {
   invalidCode: WorkflowModelValidationIssueCode;
   invalidMessage: string;
   issues: WorkflowModelValidationIssue[];
+  scope?: WorkflowModelValidationIssueScope | undefined;
 }): WorkflowExpression | undefined {
   try {
     return createWorkflowExpression({
@@ -179,6 +183,7 @@ function invalidPredicateIssue(params: {
   invalidMessage: string;
   contextRoots: readonly string[];
   reason?: string;
+  scope?: WorkflowModelValidationIssueScope | undefined;
 }): WorkflowModelValidationIssue {
   return issue({
     code: params.invalidCode,
@@ -190,6 +195,7 @@ function invalidPredicateIssue(params: {
       contextRoots: params.contextRoots,
       reason: params.reason ?? 'Expression source did not parse or type-check.',
     },
+    ...(params.scope === undefined ? {} : {scope: params.scope}),
   });
 }
 

package/src/core/workflow-model/validation-issue.ts

@@ -2,6 +2,7 @@ import type {
   WorkflowModelValidationIssue,
   WorkflowModelValidationIssueCode,
   WorkflowModelValidationIssuePathSegment,
+  WorkflowModelValidationIssueScope,
   WorkflowModelValidationIssueSeverity,
 } from './invalid-workflow-model-error.js';
 
@@ -11,21 +12,15 @@ export function issue(params: {
   path: readonly WorkflowModelValidationIssuePathSegment[];
   details?: Readonly<Record<string, unknown>>;
   severity?: WorkflowModelValidationIssueSeverity;
+  scope?: WorkflowModelValidationIssueScope;
 }): WorkflowModelValidationIssue {
+  const severity = params.severity ?? 'error';
+  const scope = params.scope ?? 'definition';
+  const base = {code: params.code, message: params.message, path: params.path, severity, scope};
+
   if (params.details === undefined) {
-    return {
-      code: params.code,
-      message: params.message,
-      path: params.path,
-      ...(params.severity === undefined ? {} : {severity: params.severity}),
-    };
+    return base;
   }
 
-  return {
-    code: params.code,
-    message: params.message,
-    path: params.path,
-    details: params.details,
-    ...(params.severity === undefined ? {} : {severity: params.severity}),
-  };
+  return {...base, details: params.details};
 }

package/src/db/db.ts

@@ -3,8 +3,14 @@ import {pgClient} from '@shipfox/node-postgres';
 import {workflowDefinitions} from './schema/definitions.js';
 import {definitionsOutbox} from './schema/outbox.js';
 import {definitionSyncStates} from './schema/sync-states.js';
+import {workflowWorkflows} from './schema/workflows.js';
 
-export const schema = {workflowDefinitions, definitionsOutbox, definitionSyncStates};
+export const schema = {
+  workflowDefinitions,
+  definitionsOutbox,
+  definitionSyncStates,
+  workflowWorkflows,
+};
 
 let _db: NodePgDatabase<typeof schema> | undefined;
 

package/src/db/definition-triggers.test.ts

@@ -1,3 +1,4 @@
+import {definitionResolvedEventSchema} from '@shipfox/api-definitions-dto';
 import type {WorkflowModel, WorkflowModelTrigger} from '#core/entities/workflow-model.js';
 import {definitionTriggersFor} from './definition-triggers.js';
 
@@ -85,6 +86,49 @@ describe('definitionTriggersFor', () => {
     });
   });
 
+  it('passes an omitted event through for integration triggers', () => {
+    const model = workflowModelWithTriggers([
+      {
+        id: 'on_any_github_event',
+        key: 'on_any_github_event',
+        source: 'github_acme',
+      },
+    ]);
+
+    const result = definitionTriggersFor(model);
+
+    expect(result).toEqual({
+      on_any_github_event: {
+        source: 'github_acme',
+      },
+    });
+    expect(result.on_any_github_event).not.toHaveProperty('event');
+  });
+
+  it('round trips a trigger without an event through the definition event schema', () => {
+    const dto = definitionTriggersFor(
+      workflowModelWithTriggers([
+        {
+          id: 'on_any_github_event',
+          key: 'on_any_github_event',
+          source: 'github_acme',
+        },
+      ]),
+    );
+
+    const result = definitionResolvedEventSchema.parse({
+      definitionId: '019e98ab-6656-7ca1-b9ad-1ca4442c479d',
+      projectId: '019e98ab-b90f-7265-b13c-8b441c991381',
+      workspaceId: '019e98ab-b90f-7265-b13c-8b441c991382',
+      configPath: '.shipfox/workflows/ci.yml',
+      triggers: dto,
+    });
+
+    expect(result.triggers).toEqual({
+      on_any_github_event: {source: 'github_acme'},
+    });
+  });
+
   it('returns an empty object when the model has no triggers', () => {
     const model = workflowModelWithTriggers([]);
 

package/src/db/definition-triggers.ts

@@ -6,7 +6,7 @@ export function definitionTriggersFor(model: WorkflowModel): Record<string, Trig
     model.triggers.map((trigger) => {
       const dto: TriggerDto = {
         source: trigger.source,
-        event: trigger.event,
+        ...(trigger.event === undefined ? {} : {event: trigger.event}),
       };
       if (trigger.inputs !== undefined) dto.with = trigger.inputs;
       if (trigger.filter !== undefined) dto.filter = trigger.filter;

package/src/db/definitions.test.ts

@@ -15,7 +15,7 @@ import {
   registerPublisher as registerInRegistry,
   renewDispatchClaim as renewFromRegistry,
 } from '@shipfox/node-module';
-import {sql} from 'drizzle-orm';
+import {eq, sql} from 'drizzle-orm';
 import type {WorkflowDefinitionPayload} from '#core/entities/workflow-definition.js';
 import {normalizeWorkflowDocument} from '#core/workflow-model/index.js';
 import {agentValidationCatalog} from '#test/agent-validation-catalog.js';
@@ -30,6 +30,7 @@ import {
 } from './definitions.js';
 import {workflowDefinitions} from './schema/definitions.js';
 import {definitionsOutbox} from './schema/outbox.js';
+import {workflowWorkflows} from './schema/workflows.js';
 
 const MS_PER_DAY = 24 * 60 * 60 * 1_000;
 let outboxRegistry = createOutboxRegistry();
@@ -390,6 +391,289 @@ describe('definition queries', () => {
     });
   });
 
+  describe('workflow lineage', () => {
+    test('upsertDefinition creates a lineage and returns its workflowId', async () => {
+      const definition = await upsertDefinition({
+        projectId,
+        workspaceId,
+        configPath: '.shipfox/workflows/lineage.yml',
+        name: 'Lineage',
+        ...definitionFields('Lineage'),
+        source: 'vcs',
+        ref: 'main',
+      });
+
+      expect(definition.workflowId).toBeDefined();
+      const lineages = await db()
+        .select()
+        .from(workflowWorkflows)
+        .where(eq(workflowWorkflows.projectId, projectId));
+      expect(lineages).toHaveLength(1);
+      expect(lineages[0]?.id).toBe(definition.workflowId);
+      expect(lineages[0]?.configPath).toBe('.shipfox/workflows/lineage.yml');
+    });
+
+    test('re-syncing the same config path reuses the lineage', async () => {
+      const first = await upsertDefinition({
+        projectId,
+        workspaceId,
+        configPath: 'a.yml',
+        name: 'A v1',
+        ...definitionFields('A v1'),
+        source: 'vcs',
+        ref: 'main',
+      });
+
+      const second = await upsertDefinition({
+        projectId,
+        workspaceId,
+        configPath: 'a.yml',
+        name: 'A v2',
+        ...definitionFields('A v2'),
+        source: 'vcs',
+        ref: 'main',
+      });
+
+      expect(second.workflowId).toBe(first.workflowId);
+      const lineages = await db()
+        .select()
+        .from(workflowWorkflows)
+        .where(eq(workflowWorkflows.projectId, projectId));
+      expect(lineages).toHaveLength(1);
+    });
+
+    test('manual and VCS rows at the same config path share one lineage', async () => {
+      const manual = await upsertDefinition({
+        projectId,
+        workspaceId,
+        configPath: 'shared.yml',
+        name: 'Shared manual',
+        ...definitionFields('Shared manual'),
+      });
+      const vcs = await upsertDefinition({
+        projectId,
+        workspaceId,
+        configPath: 'shared.yml',
+        name: 'Shared vcs',
+        ...definitionFields('Shared vcs'),
+        source: 'vcs',
+        ref: 'main',
+      });
+
+      expect(vcs.workflowId).toBe(manual.workflowId);
+    });
+
+    test('applyVcsDefinitionsBatch creates the lineage and reuses it across syncs', async () => {
+      await applyVcsDefinitionsBatch({
+        projectId,
+        workspaceId,
+        ref: 'main',
+        upserts: [
+          {
+            configPath: 'batch.yml',
+            name: 'Batch',
+            ...definitionFields('Batch'),
+            contentHash: 'h-1',
+          },
+        ],
+      });
+      const firstLineages = await db()
+        .select()
+        .from(workflowWorkflows)
+        .where(eq(workflowWorkflows.projectId, projectId));
+      expect(firstLineages).toHaveLength(1);
+
+      await applyVcsDefinitionsBatch({
+        projectId,
+        workspaceId,
+        ref: 'main',
+        upserts: [
+          {
+            configPath: 'batch.yml',
+            name: 'Batch v2',
+            ...definitionFields('Batch v2'),
+            contentHash: 'h-2',
+          },
+        ],
+      });
+      const secondLineages = await db()
+        .select()
+        .from(workflowWorkflows)
+        .where(eq(workflowWorkflows.projectId, projectId));
+      expect(secondLineages).toHaveLength(1);
+      expect(secondLineages[0]?.id).toBe(firstLineages[0]?.id);
+    });
+
+    test('soft-deleting a synced row keeps the lineage', async () => {
+      await applyVcsDefinitionsBatch({
+        projectId,
+        workspaceId,
+        ref: 'main',
+        upserts: [
+          {configPath: 'gone.yml', name: 'Gone', ...definitionFields('Gone'), contentHash: 'h-1'},
+        ],
+      });
+
+      const deletedCount = await softDeleteVcsDefinitionsNotIn({
+        projectId,
+        workspaceId,
+        ref: 'main',
+        keepConfigPaths: [],
+      });
+
+      expect(deletedCount).toBe(1);
+      const lineages = await db()
+        .select()
+        .from(workflowWorkflows)
+        .where(eq(workflowWorkflows.projectId, projectId));
+      expect(lineages).toHaveLength(1);
+      expect(lineages[0]?.configPath).toBe('gone.yml');
+    });
+
+    test('pathless manual definitions reuse the project lineage across saves', async () => {
+      const first = await upsertDefinition({
+        projectId,
+        workspaceId,
+        name: 'No path',
+        ...definitionFields('No path'),
+      });
+      const second = await upsertDefinition({
+        projectId,
+        workspaceId,
+        name: 'No path updated',
+        ...definitionFields('No path updated'),
+      });
+
+      const lineage = await db()
+        .select()
+        .from(workflowWorkflows)
+        .where(eq(workflowWorkflows.id, first.workflowId));
+      expect(lineage).toHaveLength(1);
+      expect(lineage[0]?.projectId).toBe(projectId);
+      expect(second.workflowId).toBe(first.workflowId);
+
+      const projectLineages = await db()
+        .select()
+        .from(workflowWorkflows)
+        .where(eq(workflowWorkflows.projectId, projectId));
+      expect(projectLineages).toHaveLength(1);
+    });
+
+    test('materializes a legacy row when it is read', async () => {
+      const legacyId = crypto.randomUUID();
+      await db()
+        .insert(workflowDefinitions)
+        .values({
+          id: legacyId,
+          projectId,
+          configPath: 'legacy.yml',
+          name: 'Legacy',
+          definition: definitionFields('Legacy'),
+        });
+
+      const definition = await getDefinitionById(legacyId);
+
+      expect(definition?.workflowId).toBeDefined();
+      const stored = await db()
+        .select({workflowId: workflowDefinitions.workflowId})
+        .from(workflowDefinitions)
+        .where(eq(workflowDefinitions.id, legacyId));
+      expect(stored[0]?.workflowId).toBe(definition?.workflowId);
+
+      const lineages = await db()
+        .select()
+        .from(workflowWorkflows)
+        .where(eq(workflowWorkflows.projectId, projectId));
+      expect(lineages).toHaveLength(1);
+      expect(lineages[0]?.configPath).toBe('legacy.yml');
+    });
+
+    test('materializes legacy pathless rows into one project lineage', async () => {
+      const firstId = crypto.randomUUID();
+      const secondId = crypto.randomUUID();
+      await db()
+        .insert(workflowDefinitions)
+        .values([
+          {
+            id: firstId,
+            projectId,
+            configPath: null,
+            name: 'Legacy one',
+            definition: definitionFields('Legacy one'),
+          },
+          {
+            id: secondId,
+            projectId,
+            configPath: null,
+            name: 'Legacy two',
+            definition: definitionFields('Legacy two'),
+          },
+        ]);
+
+      const definitions = await listDefinitionsByProject(projectId);
+
+      expect(definitions).toHaveLength(2);
+      expect(definitions[0]?.workflowId).toBe(definitions[1]?.workflowId);
+      const lineages = await db()
+        .select()
+        .from(workflowWorkflows)
+        .where(eq(workflowWorkflows.projectId, projectId));
+      expect(lineages).toHaveLength(1);
+      expect(lineages[0]?.configPath).toBeNull();
+    });
+
+    test('materializes an unchanged legacy VCS row during sync', async () => {
+      const legacyId = crypto.randomUUID();
+      await db()
+        .insert(workflowDefinitions)
+        .values({
+          id: legacyId,
+          projectId,
+          configPath: 'legacy-vcs.yml',
+          source: 'vcs',
+          ref: 'main',
+          name: 'Legacy VCS',
+          definition: definitionFields('Legacy VCS'),
+          contentHash: 'legacy-hash',
+        });
+
+      const result = await applyVcsDefinitionsBatch({
+        projectId,
+        workspaceId,
+        ref: 'main',
+        upserts: [
+          {
+            configPath: 'legacy-vcs.yml',
+            name: 'Legacy VCS',
+            ...definitionFields('Legacy VCS'),
+            contentHash: 'legacy-hash',
+          },
+        ],
+      });
+
+      expect(result.appliedCount).toBe(0);
+      const stored = await db()
+        .select({workflowId: workflowDefinitions.workflowId})
+        .from(workflowDefinitions)
+        .where(eq(workflowDefinitions.id, legacyId));
+      expect(stored[0]?.workflowId).toBeDefined();
+    });
+
+    test('getDefinitionById returns the workflowId', async () => {
+      const created = await upsertDefinition({
+        projectId,
+        workspaceId,
+        configPath: 'found.yml',
+        name: 'Found',
+        ...definitionFields('Found'),
+      });
+
+      const found = await getDefinitionById(created.id);
+
+      expect(found?.workflowId).toBe(created.workflowId);
+    });
+  });
+
   describe('getDefinitionById', () => {
     test('returns the definition when found', async () => {
       const created = await upsertDefinition({
@@ -519,6 +803,7 @@ describe('definition queries', () => {
       });
 
       expect(restored.id).toBe(original.id);
+      expect(restored.workflowId).toBe(original.workflowId);
       expect(restored.name).toBe('Recovered v2');
       expect(restored.deletedAt).toBeNull();
       const visible = await listDefinitionsByProject(projectId);
@@ -573,6 +858,11 @@ describe('definition queries', () => {
       expect(first.appliedCount).toBe(2);
       expect(await listOutboxRowsForProject(projectId)).toHaveLength(2);
 
+      await db()
+        .update(workflowDefinitions)
+        .set({fetchedAt: new Date(0), updatedAt: new Date(0)})
+        .where(eq(workflowDefinitions.projectId, projectId));
+
       const second = await applyVcsDefinitionsBatch({
         projectId,
         workspaceId,
@@ -585,6 +875,15 @@ describe('definition queries', () => {
 
       expect(second.appliedCount).toBe(1);
       expect(await listOutboxRowsForProject(projectId)).toHaveLength(3);
+
+      const refreshed = (
+        await db()
+          .select()
+          .from(workflowDefinitions)
+          .where(eq(workflowDefinitions.projectId, projectId))
+      ).find((row) => row.configPath === 'a.yml');
+      expect(refreshed?.fetchedAt.getTime()).toBeGreaterThan(0);
+      expect(refreshed?.updatedAt.getTime()).toBeGreaterThan(0);
     });
 
     test('softDeleteVcsDefinitionsNotIn writes a DEFINITION_DELETED event per pruned row', async () => {