@shipfox/api-definitions 2.0.0

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

@@ -0,0 +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"}

package/dist/db/db.js

@@ -0,0 +1,22 @@
+import { drizzle } from '@shipfox/node-drizzle';
+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';
+export const schema = {
+    workflowDefinitions,
+    definitionsOutbox,
+    definitionSyncStates
+};
+let _db;
+export function db() {
+    if (!_db) _db = drizzle(pgClient(), {
+        schema
+    });
+    return _db;
+}
+export function closeDb() {
+    _db = undefined;
+}
+
+//# sourceMappingURL=db.js.map

package/dist/db/db.js.map

@@ -0,0 +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"}

package/dist/db/definition-triggers.d.ts

@@ -0,0 +1,4 @@
+import type { TriggerDto } from '@shipfox/api-definitions-dto';
+import type { WorkflowModel } from '#core/entities/workflow-model.js';
+export declare function definitionTriggersFor(model: WorkflowModel): Record<string, TriggerDto>;
+//# sourceMappingURL=definition-triggers.d.ts.map

package/dist/db/definition-triggers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition-triggers.d.ts","sourceRoot":"","sources":["../../src/db/definition-triggers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,8BAA8B,CAAC;AAC7D,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,kCAAkC,CAAC;AAEpE,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,aAAa,GAAG,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAatF"}

package/dist/db/definition-triggers.js

@@ -0,0 +1,17 @@
+export function definitionTriggersFor(model) {
+    return Object.fromEntries(model.triggers.map((trigger)=>{
+        const dto = {
+            source: trigger.source,
+            event: trigger.event
+        };
+        if (trigger.inputs !== undefined) dto.with = trigger.inputs;
+        if (trigger.filter !== undefined) dto.filter = trigger.filter;
+        if (trigger.config !== undefined) dto.config = trigger.config;
+        return [
+            trigger.key,
+            dto
+        ];
+    }));
+}
+
+//# sourceMappingURL=definition-triggers.js.map

package/dist/db/definition-triggers.js.map

@@ -0,0 +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"}

package/dist/db/definitions.d.ts

