@shipfox/api-definitions 13.1.0 → 14.0.0

package/dist/db/db.d.ts

@@ -21,6 +21,23 @@ export declare const schema: {
                 identity: undefined;
                 generated: undefined;
             }, {}, {}>;
+            workflowId: import("drizzle-orm/pg-core").PgColumn<{
+                name: "workflow_id";
+                tableName: "workflow_definitions";
+                dataType: "string";
+                columnType: "PgUUID";
+                data: string;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
             projectId: import("drizzle-orm/pg-core").PgColumn<{
                 name: "project_id";
                 tableName: "workflow_definitions";
@@ -569,7 +586,9 @@ export declare const schema: {
                 tableName: "sync_states";
                 dataType: "json";
                 columnType: "PgJsonb";
-                data: import("../core/validate-definition.js").ValidationWarning[];
+                data: (Omit<import("../core/index.js").DefinitionSyncDiagnostic, "severity"> & {
+                    severity?: import("../core/index.js").DefinitionSyncDiagnostic['severity'];
+                })[];
                 driverParam: unknown;
                 notNull: true;
                 hasDefault: true;
@@ -581,7 +600,9 @@ export declare const schema: {
                 identity: undefined;
                 generated: undefined;
             }, {}, {
-                $type: import("../core/validate-definition.js").ValidationWarning[];
+                $type: (Omit<import("../core/index.js").DefinitionSyncDiagnostic, "severity"> & {
+                    severity?: import("../core/index.js").DefinitionSyncDiagnostic['severity'];
+                })[];
             }>;
             startedAt: import("drizzle-orm/pg-core").PgColumn<{
                 name: "started_at";
@@ -654,6 +675,81 @@ export declare const schema: {
         };
         dialect: 'pg';
     }>;
+    workflowWorkflows: import("drizzle-orm/pg-core").PgTableWithColumns<{
+        name: "workflows";
+        schema: undefined;
+        columns: {
+            id: import("drizzle-orm/pg-core").PgColumn<{
+                name: "id";
+                tableName: "workflows";
+                dataType: "string";
+                columnType: "PgUUID";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: true;
+                isPrimaryKey: true;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            projectId: import("drizzle-orm/pg-core").PgColumn<{
+                name: "project_id";
+                tableName: "workflows";
+                dataType: "string";
+                columnType: "PgUUID";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            configPath: import("drizzle-orm/pg-core").PgColumn<{
+                name: "config_path";
+                tableName: "workflows";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            createdAt: import("drizzle-orm/pg-core").PgColumn<{
+                name: "created_at";
+                tableName: "workflows";
+                dataType: "date";
+                columnType: "PgTimestamp";
+                data: Date;
+                driverParam: string;
+                notNull: true;
+                hasDefault: true;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+        };
+        dialect: 'pg';
+    }>;
 };
 export declare function db(): NodePgDatabase<{
     workflowDefinitions: import("drizzle-orm/pg-core").PgTableWithColumns<{
@@ -677,6 +773,23 @@ export declare function db(): NodePgDatabase<{
                 identity: undefined;
                 generated: undefined;
             }, {}, {}>;
+            workflowId: import("drizzle-orm/pg-core").PgColumn<{
+                name: "workflow_id";
+                tableName: "workflow_definitions";
+                dataType: "string";
+                columnType: "PgUUID";
+                data: string;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
             projectId: import("drizzle-orm/pg-core").PgColumn<{
                 name: "project_id";
                 tableName: "workflow_definitions";
@@ -1225,7 +1338,9 @@ export declare function db(): NodePgDatabase<{
                 tableName: "sync_states";
                 dataType: "json";
                 columnType: "PgJsonb";
-                data: import("../core/validate-definition.js").ValidationWarning[];
+                data: (Omit<import("../core/index.js").DefinitionSyncDiagnostic, "severity"> & {
+                    severity?: import("../core/index.js").DefinitionSyncDiagnostic['severity'];
+                })[];
                 driverParam: unknown;
                 notNull: true;
                 hasDefault: true;
@@ -1237,7 +1352,9 @@ export declare function db(): NodePgDatabase<{
                 identity: undefined;
                 generated: undefined;
             }, {}, {
-                $type: import("../core/validate-definition.js").ValidationWarning[];
+                $type: (Omit<import("../core/index.js").DefinitionSyncDiagnostic, "severity"> & {
+                    severity?: import("../core/index.js").DefinitionSyncDiagnostic['severity'];
+                })[];
             }>;
             startedAt: import("drizzle-orm/pg-core").PgColumn<{
                 name: "started_at";
@@ -1310,6 +1427,81 @@ export declare function db(): NodePgDatabase<{
         };
         dialect: 'pg';
     }>;
+    workflowWorkflows: import("drizzle-orm/pg-core").PgTableWithColumns<{
+        name: "workflows";
+        schema: undefined;
+        columns: {
+            id: import("drizzle-orm/pg-core").PgColumn<{
+                name: "id";
+                tableName: "workflows";
+                dataType: "string";
+                columnType: "PgUUID";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: true;
+                isPrimaryKey: true;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            projectId: import("drizzle-orm/pg-core").PgColumn<{
+                name: "project_id";
+                tableName: "workflows";
+                dataType: "string";
+                columnType: "PgUUID";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            configPath: import("drizzle-orm/pg-core").PgColumn<{
+                name: "config_path";
+                tableName: "workflows";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            createdAt: import("drizzle-orm/pg-core").PgColumn<{
+                name: "created_at";
+                tableName: "workflows";
+                dataType: "date";
+                columnType: "PgTimestamp";
+                data: Date;
+                driverParam: string;
+                notNull: true;
+                hasDefault: true;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+        };
+        dialect: 'pg';
+    }>;
 }>;
 export declare function closeDb(): void;
 //# sourceMappingURL=db.d.ts.map

package/dist/db/db.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"db.d.ts","sourceRoot":"","sources":["../../src/db/db.ts"],"names":[],"mappings":"AAAA,OAAO,EAAU,KAAK,cAAc,EAAC,MAAM,uBAAuB,CAAC;AAMnE,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAiE,CAAC;AAIrF,wBAAgB,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAGjB;AAED,wBAAgB,OAAO,IAAI,IAAI,CAE9B"}
+{"version":3,"file":"db.d.ts","sourceRoot":"","sources":["../../src/db/db.ts"],"names":[],"mappings":"AAAA,OAAO,EAAU,KAAK,cAAc,EAAC,MAAM,uBAAuB,CAAC;AAOnE,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAKlB,CAAC;AAIF,wBAAgB,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAGjB;AAED,wBAAgB,OAAO,IAAI,IAAI,CAE9B"}

package/dist/db/db.js

@@ -3,10 +3,12 @@ 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
+    definitionSyncStates,
+    workflowWorkflows
 };
 let _db;
 export function db() {

package/dist/db/db.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/db/db.ts"],"sourcesContent":["import {drizzle, type NodePgDatabase} from '@shipfox/node-drizzle';\nimport {pgClient} from '@shipfox/node-postgres';\nimport {workflowDefinitions} from './schema/definitions.js';\nimport {definitionsOutbox} from './schema/outbox.js';\nimport {definitionSyncStates} from './schema/sync-states.js';\n\nexport const schema = {workflowDefinitions, definitionsOutbox, definitionSyncStates};\n\nlet _db: NodePgDatabase<typeof schema> | undefined;\n\nexport function db() {\n  if (!_db) _db = drizzle(pgClient(), {schema});\n  return _db;\n}\n\nexport function closeDb(): void {\n  _db = undefined;\n}\n"],"names":["drizzle","pgClient","workflowDefinitions","definitionsOutbox","definitionSyncStates","schema","_db","db","closeDb","undefined"],"mappings":"AAAA,SAAQA,OAAO,QAA4B,wBAAwB;AACnE,SAAQC,QAAQ,QAAO,yBAAyB;AAChD,SAAQC,mBAAmB,QAAO,0BAA0B;AAC5D,SAAQC,iBAAiB,QAAO,qBAAqB;AACrD,SAAQC,oBAAoB,QAAO,0BAA0B;AAE7D,OAAO,MAAMC,SAAS;IAACH;IAAqBC;IAAmBC;AAAoB,EAAE;AAErF,IAAIE;AAEJ,OAAO,SAASC;IACd,IAAI,CAACD,KAAKA,MAAMN,QAAQC,YAAY;QAACI;IAAM;IAC3C,OAAOC;AACT;AAEA,OAAO,SAASE;IACdF,MAAMG;AACR"}
+{"version":3,"sources":["../../src/db/db.ts"],"sourcesContent":["import {drizzle, type NodePgDatabase} from '@shipfox/node-drizzle';\nimport {pgClient} from '@shipfox/node-postgres';\nimport {workflowDefinitions} from './schema/definitions.js';\nimport {definitionsOutbox} from './schema/outbox.js';\nimport {definitionSyncStates} from './schema/sync-states.js';\nimport {workflowWorkflows} from './schema/workflows.js';\n\nexport const schema = {\n  workflowDefinitions,\n  definitionsOutbox,\n  definitionSyncStates,\n  workflowWorkflows,\n};\n\nlet _db: NodePgDatabase<typeof schema> | undefined;\n\nexport function db() {\n  if (!_db) _db = drizzle(pgClient(), {schema});\n  return _db;\n}\n\nexport function closeDb(): void {\n  _db = undefined;\n}\n"],"names":["drizzle","pgClient","workflowDefinitions","definitionsOutbox","definitionSyncStates","workflowWorkflows","schema","_db","db","closeDb","undefined"],"mappings":"AAAA,SAAQA,OAAO,QAA4B,wBAAwB;AACnE,SAAQC,QAAQ,QAAO,yBAAyB;AAChD,SAAQC,mBAAmB,QAAO,0BAA0B;AAC5D,SAAQC,iBAAiB,QAAO,qBAAqB;AACrD,SAAQC,oBAAoB,QAAO,0BAA0B;AAC7D,SAAQC,iBAAiB,QAAO,wBAAwB;AAExD,OAAO,MAAMC,SAAS;IACpBJ;IACAC;IACAC;IACAC;AACF,EAAE;AAEF,IAAIE;AAEJ,OAAO,SAASC;IACd,IAAI,CAACD,KAAKA,MAAMP,QAAQC,YAAY;QAACK;IAAM;IAC3C,OAAOC;AACT;AAEA,OAAO,SAASE;IACdF,MAAMG;AACR"}

package/dist/db/definition-triggers.js

@@ -2,7 +2,9 @@ export function definitionTriggersFor(model) {
     return Object.fromEntries(model.triggers.map((trigger)=>{
         const dto = {
             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/dist/db/definition-triggers.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/db/definition-triggers.ts"],"sourcesContent":["import type {TriggerDto} from '@shipfox/api-definitions-dto';\nimport type {WorkflowModel} from '#core/entities/workflow-model.js';\n\nexport function definitionTriggersFor(model: WorkflowModel): Record<string, TriggerDto> {\n  return Object.fromEntries(\n    model.triggers.map((trigger) => {\n      const dto: TriggerDto = {\n        source: trigger.source,\n        event: trigger.event,\n      };\n      if (trigger.inputs !== undefined) dto.with = trigger.inputs;\n      if (trigger.filter !== undefined) dto.filter = trigger.filter;\n      if (trigger.config !== undefined) dto.config = trigger.config;\n      return [trigger.key, dto];\n    }),\n  );\n}\n"],"names":["definitionTriggersFor","model","Object","fromEntries","triggers","map","trigger","dto","source","event","inputs","undefined","with","filter","config","key"],"mappings":"AAGA,OAAO,SAASA,sBAAsBC,KAAoB;IACxD,OAAOC,OAAOC,WAAW,CACvBF,MAAMG,QAAQ,CAACC,GAAG,CAAC,CAACC;QAClB,MAAMC,MAAkB;YACtBC,QAAQF,QAAQE,MAAM;YACtBC,OAAOH,QAAQG,KAAK;QACtB;QACA,IAAIH,QAAQI,MAAM,KAAKC,WAAWJ,IAAIK,IAAI,GAAGN,QAAQI,MAAM;QAC3D,IAAIJ,QAAQO,MAAM,KAAKF,WAAWJ,IAAIM,MAAM,GAAGP,QAAQO,MAAM;QAC7D,IAAIP,QAAQQ,MAAM,KAAKH,WAAWJ,IAAIO,MAAM,GAAGR,QAAQQ,MAAM;QAC7D,OAAO;YAACR,QAAQS,GAAG;YAAER;SAAI;IAC3B;AAEJ"}
+{"version":3,"sources":["../../src/db/definition-triggers.ts"],"sourcesContent":["import type {TriggerDto} from '@shipfox/api-definitions-dto';\nimport type {WorkflowModel} from '#core/entities/workflow-model.js';\n\nexport function definitionTriggersFor(model: WorkflowModel): Record<string, TriggerDto> {\n  return Object.fromEntries(\n    model.triggers.map((trigger) => {\n      const dto: TriggerDto = {\n        source: trigger.source,\n        ...(trigger.event === undefined ? {} : {event: trigger.event}),\n      };\n      if (trigger.inputs !== undefined) dto.with = trigger.inputs;\n      if (trigger.filter !== undefined) dto.filter = trigger.filter;\n      if (trigger.config !== undefined) dto.config = trigger.config;\n      return [trigger.key, dto];\n    }),\n  );\n}\n"],"names":["definitionTriggersFor","model","Object","fromEntries","triggers","map","trigger","dto","source","event","undefined","inputs","with","filter","config","key"],"mappings":"AAGA,OAAO,SAASA,sBAAsBC,KAAoB;IACxD,OAAOC,OAAOC,WAAW,CACvBF,MAAMG,QAAQ,CAACC,GAAG,CAAC,CAACC;QAClB,MAAMC,MAAkB;YACtBC,QAAQF,QAAQE,MAAM;YACtB,GAAIF,QAAQG,KAAK,KAAKC,YAAY,CAAC,IAAI;gBAACD,OAAOH,QAAQG,KAAK;YAAA,CAAC;QAC/D;QACA,IAAIH,QAAQK,MAAM,KAAKD,WAAWH,IAAIK,IAAI,GAAGN,QAAQK,MAAM;QAC3D,IAAIL,QAAQO,MAAM,KAAKH,WAAWH,IAAIM,MAAM,GAAGP,QAAQO,MAAM;QAC7D,IAAIP,QAAQQ,MAAM,KAAKJ,WAAWH,IAAIO,MAAM,GAAGR,QAAQQ,MAAM;QAC7D,OAAO;YAACR,QAAQS,GAAG;YAAER;SAAI;IAC3B;AAEJ"}

package/dist/db/definitions.d.ts

@@ -15,7 +15,24 @@ export interface UpsertDefinitionParams {
     ref?: string | undefined;
 }
 export declare function upsertDefinition(params: UpsertDefinitionParams): Promise<WorkflowDefinition>;
+/**
+ * Finds or creates the workflow lineage for (projectId, configPath) outside a
+ * sync. A dev definition uses the lineage for run numbering without ever
+ * persisting a definition row or publishing a resolution event.
+ */
+export declare function findOrCreateWorkflowLineage(params: {
+    projectId: string;
+    configPath: string;
+}): Promise<string>;
 export declare function getDefinitionById(id: string): Promise<WorkflowDefinition | undefined>;
+export declare function getWorkflowLineageById(id: string): Promise<{
+    id: string;
+    projectId: string;
+} | undefined>;
+export declare function getDefinitionByWorkflowId(params: {
+    workflowId: string;
+    ref: string;
+}): Promise<WorkflowDefinition | undefined>;
 export interface DefinitionCursor {
     value: string;
     id: string;

package/dist/db/definitions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"definitions.d.ts","sourceRoot":"","sources":["../../src/db/definitions.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"definitions.d.ts","sourceRoot":"","sources":["../../src/db/definitions.ts"],"names":[],"mappings":"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"}

package/dist/db/definitions.js

@@ -1,10 +1,105 @@
 import { DEFINITION_DELETED, DEFINITION_RESOLVED } from '@shipfox/api-definitions-dto';
 import { writeOutboxEvent } from '@shipfox/node-outbox';
-import { and, asc, eq, gt, isNull, notInArray, or, sql } from 'drizzle-orm';
+import { and, asc, eq, gt, inArray, isNotNull, isNull, notInArray, or, sql } from 'drizzle-orm';
 import { db } from './db.js';
 import { definitionTriggersFor } from './definition-triggers.js';
 import { toDefinition, workflowDefinitions } from './schema/definitions.js';
 import { definitionsOutbox } from './schema/outbox.js';
+import { workflowWorkflows } from './schema/workflows.js';
+/**
+ * Finds or creates the workflow lineage for (projectId, configPath) and returns
+ * its id. Pathless manual definitions share a project-scoped lineage because
+ * their request has no more specific stable key.
+ */ async function findOrCreateWorkflow(tx, params) {
+    if (params.configPath === null) {
+        // Serialize the first pathless definition for a project so concurrent saves
+        // cannot create multiple project-scoped lineages.
+        await tx.execute(sql`SELECT pg_advisory_xact_lock(hashtextextended(${params.projectId}, 0))`);
+        const existing = await tx.select({
+            workflowId: workflowDefinitions.workflowId
+        }).from(workflowDefinitions).where(and(eq(workflowDefinitions.projectId, params.projectId), isNull(workflowDefinitions.configPath), eq(workflowDefinitions.source, 'manual'), isNotNull(workflowDefinitions.workflowId))).orderBy(asc(workflowDefinitions.createdAt), asc(workflowDefinitions.id)).limit(1);
+        const existingRow = existing[0];
+        if (existingRow?.workflowId) return existingRow.workflowId;
+        const inserted = await tx.insert(workflowWorkflows).values({
+            projectId: params.projectId,
+            configPath: null
+        }).onConflictDoNothing().returning({
+            id: workflowWorkflows.id
+        });
+        const insertedRow = inserted[0];
+        if (insertedRow) return insertedRow.id;
+        const existingLineage = await tx.select({
+            id: workflowWorkflows.id
+        }).from(workflowWorkflows).where(and(eq(workflowWorkflows.projectId, params.projectId), isNull(workflowWorkflows.configPath))).limit(1);
+        const existingLineageRow = existingLineage[0];
+        if (!existingLineageRow) {
+            throw new Error(`Pathless workflow lineage missing for project ${params.projectId}`);
+        }
+        return existingLineageRow.id;
+    }
+    const inserted = await tx.insert(workflowWorkflows).values({
+        projectId: params.projectId,
+        configPath: params.configPath
+    }).onConflictDoNothing().returning({
+        id: workflowWorkflows.id
+    });
+    const insertedRow = inserted[0];
+    if (insertedRow) return insertedRow.id;
+    const existing = await tx.select({
+        id: workflowWorkflows.id
+    }).from(workflowWorkflows).where(and(eq(workflowWorkflows.projectId, params.projectId), eq(workflowWorkflows.configPath, params.configPath))).limit(1);
+    const existingRow = existing[0];
+    if (!existingRow) {
+        throw new Error(`Workflow lineage upsert returned no row for project ${params.projectId} and config path ${params.configPath}`);
+    }
+    return existingRow.id;
+}
+async function findOrCreateWorkflows(tx, params) {
+    const configPaths = [
+        ...new Set(params.configPaths)
+    ].sort((left, right)=>left < right ? -1 : left > right ? 1 : 0);
+    if (configPaths.length === 0) return new Map();
+    await tx.insert(workflowWorkflows).values(configPaths.map((configPath)=>({
+            projectId: params.projectId,
+            configPath
+        }))).onConflictDoNothing();
+    const rows = await tx.select({
+        id: workflowWorkflows.id,
+        configPath: workflowWorkflows.configPath
+    }).from(workflowWorkflows).where(and(eq(workflowWorkflows.projectId, params.projectId), inArray(workflowWorkflows.configPath, configPaths)));
+    const workflowIds = new Map();
+    for (const row of rows){
+        if (row.configPath !== null) workflowIds.set(row.configPath, row.id);
+    }
+    for (const configPath of configPaths){
+        if (!workflowIds.has(configPath)) {
+            throw new Error(`Workflow lineage upsert returned no row for project ${params.projectId} and config path ${configPath}`);
+        }
+    }
+    return workflowIds;
+}
+async function ensureWorkflowId(tx, row) {
+    if (row.workflowId !== null) return row.workflowId;
+    const workflowId = await findOrCreateWorkflow(tx, {
+        projectId: row.projectId,
+        configPath: row.configPath
+    });
+    const updated = await tx.update(workflowDefinitions).set({
+        workflowId
+    }).where(and(eq(workflowDefinitions.id, row.id), isNull(workflowDefinitions.workflowId))).returning({
+        workflowId: workflowDefinitions.workflowId
+    });
+    const updatedRow = updated[0];
+    if (updatedRow?.workflowId) return updatedRow.workflowId;
+    const current = await tx.select({
+        workflowId: workflowDefinitions.workflowId
+    }).from(workflowDefinitions).where(eq(workflowDefinitions.id, row.id)).limit(1);
+    const currentRow = current[0];
+    if (!currentRow?.workflowId) {
+        throw new Error(`Definition ${row.id} still has no workflow lineage after reconciliation`);
+    }
+    return currentRow.workflowId;
+}
 function buildUpsertQuery(tx, params) {
     const source = params.source ?? 'manual';
     if (source === 'vcs' && !params.configPath) {
@@ -22,6 +117,7 @@ function buildUpsertQuery(tx, params) {
         sourceSnapshot: params.sourceSnapshot ?? null
     };
     const set = {
+        workflowId: params.workflowId,
         name: params.name,
         source,
         definition,
@@ -32,6 +128,7 @@ function buildUpsertQuery(tx, params) {
     };
     const values = {
         projectId: params.projectId,
+        workflowId: params.workflowId,
         configPath: params.configPath ?? null,
         source,
         sha: params.sha ?? null,
@@ -73,7 +170,14 @@ function buildUpsertQuery(tx, params) {
 }
 export async function upsertDefinition(params) {
     return await db().transaction(async (tx)=>{
-        const rows = await buildUpsertQuery(tx, params);
+        const workflowId = await findOrCreateWorkflow(tx, {
+            projectId: params.projectId,
+            configPath: params.configPath ?? null
+        });
+        const rows = await buildUpsertQuery(tx, {
+            ...params,
+            workflowId
+        });
         const row = rows[0];
         if (!row) throw new Error('Upsert returned no rows');
         await writeOutboxEvent(tx, definitionsOutbox, {
@@ -89,34 +193,76 @@ export async function upsertDefinition(params) {
         return toDefinition(row);
     });
 }
+/**
+ * Finds or creates the workflow lineage for (projectId, configPath) outside a
+ * sync. A dev definition uses the lineage for run numbering without ever
+ * persisting a definition row or publishing a resolution event.
+ */ export async function findOrCreateWorkflowLineage(params) {
+    return await db().transaction(async (tx)=>{
+        return await findOrCreateWorkflow(tx, params);
+    });
+}
 export async function getDefinitionById(id) {
-    const rows = await db().select().from(workflowDefinitions).where(and(eq(workflowDefinitions.id, id), isNull(workflowDefinitions.deletedAt))).limit(1);
+    return await db().transaction(async (tx)=>{
+        const rows = await tx.select().from(workflowDefinitions).where(and(eq(workflowDefinitions.id, id), isNull(workflowDefinitions.deletedAt))).limit(1);
+        const row = rows[0];
+        if (row) {
+            const workflowId = await ensureWorkflowId(tx, row);
+            return toDefinition({
+                ...row,
+                workflowId
+            });
+        }
+        return undefined;
+    });
+}
+export async function getWorkflowLineageById(id) {
+    const rows = await db().select({
+        id: workflowWorkflows.id,
+        projectId: workflowWorkflows.projectId
+    }).from(workflowWorkflows).where(eq(workflowWorkflows.id, id)).limit(1);
+    return rows[0];
+}
+export async function getDefinitionByWorkflowId(params) {
+    const rows = await db().select().from(workflowDefinitions).where(and(eq(workflowDefinitions.workflowId, params.workflowId), eq(workflowDefinitions.ref, params.ref), isNull(workflowDefinitions.deletedAt))).limit(1);
     const row = rows[0];
-    if (!row) return undefined;
-    return toDefinition(row);
+    return row ? toDefinition({
+        ...row,
+        workflowId: params.workflowId
+    }) : undefined;
 }
 function cursorWhere(cursor) {
     if (!cursor) return undefined;
     return or(gt(workflowDefinitions.name, cursor.value), and(eq(workflowDefinitions.name, cursor.value), gt(workflowDefinitions.id, cursor.id)));
 }
 export async function listDefinitions(params) {
-    const conditions = [
-        eq(workflowDefinitions.projectId, params.projectId),
-        isNull(workflowDefinitions.deletedAt)
-    ];
-    const cursorCondition = cursorWhere(params.cursor);
-    if (cursorCondition) conditions.push(cursorCondition);
-    const rows = await db().select().from(workflowDefinitions).where(and(...conditions)).orderBy(asc(workflowDefinitions.name), asc(workflowDefinitions.id)).limit(params.limit + 1);
-    const hasMore = rows.length > params.limit;
-    const pageRows = hasMore ? rows.slice(0, params.limit) : rows;
-    const last = pageRows.at(-1);
-    return {
-        definitions: pageRows.map(toDefinition),
-        nextCursor: hasMore && last ? {
-            value: last.name,
-            id: last.id
-        } : null
-    };
+    return await db().transaction(async (tx)=>{
+        const conditions = [
+            eq(workflowDefinitions.projectId, params.projectId),
+            isNull(workflowDefinitions.deletedAt)
+        ];
+        const cursorCondition = cursorWhere(params.cursor);
+        if (cursorCondition) conditions.push(cursorCondition);
+        const rows = await tx.select().from(workflowDefinitions).where(and(...conditions)).orderBy(asc(workflowDefinitions.name), asc(workflowDefinitions.id)).limit(params.limit + 1);
+        const hasMore = rows.length > params.limit;
+        const pageRows = hasMore ? rows.slice(0, params.limit) : rows;
+        const last = pageRows.at(-1);
+        const definitions = [];
+        for (const row of pageRows){
+            const workflowId = await ensureWorkflowId(tx, row);
+            definitions.push(toDefinition({
+                ...row,
+                workflowId
+            }));
+        }
+        return {
+            definitions,
+            nextCursor: hasMore && last ? {
+                value: last.name,
+                id: last.id
+            } : null
+        };
+    });
 }
 export async function listDefinitionsByProject(projectId) {
     const result = await listDefinitions({
@@ -153,16 +299,37 @@ export async function softDeleteVcsDefinitionsNotIn(params) {
 export async function applyVcsDefinitionsBatch(params) {
     return await db().transaction(async (tx)=>{
         let appliedCount = 0;
+        const prepared = [];
         for (const item of params.upserts){
             const existing = await tx.select({
                 contentHash: workflowDefinitions.contentHash,
-                deletedAt: workflowDefinitions.deletedAt
+                deletedAt: workflowDefinitions.deletedAt,
+                workflowId: workflowDefinitions.workflowId
             }).from(workflowDefinitions).where(and(eq(workflowDefinitions.projectId, params.projectId), eq(workflowDefinitions.ref, params.ref), eq(workflowDefinitions.configPath, item.configPath))).limit(1);
             const previous = existing[0];
             const unchanged = previous !== undefined && previous.deletedAt === null && previous.contentHash === item.contentHash;
+            prepared.push({
+                item,
+                unchanged,
+                workflowId: previous?.workflowId
+            });
+        }
+        const workflowIds = await findOrCreateWorkflows(tx, {
+            projectId: params.projectId,
+            configPaths: prepared.filter(({ unchanged })=>!unchanged).map(({ item })=>item.configPath)
+        });
+        for (const { item, unchanged, workflowId: previousWorkflowId } of prepared){
+            const workflowId = unchanged ? previousWorkflowId ?? await findOrCreateWorkflow(tx, {
+                projectId: params.projectId,
+                configPath: item.configPath
+            }) : workflowIds.get(item.configPath);
+            if (!workflowId) {
+                throw new Error(`Workflow lineage missing for project ${params.projectId} and config path ${item.configPath}`);
+            }
             const rows = await buildUpsertQuery(tx, {
                 projectId: params.projectId,
                 workspaceId: params.workspaceId,
+                workflowId,
                 configPath: item.configPath,
                 source: 'vcs',
                 ref: params.ref,