@@ -0,0 +1,63 @@
+import type { WorkflowDocument } from '@shipfox/workflow-document';
+import type { WorkflowDefinition, WorkflowSourceSnapshot } from '#core/entities/workflow-definition.js';
+import type { WorkflowModel } from '#core/entities/workflow-model.js';
+export interface UpsertDefinitionParams {
+    projectId: string;
+    workspaceId: string;
+    configPath?: string | null | undefined;
+    source?: 'manual' | 'vcs' | undefined;
+    name: string;
+    document: WorkflowDocument;
+    model: WorkflowModel;
+    sourceSnapshot?: WorkflowSourceSnapshot | null | undefined;
+    contentHash?: string | null | undefined;
+    sha?: string | undefined;
+    ref?: string | undefined;
+}
+export declare function upsertDefinition(params: UpsertDefinitionParams): Promise<WorkflowDefinition>;
+export declare function getDefinitionById(id: string): Promise<WorkflowDefinition | undefined>;
+export interface DefinitionCursor {
+    value: string;
+    id: string;
+}
+export interface ListDefinitionsParams {
+    projectId: string;
+    limit: number;
+    cursor?: DefinitionCursor | undefined;
+}
+export interface ListDefinitionsResult {
+    definitions: WorkflowDefinition[];
+    nextCursor: DefinitionCursor | null;
+}
+export declare function listDefinitions(params: ListDefinitionsParams): Promise<ListDefinitionsResult>;
+export declare function listDefinitionsByProject(projectId: string): Promise<WorkflowDefinition[]>;
+export interface SoftDeleteVcsDefinitionsParams {
+    projectId: string;
+    workspaceId: string;
+    ref: string;
+    keepConfigPaths: string[];
+}
+export declare function softDeleteVcsDefinitionsNotIn(params: SoftDeleteVcsDefinitionsParams): Promise<number>;
+export interface ApplyVcsDefinitionsBatchParams {
+    projectId: string;
+    workspaceId: string;
+    ref: string;
+    upserts: Array<{
+        configPath: string;
+        name: string;
+        document: WorkflowDocument;
+        model: WorkflowModel;
+        sourceSnapshot?: WorkflowSourceSnapshot | null | undefined;
+        contentHash: string;
+    }>;
+}
+export interface ApplyVcsDefinitionsBatchResult {
+    appliedCount: number;
+    deletedCount: number;
+}
+export declare function applyVcsDefinitionsBatch(params: ApplyVcsDefinitionsBatchParams): Promise<ApplyVcsDefinitionsBatchResult>;
+export declare function invalidateCache(params: {
+    projectId: string;
+    ref: string;
+}): Promise<void>;
+//# sourceMappingURL=definitions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"definitions.d.ts","sourceRoot":"","sources":["../../src/db/definitions.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,4BAA4B,CAAC;AAEjE,OAAO,KAAK,EACV,kBAAkB,EAElB,sBAAsB,EACvB,MAAM,uCAAuC,CAAC;AAC/C,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,kCAAkC,CAAC;AAQpE,MAAM,WAAW,sBAAsB;IACrC,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IACvC,MAAM,CAAC,EAAE,QAAQ,GAAG,KAAK,GAAG,SAAS,CAAC;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,KAAK,EAAE,aAAa,CAAC;IACrB,cAAc,CAAC,EAAE,sBAAsB,GAAG,IAAI,GAAG,SAAS,CAAC;IAC3D,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IACxC,GAAG,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACzB,GAAG,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAC1B;AAsFD,wBAAsB,gBAAgB,CACpC,MAAM,EAAE,sBAAsB,GAC7B,OAAO,CAAC,kBAAkB,CAAC,CAmB7B;AAED,wBAAsB,iBAAiB,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,kBAAkB,GAAG,SAAS,CAAC,CAU3F;AAED,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,MAAM,CAAC;IACd,EAAE,EAAE,MAAM,CAAC;CACZ;AAED,MAAM,WAAW,qBAAqB;IACpC,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,gBAAgB,GAAG,SAAS,CAAC;CACvC;AAED,MAAM,WAAW,qBAAqB;IACpC,WAAW,EAAE,kBAAkB,EAAE,CAAC;IAClC,UAAU,EAAE,gBAAgB,GAAG,IAAI,CAAC;CACrC;AAUD,wBAAsB,eAAe,CACnC,MAAM,EAAE,qBAAqB,GAC5B,OAAO,CAAC,qBAAqB,CAAC,CAuBhC;AAED,wBAAsB,wBAAwB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,kBAAkB,EAAE,CAAC,CAG/F;AAED,MAAM,WAAW,8BAA8B;IAC7C,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,GAAG,EAAE,MAAM,CAAC;IACZ,eAAe,EAAE,MAAM,EAAE,CAAC;CAC3B;AAsCD,wBAAsB,6BAA6B,CACjD,MAAM,EAAE,8BAA8B,GACrC,OAAO,CAAC,MAAM,CAAC,CAEjB;AAED,MAAM,WAAW,8BAA8B;IAC7C,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,KAAK,CAAC;QACb,UAAU,EAAE,MAAM,CAAC;QACnB,IAAI,EAAE,MAAM,CAAC;QACb,QAAQ,EAAE,gBAAgB,CAAC;QAC3B,KAAK,EAAE,aAAa,CAAC;QACrB,cAAc,CAAC,EAAE,sBAAsB,GAAG,IAAI,GAAG,SAAS,CAAC;QAC3D,WAAW,EAAE,MAAM,CAAC;KACrB,CAAC,CAAC;CACJ;AAED,MAAM,WAAW,8BAA8B;IAC7C,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,wBAAsB,wBAAwB,CAC5C,MAAM,EAAE,8BAA8B,GACrC,OAAO,CAAC,8BAA8B,CAAC,CAiEzC;AAED,wBAAsB,eAAe,CAAC,MAAM,EAAE;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAS7F"}

package/dist/db/definitions.js

@@ -0,0 +1,208 @@
+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 { db } from './db.js';
+import { definitionTriggersFor } from './definition-triggers.js';
+import { toDefinition, workflowDefinitions } from './schema/definitions.js';
+import { definitionsOutbox } from './schema/outbox.js';
+function buildUpsertQuery(tx, params) {
+    const source = params.source ?? 'manual';
+    if (source === 'vcs' && !params.configPath) {
+        throw new Error('configPath is required for VCS definitions');
+    }
+    // Keep source aligned with the conflict arbiter (chosen by ref/sha presence):
+    // vcs rows are versioned by ref/sha, manual rows have neither.
+    const hasRefOrSha = params.ref != null || params.sha != null;
+    if (source === 'vcs' !== hasRefOrSha) {
+        throw new Error('Definition source/ref/sha mismatch: vcs requires a ref or sha, manual requires neither');
+    }
+    const definition = {
+        document: params.document,
+        model: params.model,
+        sourceSnapshot: params.sourceSnapshot ?? null
+    };
+    const set = {
+        name: params.name,
+        source,
+        definition,
+        contentHash: params.contentHash ?? null,
+        fetchedAt: sql`now()`,
+        updatedAt: sql`now()`,
+        deletedAt: null
+    };
+    const values = {
+        projectId: params.projectId,
+        configPath: params.configPath ?? null,
+        source,
+        sha: params.sha ?? null,
+        ref: params.ref ?? null,
+        name: params.name,
+        definition,
+        contentHash: params.contentHash ?? null
+    };
+    if (params.sha) {
+        return tx.insert(workflowDefinitions).values(values).onConflictDoUpdate({
+            target: [
+                workflowDefinitions.projectId,
+                workflowDefinitions.sha,
+                workflowDefinitions.configPath
+            ],
+            targetWhere: sql`"sha" IS NOT NULL`,
+            set
+        }).returning();
+    }
+    if (params.ref) {
+        return tx.insert(workflowDefinitions).values(values).onConflictDoUpdate({
+            target: [
+                workflowDefinitions.projectId,
+                workflowDefinitions.ref,
+                workflowDefinitions.configPath
+            ],
+            targetWhere: sql`"ref" IS NOT NULL`,
+            set
+        }).returning();
+    }
+    return tx.insert(workflowDefinitions).values(values).onConflictDoUpdate({
+        target: [
+            workflowDefinitions.projectId,
+            workflowDefinitions.configPath
+        ],
+        targetWhere: sql`"config_path" IS NOT NULL AND "ref" IS NULL AND "sha" IS NULL`,
+        set
+    }).returning();
+}
+export async function upsertDefinition(params) {
+    return await db().transaction(async (tx)=>{
+        const rows = await buildUpsertQuery(tx, params);
+        const row = rows[0];
+        if (!row) throw new Error('Upsert returned no rows');
+        await writeOutboxEvent(tx, definitionsOutbox, {
+            type: DEFINITION_RESOLVED,
+            payload: {
+                definitionId: row.id,
+                projectId: row.projectId,
+                workspaceId: params.workspaceId,
+                configPath: row.configPath,
+                triggers: definitionTriggersFor(row.definition.model)
+            }
+        });
+        return toDefinition(row);
+    });
+}
+export async function getDefinitionById(id) {
+    const rows = await db().select().from(workflowDefinitions).where(and(eq(workflowDefinitions.id, id), isNull(workflowDefinitions.deletedAt))).limit(1);
+    const row = rows[0];
+    if (!row) return undefined;
+    return toDefinition(row);
+}
+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
+    };
+}
+export async function listDefinitionsByProject(projectId) {
+    const result = await listDefinitions({
+        projectId,
+        limit: 100
+    });
+    return result.definitions;
+}
+async function softDeleteVcsDefinitionsNotInTx(tx, params) {
+    const now = sql`now()`;
+    const baseWhere = and(eq(workflowDefinitions.projectId, params.projectId), eq(workflowDefinitions.source, 'vcs'), eq(workflowDefinitions.ref, params.ref), isNull(workflowDefinitions.deletedAt));
+    const where = params.keepConfigPaths.length > 0 ? and(baseWhere, notInArray(workflowDefinitions.configPath, params.keepConfigPaths)) : baseWhere;
+    const rows = await tx.update(workflowDefinitions).set({
+        deletedAt: now,
+        updatedAt: now
+    }).where(where).returning({
+        id: workflowDefinitions.id
+    });
+    for (const row of rows){
+        await writeOutboxEvent(tx, definitionsOutbox, {
+            type: DEFINITION_DELETED,
+            payload: {
+                definitionId: row.id,
+                projectId: params.projectId,
+                workspaceId: params.workspaceId
+            }
+        });
+    }
+    return rows.length;
+}
+export async function softDeleteVcsDefinitionsNotIn(params) {
+    return await db().transaction((tx)=>softDeleteVcsDefinitionsNotInTx(tx, params));
+}
+export async function applyVcsDefinitionsBatch(params) {
+    return await db().transaction(async (tx)=>{
+        let appliedCount = 0;
+        for (const item of params.upserts){
+            const existing = await tx.select({
+                contentHash: workflowDefinitions.contentHash,
+                deletedAt: workflowDefinitions.deletedAt
+            }).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;
+            const rows = await buildUpsertQuery(tx, {
+                projectId: params.projectId,
+                workspaceId: params.workspaceId,
+                configPath: item.configPath,
+                source: 'vcs',
+                ref: params.ref,
+                name: item.name,
+                document: item.document,
+                model: item.model,
+                sourceSnapshot: item.sourceSnapshot ?? null,
+                contentHash: item.contentHash
+            });
+            const row = rows[0];
+            if (!row) throw new Error('Upsert returned no rows');
+            if (!unchanged) {
+                await writeOutboxEvent(tx, definitionsOutbox, {
+                    type: DEFINITION_RESOLVED,
+                    payload: {
+                        definitionId: row.id,
+                        projectId: row.projectId,
+                        workspaceId: params.workspaceId,
+                        configPath: row.configPath,
+                        triggers: definitionTriggersFor(row.definition.model)
+                    }
+                });
+                appliedCount += 1;
+            }
+        }
+        const keepConfigPaths = params.upserts.map((upsert)=>upsert.configPath);
+        const deletedCount = await softDeleteVcsDefinitionsNotInTx(tx, {
+            projectId: params.projectId,
+            workspaceId: params.workspaceId,
+            ref: params.ref,
+            keepConfigPaths
+        });
+        return {
+            appliedCount,
+            deletedCount
+        };
+    });
+}
+export async function invalidateCache(params) {
+    await db().delete(workflowDefinitions).where(and(eq(workflowDefinitions.projectId, params.projectId), eq(workflowDefinitions.ref, params.ref)));
+}
+
+//# sourceMappingURL=definitions.js.map

package/dist/db/definitions.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/db/definitions.ts"],"sourcesContent":["import {\n  DEFINITION_DELETED,\n  DEFINITION_RESOLVED,\n  type DefinitionsEventMap,\n} from '@shipfox/api-definitions-dto';\nimport {writeOutboxEvent} from '@shipfox/node-outbox';\nimport type {WorkflowDocument} from '@shipfox/workflow-document';\nimport {and, asc, eq, gt, isNull, notInArray, or, type SQL, sql} from 'drizzle-orm';\nimport type {\n  WorkflowDefinition,\n  WorkflowDefinitionPayload,\n  WorkflowSourceSnapshot,\n} from '#core/entities/workflow-definition.js';\nimport type {WorkflowModel} from '#core/entities/workflow-model.js';\nimport {db} from './db.js';\nimport {definitionTriggersFor} from './definition-triggers.js';\nimport {toDefinition, workflowDefinitions} from './schema/definitions.js';\nimport {definitionsOutbox} from './schema/outbox.js';\n\ntype Tx = Parameters<Parameters<ReturnType<typeof db>['transaction']>[0]>[0];\n\nexport interface UpsertDefinitionParams {\n  projectId: string;\n  workspaceId: string;\n  configPath?: string | null | undefined;\n  source?: 'manual' | 'vcs' | undefined;\n  name: string;\n  document: WorkflowDocument;\n  model: WorkflowModel;\n  sourceSnapshot?: WorkflowSourceSnapshot | null | undefined;\n  contentHash?: string | null | undefined;\n  sha?: string | undefined;\n  ref?: string | undefined;\n}\n\nfunction buildUpsertQuery(tx: Tx, params: UpsertDefinitionParams) {\n  const source = params.source ?? 'manual';\n  if (source === 'vcs' && !params.configPath) {\n    throw new Error('configPath is required for VCS definitions');\n  }\n  // Keep source aligned with the conflict arbiter (chosen by ref/sha presence):\n  // vcs rows are versioned by ref/sha, manual rows have neither.\n  const hasRefOrSha = params.ref != null || params.sha != null;\n  if ((source === 'vcs') !== hasRefOrSha) {\n    throw new Error(\n      'Definition source/ref/sha mismatch: vcs requires a ref or sha, manual requires neither',\n    );\n  }\n\n  const definition: WorkflowDefinitionPayload = {\n    document: params.document,\n    model: params.model,\n    sourceSnapshot: params.sourceSnapshot ?? null,\n  };\n\n  const set = {\n    name: params.name,\n    source,\n    definition,\n    contentHash: params.contentHash ?? null,\n    fetchedAt: sql`now()`,\n    updatedAt: sql`now()`,\n    deletedAt: null,\n  };\n\n  const values = {\n    projectId: params.projectId,\n    configPath: params.configPath ?? null,\n    source,\n    sha: params.sha ?? null,\n    ref: params.ref ?? null,\n    name: params.name,\n    definition,\n    contentHash: params.contentHash ?? null,\n  };\n\n  if (params.sha) {\n    return tx\n      .insert(workflowDefinitions)\n      .values(values)\n      .onConflictDoUpdate({\n        target: [\n          workflowDefinitions.projectId,\n          workflowDefinitions.sha,\n          workflowDefinitions.configPath,\n        ],\n        targetWhere: sql`\"sha\" IS NOT NULL`,\n        set,\n      })\n      .returning();\n  }\n\n  if (params.ref) {\n    return tx\n      .insert(workflowDefinitions)\n      .values(values)\n      .onConflictDoUpdate({\n        target: [\n          workflowDefinitions.projectId,\n          workflowDefinitions.ref,\n          workflowDefinitions.configPath,\n        ],\n        targetWhere: sql`\"ref\" IS NOT NULL`,\n        set,\n      })\n      .returning();\n  }\n\n  return tx\n    .insert(workflowDefinitions)\n    .values(values)\n    .onConflictDoUpdate({\n      target: [workflowDefinitions.projectId, workflowDefinitions.configPath],\n      targetWhere: sql`\"config_path\" IS NOT NULL AND \"ref\" IS NULL AND \"sha\" IS NULL`,\n      set,\n    })\n    .returning();\n}\n\nexport async function upsertDefinition(\n  params: UpsertDefinitionParams,\n): Promise<WorkflowDefinition> {\n  return await db().transaction(async (tx) => {\n    const rows = await buildUpsertQuery(tx, params);\n    const row = rows[0];\n    if (!row) throw new Error('Upsert returned no rows');\n\n    await writeOutboxEvent<DefinitionsEventMap>(tx, definitionsOutbox, {\n      type: DEFINITION_RESOLVED,\n      payload: {\n        definitionId: row.id,\n        projectId: row.projectId,\n        workspaceId: params.workspaceId,\n        configPath: row.configPath,\n        triggers: definitionTriggersFor(row.definition.model),\n      },\n    });\n\n    return toDefinition(row);\n  });\n}\n\nexport async function getDefinitionById(id: string): Promise<WorkflowDefinition | undefined> {\n  const rows = await db()\n    .select()\n    .from(workflowDefinitions)\n    .where(and(eq(workflowDefinitions.id, id), isNull(workflowDefinitions.deletedAt)))\n    .limit(1);\n  const row = rows[0];\n\n  if (!row) return undefined;\n  return toDefinition(row);\n}\n\nexport interface DefinitionCursor {\n  value: string;\n  id: string;\n}\n\nexport interface ListDefinitionsParams {\n  projectId: string;\n  limit: number;\n  cursor?: DefinitionCursor | undefined;\n}\n\nexport interface ListDefinitionsResult {\n  definitions: WorkflowDefinition[];\n  nextCursor: DefinitionCursor | null;\n}\n\nfunction cursorWhere(cursor: DefinitionCursor | undefined): SQL | undefined {\n  if (!cursor) return undefined;\n  return or(\n    gt(workflowDefinitions.name, cursor.value),\n    and(eq(workflowDefinitions.name, cursor.value), gt(workflowDefinitions.id, cursor.id)),\n  );\n}\n\nexport async function listDefinitions(\n  params: ListDefinitionsParams,\n): Promise<ListDefinitionsResult> {\n  const conditions = [\n    eq(workflowDefinitions.projectId, params.projectId),\n    isNull(workflowDefinitions.deletedAt),\n  ];\n  const cursorCondition = cursorWhere(params.cursor);\n  if (cursorCondition) conditions.push(cursorCondition);\n\n  const rows = await db()\n    .select()\n    .from(workflowDefinitions)\n    .where(and(...conditions))\n    .orderBy(asc(workflowDefinitions.name), asc(workflowDefinitions.id))\n    .limit(params.limit + 1);\n\n  const hasMore = rows.length > params.limit;\n  const pageRows = hasMore ? rows.slice(0, params.limit) : rows;\n  const last = pageRows.at(-1);\n\n  return {\n    definitions: pageRows.map(toDefinition),\n    nextCursor: hasMore && last ? {value: last.name, id: last.id} : null,\n  };\n}\n\nexport async function listDefinitionsByProject(projectId: string): Promise<WorkflowDefinition[]> {\n  const result = await listDefinitions({projectId, limit: 100});\n  return result.definitions;\n}\n\nexport interface SoftDeleteVcsDefinitionsParams {\n  projectId: string;\n  workspaceId: string;\n  ref: string;\n  keepConfigPaths: string[];\n}\n\nasync function softDeleteVcsDefinitionsNotInTx(\n  tx: Tx,\n  params: SoftDeleteVcsDefinitionsParams,\n): Promise<number> {\n  const now = sql`now()`;\n  const baseWhere = and(\n    eq(workflowDefinitions.projectId, params.projectId),\n    eq(workflowDefinitions.source, 'vcs'),\n    eq(workflowDefinitions.ref, params.ref),\n    isNull(workflowDefinitions.deletedAt),\n  );\n  const where =\n    params.keepConfigPaths.length > 0\n      ? and(baseWhere, notInArray(workflowDefinitions.configPath, params.keepConfigPaths))\n      : baseWhere;\n\n  const rows = await tx\n    .update(workflowDefinitions)\n    .set({deletedAt: now, updatedAt: now})\n    .where(where)\n    .returning({id: workflowDefinitions.id});\n\n  for (const row of rows) {\n    await writeOutboxEvent<DefinitionsEventMap>(tx, definitionsOutbox, {\n      type: DEFINITION_DELETED,\n      payload: {\n        definitionId: row.id,\n        projectId: params.projectId,\n        workspaceId: params.workspaceId,\n      },\n    });\n  }\n\n  return rows.length;\n}\n\nexport async function softDeleteVcsDefinitionsNotIn(\n  params: SoftDeleteVcsDefinitionsParams,\n): Promise<number> {\n  return await db().transaction((tx) => softDeleteVcsDefinitionsNotInTx(tx, params));\n}\n\nexport interface ApplyVcsDefinitionsBatchParams {\n  projectId: string;\n  workspaceId: string;\n  ref: string;\n  upserts: Array<{\n    configPath: string;\n    name: string;\n    document: WorkflowDocument;\n    model: WorkflowModel;\n    sourceSnapshot?: WorkflowSourceSnapshot | null | undefined;\n    contentHash: string;\n  }>;\n}\n\nexport interface ApplyVcsDefinitionsBatchResult {\n  appliedCount: number;\n  deletedCount: number;\n}\n\nexport async function applyVcsDefinitionsBatch(\n  params: ApplyVcsDefinitionsBatchParams,\n): Promise<ApplyVcsDefinitionsBatchResult> {\n  return await db().transaction(async (tx) => {\n    let appliedCount = 0;\n    for (const item of params.upserts) {\n      const existing = await tx\n        .select({\n          contentHash: workflowDefinitions.contentHash,\n          deletedAt: workflowDefinitions.deletedAt,\n        })\n        .from(workflowDefinitions)\n        .where(\n          and(\n            eq(workflowDefinitions.projectId, params.projectId),\n            eq(workflowDefinitions.ref, params.ref),\n            eq(workflowDefinitions.configPath, item.configPath),\n          ),\n        )\n        .limit(1);\n\n      const previous = existing[0];\n      const unchanged =\n        previous !== undefined &&\n        previous.deletedAt === null &&\n        previous.contentHash === item.contentHash;\n\n      const rows = await buildUpsertQuery(tx, {\n        projectId: params.projectId,\n        workspaceId: params.workspaceId,\n        configPath: item.configPath,\n        source: 'vcs',\n        ref: params.ref,\n        name: item.name,\n        document: item.document,\n        model: item.model,\n        sourceSnapshot: item.sourceSnapshot ?? null,\n        contentHash: item.contentHash,\n      });\n      const row = rows[0];\n      if (!row) throw new Error('Upsert returned no rows');\n\n      if (!unchanged) {\n        await writeOutboxEvent<DefinitionsEventMap>(tx, definitionsOutbox, {\n          type: DEFINITION_RESOLVED,\n          payload: {\n            definitionId: row.id,\n            projectId: row.projectId,\n            workspaceId: params.workspaceId,\n            configPath: row.configPath,\n            triggers: definitionTriggersFor(row.definition.model),\n          },\n        });\n        appliedCount += 1;\n      }\n    }\n\n    const keepConfigPaths = params.upserts.map((upsert) => upsert.configPath);\n    const deletedCount = await softDeleteVcsDefinitionsNotInTx(tx, {\n      projectId: params.projectId,\n      workspaceId: params.workspaceId,\n      ref: params.ref,\n      keepConfigPaths,\n    });\n\n    return {appliedCount, deletedCount};\n  });\n}\n\nexport async function invalidateCache(params: {projectId: string; ref: string}): Promise<void> {\n  await db()\n    .delete(workflowDefinitions)\n    .where(\n      and(\n        eq(workflowDefinitions.projectId, params.projectId),\n        eq(workflowDefinitions.ref, params.ref),\n      ),\n    );\n}\n"],"names":["DEFINITION_DELETED","DEFINITION_RESOLVED","writeOutboxEvent","and","asc","eq","gt","isNull","notInArray","or","sql","db","definitionTriggersFor","toDefinition","workflowDefinitions","definitionsOutbox","buildUpsertQuery","tx","params","source","configPath","Error","hasRefOrSha","ref","sha","definition","document","model","sourceSnapshot","set","name","contentHash","fetchedAt","updatedAt","deletedAt","values","projectId","insert","onConflictDoUpdate","target","targetWhere","returning","upsertDefinition","transaction","rows","row","type","payload","definitionId","id","workspaceId","triggers","getDefinitionById","select","from","where","limit","undefined","cursorWhere","cursor","value","listDefinitions","conditions","cursorCondition","push","orderBy","hasMore","length","pageRows","slice","last","at","definitions","map","nextCursor","listDefinitionsByProject","result","softDeleteVcsDefinitionsNotInTx","now","baseWhere","keepConfigPaths","update","softDeleteVcsDefinitionsNotIn","applyVcsDefinitionsBatch","appliedCount","item","upserts","existing","previous","unchanged","upsert","deletedCount","invalidateCache","delete"],"mappings":"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"}

package/dist/db/index.d.ts

@@ -0,0 +1,8 @@
+export { closeDb, db, schema } from './db.js';
+export type { ApplyVcsDefinitionsBatchParams, ApplyVcsDefinitionsBatchResult, ListDefinitionsParams, ListDefinitionsResult, SoftDeleteVcsDefinitionsParams, UpsertDefinitionParams, } from './definitions.js';
+export { applyVcsDefinitionsBatch, getDefinitionById, invalidateCache, listDefinitions, listDefinitionsByProject, softDeleteVcsDefinitionsNotIn, upsertDefinition, } from './definitions.js';
+export { definitionsOutbox } from './schema/outbox.js';
+export { definitionSyncStates } from './schema/sync-states.js';
+export { type DefinitionSyncStateKey, getLatestDefinitionSyncState, type MarkDefinitionSyncParams, markDefinitionSyncState, } from './sync-states.js';
+export declare const migrationsPath: string;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/db/index.ts"],"names":[],"mappings":"AAGA,OAAO,EAAC,OAAO,EAAE,EAAE,EAAE,MAAM,EAAC,MAAM,SAAS,CAAC;AAC5C,YAAY,EACV,8BAA8B,EAC9B,8BAA8B,EAC9B,qBAAqB,EACrB,qBAAqB,EACrB,8BAA8B,EAC9B,sBAAsB,GACvB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACL,wBAAwB,EACxB,iBAAiB,EACjB,eAAe,EACf,eAAe,EACf,wBAAwB,EACxB,6BAA6B,EAC7B,gBAAgB,GACjB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAC,iBAAiB,EAAC,MAAM,oBAAoB,CAAC;AACrD,OAAO,EAAC,oBAAoB,EAAC,MAAM,yBAAyB,CAAC;AAC7D,OAAO,EACL,KAAK,sBAAsB,EAC3B,4BAA4B,EAC5B,KAAK,wBAAwB,EAC7B,uBAAuB,GACxB,MAAM,kBAAkB,CAAC;AAE1B,eAAO,MAAM,cAAc,QAAoE,CAAC"}

package/dist/db/index.js

@@ -0,0 +1,10 @@
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+export { closeDb, db, schema } from './db.js';
+export { applyVcsDefinitionsBatch, getDefinitionById, invalidateCache, listDefinitions, listDefinitionsByProject, softDeleteVcsDefinitionsNotIn, upsertDefinition } from './definitions.js';
+export { definitionsOutbox } from './schema/outbox.js';
+export { definitionSyncStates } from './schema/sync-states.js';
+export { getLatestDefinitionSyncState, markDefinitionSyncState } from './sync-states.js';
+export const migrationsPath = resolve(dirname(fileURLToPath(import.meta.url)), '../../drizzle');
+
+//# sourceMappingURL=index.js.map

package/dist/db/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/db/index.ts"],"sourcesContent":["import {dirname, resolve} from 'node:path';\nimport {fileURLToPath} from 'node:url';\n\nexport {closeDb, db, schema} from './db.js';\nexport type {\n  ApplyVcsDefinitionsBatchParams,\n  ApplyVcsDefinitionsBatchResult,\n  ListDefinitionsParams,\n  ListDefinitionsResult,\n  SoftDeleteVcsDefinitionsParams,\n  UpsertDefinitionParams,\n} from './definitions.js';\nexport {\n  applyVcsDefinitionsBatch,\n  getDefinitionById,\n  invalidateCache,\n  listDefinitions,\n  listDefinitionsByProject,\n  softDeleteVcsDefinitionsNotIn,\n  upsertDefinition,\n} from './definitions.js';\nexport {definitionsOutbox} from './schema/outbox.js';\nexport {definitionSyncStates} from './schema/sync-states.js';\nexport {\n  type DefinitionSyncStateKey,\n  getLatestDefinitionSyncState,\n  type MarkDefinitionSyncParams,\n  markDefinitionSyncState,\n} from './sync-states.js';\n\nexport const migrationsPath = resolve(dirname(fileURLToPath(import.meta.url)), '../../drizzle');\n"],"names":["dirname","resolve","fileURLToPath","closeDb","db","schema","applyVcsDefinitionsBatch","getDefinitionById","invalidateCache","listDefinitions","listDefinitionsByProject","softDeleteVcsDefinitionsNotIn","upsertDefinition","definitionsOutbox","definitionSyncStates","getLatestDefinitionSyncState","markDefinitionSyncState","migrationsPath","url"],"mappings":"AAAA,SAAQA,OAAO,EAAEC,OAAO,QAAO,YAAY;AAC3C,SAAQC,aAAa,QAAO,WAAW;AAEvC,SAAQC,OAAO,EAAEC,EAAE,EAAEC,MAAM,QAAO,UAAU;AAS5C,SACEC,wBAAwB,EACxBC,iBAAiB,EACjBC,eAAe,EACfC,eAAe,EACfC,wBAAwB,EACxBC,6BAA6B,EAC7BC,gBAAgB,QACX,mBAAmB;AAC1B,SAAQC,iBAAiB,QAAO,qBAAqB;AACrD,SAAQC,oBAAoB,QAAO,0BAA0B;AAC7D,SAEEC,4BAA4B,EAE5BC,uBAAuB,QAClB,mBAAmB;AAE1B,OAAO,MAAMC,iBAAiBhB,QAAQD,QAAQE,cAAc,YAAYgB,GAAG,IAAI,iBAAiB"}

package/dist/db/schema/common.d.ts

@@ -0,0 +1,2 @@
+export declare const pgTable: import("drizzle-orm/pg-core").PgTableFn<undefined>;
+//# sourceMappingURL=common.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../../src/db/schema/common.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,OAAO,oDAAkD,CAAC"}

package/dist/db/schema/common.js

@@ -0,0 +1,4 @@
+import { pgTableCreator } from 'drizzle-orm/pg-core';
+export const pgTable = pgTableCreator((name)=>`definitions_${name}`);
+
+//# sourceMappingURL=common.js.map

package/dist/db/schema/common.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/db/schema/common.ts"],"sourcesContent":["import {pgTableCreator} from 'drizzle-orm/pg-core';\n\nexport const pgTable = pgTableCreator((name) => `definitions_${name}`);\n"],"names":["pgTableCreator","pgTable","name"],"mappings":"AAAA,SAAQA,cAAc,QAAO,sBAAsB;AAEnD,OAAO,MAAMC,UAAUD,eAAe,CAACE,OAAS,CAAC,YAAY,EAAEA,MAAM,EAAE"}