@shipfox/api-definitions 2.0.0

package/dist/db/schema/sync-states.d.ts

@@ -0,0 +1,218 @@
+import type { DefinitionSyncState } from '#core/entities/sync-state.js';
+export declare const definitionSyncStatusEnum: import("drizzle-orm/pg-core").PgEnum<["pending", "syncing", "succeeded", "failed"]>;
+export declare const definitionSyncErrorCodeEnum: import("drizzle-orm/pg-core").PgEnum<["no-workflow-files", "invalid-definition", "provider-repository-not-found", "provider-file-not-found", "provider-access-denied", "provider-rate-limited", "provider-timeout", "provider-unavailable", "provider-malformed-response", "content-too-large", "too-many-files", "connection-unavailable", "unknown"]>;
+export declare const definitionSyncStates: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "sync_states";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "sync_states";
+            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: "sync_states";
+            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;
+        }, {}, {}>;
+        sourceConnectionId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "source_connection_id";
+            tableName: "sync_states";
+            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;
+        }, {}, {}>;
+        sourceExternalRepositoryId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "source_external_repository_id";
+            tableName: "sync_states";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        ref: import("drizzle-orm/pg-core").PgColumn<{
+            name: "ref";
+            tableName: "sync_states";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        status: import("drizzle-orm/pg-core").PgColumn<{
+            name: "status";
+            tableName: "sync_states";
+            dataType: "string";
+            columnType: "PgEnumColumn";
+            data: "pending" | "syncing" | "succeeded" | "failed";
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["pending", "syncing", "succeeded", "failed"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        lastErrorCode: import("drizzle-orm/pg-core").PgColumn<{
+            name: "last_error_code";
+            tableName: "sync_states";
+            dataType: "string";
+            columnType: "PgEnumColumn";
+            data: "no-workflow-files" | "invalid-definition" | "provider-repository-not-found" | "provider-file-not-found" | "provider-access-denied" | "provider-rate-limited" | "provider-timeout" | "provider-unavailable" | "provider-malformed-response" | "content-too-large" | "too-many-files" | "connection-unavailable" | "unknown";
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["no-workflow-files", "invalid-definition", "provider-repository-not-found", "provider-file-not-found", "provider-access-denied", "provider-rate-limited", "provider-timeout", "provider-unavailable", "provider-malformed-response", "content-too-large", "too-many-files", "connection-unavailable", "unknown"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        lastErrorMessage: import("drizzle-orm/pg-core").PgColumn<{
+            name: "last_error_message";
+            tableName: "sync_states";
+            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;
+        }, {}, {}>;
+        startedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "started_at";
+            tableName: "sync_states";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        finishedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "finished_at";
+            tableName: "sync_states";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "sync_states";
+            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;
+        }, {}, {}>;
+        updatedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "updated_at";
+            tableName: "sync_states";
+            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 type DefinitionSyncStateDb = typeof definitionSyncStates.$inferSelect;
+export type DefinitionSyncStateCreateDb = typeof definitionSyncStates.$inferInsert;
+export declare function toDefinitionSyncState(row: DefinitionSyncStateDb): DefinitionSyncState;
+//# sourceMappingURL=sync-states.d.ts.map

package/dist/db/schema/sync-states.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync-states.d.ts","sourceRoot":"","sources":["../../../src/db/schema/sync-states.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAEV,mBAAmB,EAEpB,MAAM,8BAA8B,CAAC;AAGtC,eAAO,MAAM,wBAAwB,qFAKnC,CAAC;AAEH,eAAO,MAAM,2BAA2B,yVActC,CAAC;AAEH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyBhC,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG,OAAO,oBAAoB,CAAC,YAAY,CAAC;AAC7E,MAAM,MAAM,2BAA2B,GAAG,OAAO,oBAAoB,CAAC,YAAY,CAAC;AAEnF,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,qBAAqB,GAAG,mBAAmB,CAerF"}

package/dist/db/schema/sync-states.js

@@ -0,0 +1,68 @@
+import { uuidv7PrimaryKey } from '@shipfox/node-drizzle';
+import { sql } from 'drizzle-orm';
+import { index, pgEnum, text, timestamp, uniqueIndex, uuid } from 'drizzle-orm/pg-core';
+import { pgTable } from './common.js';
+export const definitionSyncStatusEnum = pgEnum('definitions_sync_status', [
+    'pending',
+    'syncing',
+    'succeeded',
+    'failed'
+]);
+export const definitionSyncErrorCodeEnum = pgEnum('definitions_sync_error_code', [
+    'no-workflow-files',
+    'invalid-definition',
+    'provider-repository-not-found',
+    'provider-file-not-found',
+    'provider-access-denied',
+    'provider-rate-limited',
+    'provider-timeout',
+    'provider-unavailable',
+    'provider-malformed-response',
+    'content-too-large',
+    'too-many-files',
+    'connection-unavailable',
+    'unknown'
+]);
+export const definitionSyncStates = pgTable('sync_states', {
+    id: uuidv7PrimaryKey(),
+    projectId: uuid('project_id').notNull(),
+    sourceConnectionId: uuid('source_connection_id').notNull(),
+    sourceExternalRepositoryId: text('source_external_repository_id').notNull(),
+    ref: text('ref').notNull(),
+    status: definitionSyncStatusEnum('status').notNull().default('pending'),
+    lastErrorCode: definitionSyncErrorCodeEnum('last_error_code'),
+    lastErrorMessage: text('last_error_message'),
+    startedAt: timestamp('started_at', {
+        withTimezone: true
+    }),
+    finishedAt: timestamp('finished_at', {
+        withTimezone: true
+    }),
+    createdAt: timestamp('created_at', {
+        withTimezone: true
+    }).notNull().defaultNow(),
+    updatedAt: timestamp('updated_at', {
+        withTimezone: true
+    }).notNull().defaultNow()
+}, (table)=>[
+        uniqueIndex('definitions_sync_states_source_unique').on(table.projectId, table.sourceConnectionId, table.sourceExternalRepositoryId, table.ref),
+        index('definitions_sync_states_failed_idx').on(table.updatedAt).where(sql`"status" = 'failed'`)
+    ]);
+export function toDefinitionSyncState(row) {
+    return {
+        id: row.id,
+        projectId: row.projectId,
+        sourceConnectionId: row.sourceConnectionId,
+        sourceExternalRepositoryId: row.sourceExternalRepositoryId,
+        ref: row.ref,
+        status: row.status,
+        lastErrorCode: row.lastErrorCode,
+        lastErrorMessage: row.lastErrorMessage,
+        startedAt: row.startedAt,
+        finishedAt: row.finishedAt,
+        createdAt: row.createdAt,
+        updatedAt: row.updatedAt
+    };
+}
+
+//# sourceMappingURL=sync-states.js.map

package/dist/db/schema/sync-states.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/db/schema/sync-states.ts"],"sourcesContent":["import {uuidv7PrimaryKey} from '@shipfox/node-drizzle';\nimport {sql} from 'drizzle-orm';\nimport {index, pgEnum, text, timestamp, uniqueIndex, uuid} from 'drizzle-orm/pg-core';\nimport type {\n  DefinitionSyncErrorCode,\n  DefinitionSyncState,\n  DefinitionSyncStatus,\n} from '#core/entities/sync-state.js';\nimport {pgTable} from './common.js';\n\nexport const definitionSyncStatusEnum = pgEnum('definitions_sync_status', [\n  'pending',\n  'syncing',\n  'succeeded',\n  'failed',\n]);\n\nexport const definitionSyncErrorCodeEnum = pgEnum('definitions_sync_error_code', [\n  'no-workflow-files',\n  'invalid-definition',\n  'provider-repository-not-found',\n  'provider-file-not-found',\n  'provider-access-denied',\n  'provider-rate-limited',\n  'provider-timeout',\n  'provider-unavailable',\n  'provider-malformed-response',\n  'content-too-large',\n  'too-many-files',\n  'connection-unavailable',\n  'unknown',\n]);\n\nexport const definitionSyncStates = pgTable(\n  'sync_states',\n  {\n    id: uuidv7PrimaryKey(),\n    projectId: uuid('project_id').notNull(),\n    sourceConnectionId: uuid('source_connection_id').notNull(),\n    sourceExternalRepositoryId: text('source_external_repository_id').notNull(),\n    ref: text('ref').notNull(),\n    status: definitionSyncStatusEnum('status').notNull().default('pending'),\n    lastErrorCode: definitionSyncErrorCodeEnum('last_error_code'),\n    lastErrorMessage: text('last_error_message'),\n    startedAt: timestamp('started_at', {withTimezone: true}),\n    finishedAt: timestamp('finished_at', {withTimezone: true}),\n    createdAt: timestamp('created_at', {withTimezone: true}).notNull().defaultNow(),\n    updatedAt: timestamp('updated_at', {withTimezone: true}).notNull().defaultNow(),\n  },\n  (table) => [\n    uniqueIndex('definitions_sync_states_source_unique').on(\n      table.projectId,\n      table.sourceConnectionId,\n      table.sourceExternalRepositoryId,\n      table.ref,\n    ),\n    index('definitions_sync_states_failed_idx').on(table.updatedAt).where(sql`\"status\" = 'failed'`),\n  ],\n);\n\nexport type DefinitionSyncStateDb = typeof definitionSyncStates.$inferSelect;\nexport type DefinitionSyncStateCreateDb = typeof definitionSyncStates.$inferInsert;\n\nexport function toDefinitionSyncState(row: DefinitionSyncStateDb): DefinitionSyncState {\n  return {\n    id: row.id,\n    projectId: row.projectId,\n    sourceConnectionId: row.sourceConnectionId,\n    sourceExternalRepositoryId: row.sourceExternalRepositoryId,\n    ref: row.ref,\n    status: row.status as DefinitionSyncStatus,\n    lastErrorCode: row.lastErrorCode as DefinitionSyncErrorCode | null,\n    lastErrorMessage: row.lastErrorMessage,\n    startedAt: row.startedAt,\n    finishedAt: row.finishedAt,\n    createdAt: row.createdAt,\n    updatedAt: row.updatedAt,\n  };\n}\n"],"names":["uuidv7PrimaryKey","sql","index","pgEnum","text","timestamp","uniqueIndex","uuid","pgTable","definitionSyncStatusEnum","definitionSyncErrorCodeEnum","definitionSyncStates","id","projectId","notNull","sourceConnectionId","sourceExternalRepositoryId","ref","status","default","lastErrorCode","lastErrorMessage","startedAt","withTimezone","finishedAt","createdAt","defaultNow","updatedAt","table","on","where","toDefinitionSyncState","row"],"mappings":"AAAA,SAAQA,gBAAgB,QAAO,wBAAwB;AACvD,SAAQC,GAAG,QAAO,cAAc;AAChC,SAAQC,KAAK,EAAEC,MAAM,EAAEC,IAAI,EAAEC,SAAS,EAAEC,WAAW,EAAEC,IAAI,QAAO,sBAAsB;AAMtF,SAAQC,OAAO,QAAO,cAAc;AAEpC,OAAO,MAAMC,2BAA2BN,OAAO,2BAA2B;IACxE;IACA;IACA;IACA;CACD,EAAE;AAEH,OAAO,MAAMO,8BAA8BP,OAAO,+BAA+B;IAC/E;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;CACD,EAAE;AAEH,OAAO,MAAMQ,uBAAuBH,QAClC,eACA;IACEI,IAAIZ;IACJa,WAAWN,KAAK,cAAcO,OAAO;IACrCC,oBAAoBR,KAAK,wBAAwBO,OAAO;IACxDE,4BAA4BZ,KAAK,iCAAiCU,OAAO;IACzEG,KAAKb,KAAK,OAAOU,OAAO;IACxBI,QAAQT,yBAAyB,UAAUK,OAAO,GAAGK,OAAO,CAAC;IAC7DC,eAAeV,4BAA4B;IAC3CW,kBAAkBjB,KAAK;IACvBkB,WAAWjB,UAAU,cAAc;QAACkB,cAAc;IAAI;IACtDC,YAAYnB,UAAU,eAAe;QAACkB,cAAc;IAAI;IACxDE,WAAWpB,UAAU,cAAc;QAACkB,cAAc;IAAI,GAAGT,OAAO,GAAGY,UAAU;IAC7EC,WAAWtB,UAAU,cAAc;QAACkB,cAAc;IAAI,GAAGT,OAAO,GAAGY,UAAU;AAC/E,GACA,CAACE,QAAU;QACTtB,YAAY,yCAAyCuB,EAAE,CACrDD,MAAMf,SAAS,EACfe,MAAMb,kBAAkB,EACxBa,MAAMZ,0BAA0B,EAChCY,MAAMX,GAAG;QAEXf,MAAM,sCAAsC2B,EAAE,CAACD,MAAMD,SAAS,EAAEG,KAAK,CAAC7B,GAAG,CAAC,mBAAmB,CAAC;KAC/F,EACD;AAKF,OAAO,SAAS8B,sBAAsBC,GAA0B;IAC9D,OAAO;QACLpB,IAAIoB,IAAIpB,EAAE;QACVC,WAAWmB,IAAInB,SAAS;QACxBE,oBAAoBiB,IAAIjB,kBAAkB;QAC1CC,4BAA4BgB,IAAIhB,0BAA0B;QAC1DC,KAAKe,IAAIf,GAAG;QACZC,QAAQc,IAAId,MAAM;QAClBE,eAAeY,IAAIZ,aAAa;QAChCC,kBAAkBW,IAAIX,gBAAgB;QACtCC,WAAWU,IAAIV,SAAS;QACxBE,YAAYQ,IAAIR,UAAU;QAC1BC,WAAWO,IAAIP,SAAS;QACxBE,WAAWK,IAAIL,SAAS;IAC1B;AACF"}

package/dist/db/sync-states.d.ts

@@ -0,0 +1,21 @@
+import type { DefinitionSyncErrorCode, DefinitionSyncState, DefinitionSyncStatus } from '#core/entities/sync-state.js';
+export interface DefinitionSyncStateKey {
+    projectId: string;
+    sourceConnectionId: string;
+    sourceExternalRepositoryId: string;
+    ref: string;
+}
+export interface MarkDefinitionSyncParams extends DefinitionSyncStateKey {
+    status: DefinitionSyncStatus;
+    lastErrorCode?: DefinitionSyncErrorCode | null | undefined;
+    lastErrorMessage?: string | null | undefined;
+    startedAt?: Date | null | undefined;
+    finishedAt?: Date | null | undefined;
+}
+export declare function markDefinitionSyncState(params: MarkDefinitionSyncParams): Promise<DefinitionSyncState>;
+export declare function getLatestDefinitionSyncState(params: {
+    projectId: string;
+    sourceConnectionId: string;
+    sourceExternalRepositoryId: string;
+}): Promise<DefinitionSyncState | undefined>;
+//# sourceMappingURL=sync-states.d.ts.map

package/dist/db/sync-states.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync-states.d.ts","sourceRoot":"","sources":["../../src/db/sync-states.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,uBAAuB,EACvB,mBAAmB,EACnB,oBAAoB,EACrB,MAAM,8BAA8B,CAAC;AAItC,MAAM,WAAW,sBAAsB;IACrC,SAAS,EAAE,MAAM,CAAC;IAClB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,0BAA0B,EAAE,MAAM,CAAC;IACnC,GAAG,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,wBAAyB,SAAQ,sBAAsB;IACtE,MAAM,EAAE,oBAAoB,CAAC;IAC7B,aAAa,CAAC,EAAE,uBAAuB,GAAG,IAAI,GAAG,SAAS,CAAC;IAC3D,gBAAgB,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IAC7C,SAAS,CAAC,EAAE,IAAI,GAAG,IAAI,GAAG,SAAS,CAAC;IACpC,UAAU,CAAC,EAAE,IAAI,GAAG,IAAI,GAAG,SAAS,CAAC;CACtC;AAED,wBAAsB,uBAAuB,CAC3C,MAAM,EAAE,wBAAwB,GAC/B,OAAO,CAAC,mBAAmB,CAAC,CAoC9B;AAED,wBAAsB,4BAA4B,CAAC,MAAM,EAAE;IACzD,SAAS,EAAE,MAAM,CAAC;IAClB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,0BAA0B,EAAE,MAAM,CAAC;CACpC,GAAG,OAAO,CAAC,mBAAmB,GAAG,SAAS,CAAC,CAiB3C"}

package/dist/db/sync-states.js

@@ -0,0 +1,47 @@
+import { and, desc, eq } from 'drizzle-orm';
+import { db } from './db.js';
+import { definitionSyncStates, toDefinitionSyncState } from './schema/sync-states.js';
+export async function markDefinitionSyncState(params) {
+    const now = new Date();
+    const [row] = await db().insert(definitionSyncStates).values({
+        projectId: params.projectId,
+        sourceConnectionId: params.sourceConnectionId,
+        sourceExternalRepositoryId: params.sourceExternalRepositoryId,
+        ref: params.ref,
+        status: params.status,
+        lastErrorCode: params.lastErrorCode ?? null,
+        lastErrorMessage: params.lastErrorMessage ?? null,
+        startedAt: params.startedAt ?? null,
+        finishedAt: params.finishedAt ?? null,
+        updatedAt: now
+    }).onConflictDoUpdate({
+        target: [
+            definitionSyncStates.projectId,
+            definitionSyncStates.sourceConnectionId,
+            definitionSyncStates.sourceExternalRepositoryId,
+            definitionSyncStates.ref
+        ],
+        set: {
+            status: params.status,
+            lastErrorCode: params.lastErrorCode ?? null,
+            lastErrorMessage: params.lastErrorMessage ?? null,
+            ...params.startedAt !== undefined ? {
+                startedAt: params.startedAt
+            } : {},
+            ...params.finishedAt !== undefined ? {
+                finishedAt: params.finishedAt
+            } : {},
+            updatedAt: now
+        }
+    }).returning();
+    if (!row) throw new Error('Definition sync state upsert returned no rows');
+    return toDefinitionSyncState(row);
+}
+export async function getLatestDefinitionSyncState(params) {
+    const rows = await db().select().from(definitionSyncStates).where(and(eq(definitionSyncStates.projectId, params.projectId), eq(definitionSyncStates.sourceConnectionId, params.sourceConnectionId), eq(definitionSyncStates.sourceExternalRepositoryId, params.sourceExternalRepositoryId))).orderBy(desc(definitionSyncStates.updatedAt)).limit(1);
+    const row = rows[0];
+    if (!row) return undefined;
+    return toDefinitionSyncState(row);
+}
+
+//# sourceMappingURL=sync-states.js.map

package/dist/db/sync-states.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/db/sync-states.ts"],"sourcesContent":["import {and, desc, eq} from 'drizzle-orm';\nimport type {\n  DefinitionSyncErrorCode,\n  DefinitionSyncState,\n  DefinitionSyncStatus,\n} from '#core/entities/sync-state.js';\nimport {db} from './db.js';\nimport {definitionSyncStates, toDefinitionSyncState} from './schema/sync-states.js';\n\nexport interface DefinitionSyncStateKey {\n  projectId: string;\n  sourceConnectionId: string;\n  sourceExternalRepositoryId: string;\n  ref: string;\n}\n\nexport interface MarkDefinitionSyncParams extends DefinitionSyncStateKey {\n  status: DefinitionSyncStatus;\n  lastErrorCode?: DefinitionSyncErrorCode | null | undefined;\n  lastErrorMessage?: string | null | undefined;\n  startedAt?: Date | null | undefined;\n  finishedAt?: Date | null | undefined;\n}\n\nexport async function markDefinitionSyncState(\n  params: MarkDefinitionSyncParams,\n): Promise<DefinitionSyncState> {\n  const now = new Date();\n  const [row] = await db()\n    .insert(definitionSyncStates)\n    .values({\n      projectId: params.projectId,\n      sourceConnectionId: params.sourceConnectionId,\n      sourceExternalRepositoryId: params.sourceExternalRepositoryId,\n      ref: params.ref,\n      status: params.status,\n      lastErrorCode: params.lastErrorCode ?? null,\n      lastErrorMessage: params.lastErrorMessage ?? null,\n      startedAt: params.startedAt ?? null,\n      finishedAt: params.finishedAt ?? null,\n      updatedAt: now,\n    })\n    .onConflictDoUpdate({\n      target: [\n        definitionSyncStates.projectId,\n        definitionSyncStates.sourceConnectionId,\n        definitionSyncStates.sourceExternalRepositoryId,\n        definitionSyncStates.ref,\n      ],\n      set: {\n        status: params.status,\n        lastErrorCode: params.lastErrorCode ?? null,\n        lastErrorMessage: params.lastErrorMessage ?? null,\n        ...(params.startedAt !== undefined ? {startedAt: params.startedAt} : {}),\n        ...(params.finishedAt !== undefined ? {finishedAt: params.finishedAt} : {}),\n        updatedAt: now,\n      },\n    })\n    .returning();\n\n  if (!row) throw new Error('Definition sync state upsert returned no rows');\n  return toDefinitionSyncState(row);\n}\n\nexport async function getLatestDefinitionSyncState(params: {\n  projectId: string;\n  sourceConnectionId: string;\n  sourceExternalRepositoryId: string;\n}): Promise<DefinitionSyncState | undefined> {\n  const rows = await db()\n    .select()\n    .from(definitionSyncStates)\n    .where(\n      and(\n        eq(definitionSyncStates.projectId, params.projectId),\n        eq(definitionSyncStates.sourceConnectionId, params.sourceConnectionId),\n        eq(definitionSyncStates.sourceExternalRepositoryId, params.sourceExternalRepositoryId),\n      ),\n    )\n    .orderBy(desc(definitionSyncStates.updatedAt))\n    .limit(1);\n\n  const row = rows[0];\n  if (!row) return undefined;\n  return toDefinitionSyncState(row);\n}\n"],"names":["and","desc","eq","db","definitionSyncStates","toDefinitionSyncState","markDefinitionSyncState","params","now","Date","row","insert","values","projectId","sourceConnectionId","sourceExternalRepositoryId","ref","status","lastErrorCode","lastErrorMessage","startedAt","finishedAt","updatedAt","onConflictDoUpdate","target","set","undefined","returning","Error","getLatestDefinitionSyncState","rows","select","from","where","orderBy","limit"],"mappings":"AAAA,SAAQA,GAAG,EAAEC,IAAI,EAAEC,EAAE,QAAO,cAAc;AAM1C,SAAQC,EAAE,QAAO,UAAU;AAC3B,SAAQC,oBAAoB,EAAEC,qBAAqB,QAAO,0BAA0B;AAiBpF,OAAO,eAAeC,wBACpBC,MAAgC;IAEhC,MAAMC,MAAM,IAAIC;IAChB,MAAM,CAACC,IAAI,GAAG,MAAMP,KACjBQ,MAAM,CAACP,sBACPQ,MAAM,CAAC;QACNC,WAAWN,OAAOM,SAAS;QAC3BC,oBAAoBP,OAAOO,kBAAkB;QAC7CC,4BAA4BR,OAAOQ,0BAA0B;QAC7DC,KAAKT,OAAOS,GAAG;QACfC,QAAQV,OAAOU,MAAM;QACrBC,eAAeX,OAAOW,aAAa,IAAI;QACvCC,kBAAkBZ,OAAOY,gBAAgB,IAAI;QAC7CC,WAAWb,OAAOa,SAAS,IAAI;QAC/BC,YAAYd,OAAOc,UAAU,IAAI;QACjCC,WAAWd;IACb,GACCe,kBAAkB,CAAC;QAClBC,QAAQ;YACNpB,qBAAqBS,SAAS;YAC9BT,qBAAqBU,kBAAkB;YACvCV,qBAAqBW,0BAA0B;YAC/CX,qBAAqBY,GAAG;SACzB;QACDS,KAAK;YACHR,QAAQV,OAAOU,MAAM;YACrBC,eAAeX,OAAOW,aAAa,IAAI;YACvCC,kBAAkBZ,OAAOY,gBAAgB,IAAI;YAC7C,GAAIZ,OAAOa,SAAS,KAAKM,YAAY;gBAACN,WAAWb,OAAOa,SAAS;YAAA,IAAI,CAAC,CAAC;YACvE,GAAIb,OAAOc,UAAU,KAAKK,YAAY;gBAACL,YAAYd,OAAOc,UAAU;YAAA,IAAI,CAAC,CAAC;YAC1EC,WAAWd;QACb;IACF,GACCmB,SAAS;IAEZ,IAAI,CAACjB,KAAK,MAAM,IAAIkB,MAAM;IAC1B,OAAOvB,sBAAsBK;AAC/B;AAEA,OAAO,eAAemB,6BAA6BtB,MAIlD;IACC,MAAMuB,OAAO,MAAM3B,KAChB4B,MAAM,GACNC,IAAI,CAAC5B,sBACL6B,KAAK,CACJjC,IACEE,GAAGE,qBAAqBS,SAAS,EAAEN,OAAOM,SAAS,GACnDX,GAAGE,qBAAqBU,kBAAkB,EAAEP,OAAOO,kBAAkB,GACrEZ,GAAGE,qBAAqBW,0BAA0B,EAAER,OAAOQ,0BAA0B,IAGxFmB,OAAO,CAACjC,KAAKG,qBAAqBkB,SAAS,GAC3Ca,KAAK,CAAC;IAET,MAAMzB,MAAMoB,IAAI,CAAC,EAAE;IACnB,IAAI,CAACpB,KAAK,OAAOgB;IACjB,OAAOrB,sBAAsBK;AAC/B"}

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+import type { AgentToolSelectionCatalogs, GetIntegrationConnectionByIdFn, IntegrationSourceControlService, LoadWorkspaceConnectionSnapshot } from '@shipfox/api-integration-core';
+import { type ShipfoxModule } from '@shipfox/node-module';
+export type { WorkflowDefinition, WorkflowDefinitionPayload, WorkflowEnvTemplates, WorkflowModel, WorkflowModelJobCheckout, WorkflowSourceSnapshot, WorkflowSpec, } from '#core/index.js';
+export { DEFAULT_JOB_CHECKOUT, DEFAULT_JOB_SUCCESS, DEFAULT_RUN_TIMEOUT_MS, normalizeWorkflowDocument, } from '#core/index.js';
+export { db, definitionsOutbox, getDefinitionById, migrationsPath } from '#db/index.js';
+export { routes } from '#presentation/index.js';
+export interface CreateDefinitionsModuleOptions {
+    sourceControl: IntegrationSourceControlService;
+    agentToolSelectionCatalogs?: AgentToolSelectionCatalogs | undefined;
+    loadWorkspaceConnectionSnapshot?: LoadWorkspaceConnectionSnapshot | undefined;
+    getIntegrationConnectionById?: GetIntegrationConnectionByIdFn | undefined;
+}
+export declare function createDefinitionsModule({ sourceControl, agentToolSelectionCatalogs, loadWorkspaceConnectionSnapshot, getIntegrationConnectionById, }: CreateDefinitionsModuleOptions): ShipfoxModule;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EACV,0BAA0B,EAC1B,8BAA8B,EAC9B,+BAA+B,EAC/B,+BAA+B,EAChC,MAAM,+BAA+B,CAAC;AAMvC,OAAO,EAAC,KAAK,aAAa,EAAoB,MAAM,sBAAsB,CAAC;AAU3E,YAAY,EACV,kBAAkB,EAClB,yBAAyB,EACzB,oBAAoB,EACpB,aAAa,EACb,wBAAwB,EACxB,sBAAsB,EACtB,YAAY,GACb,MAAM,gBAAgB,CAAC;AACxB,OAAO,EACL,oBAAoB,EACpB,mBAAmB,EACnB,sBAAsB,EACtB,yBAAyB,GAC1B,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAC,EAAE,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,cAAc,EAAC,MAAM,cAAc,CAAC;AACtF,OAAO,EAAC,MAAM,EAAC,MAAM,wBAAwB,CAAC;AAO9C,MAAM,WAAW,8BAA8B;IAC7C,aAAa,EAAE,+BAA+B,CAAC;IAC/C,0BAA0B,CAAC,EAAE,0BAA0B,GAAG,SAAS,CAAC;IACpE,+BAA+B,CAAC,EAAE,+BAA+B,GAAG,SAAS,CAAC;IAC9E,4BAA4B,CAAC,EAAE,8BAA8B,GAAG,SAAS,CAAC;CAC3E;AAED,wBAAgB,uBAAuB,CAAC,EACtC,aAAa,EACb,0BAA0B,EAC1B,+BAA+B,EAC/B,4BAA4B,GAC7B,EAAE,8BAA8B,GAAG,aAAa,CAwChD"}

package/dist/index.js

@@ -0,0 +1,63 @@
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { DEFINITION_RESOLVED, definitionsEventSchemas } from '@shipfox/api-definitions-dto';
+import { PROJECT_SOURCE_BOUND, PROJECT_SOURCE_COMMIT_OBSERVED } from '@shipfox/api-projects-dto';
+import { subscriberFactory } from '@shipfox/node-module';
+import { logger } from '@shipfox/node-opentelemetry';
+import { db, definitionsOutbox, migrationsPath } from '#db/index.js';
+import { createDefinitionRoutes } from '#presentation/index.js';
+import { onProjectSourceBound, onProjectSourceCommitObserved } from '#presentation/subscribers/index.js';
+import { createDefinitionSyncActivities, DEFINITIONS_TASK_QUEUE } from '#temporal/index.js';
+export { DEFAULT_JOB_CHECKOUT, DEFAULT_JOB_SUCCESS, DEFAULT_RUN_TIMEOUT_MS, normalizeWorkflowDocument } from '#core/index.js';
+export { db, definitionsOutbox, getDefinitionById, migrationsPath } from '#db/index.js';
+export { routes } from '#presentation/index.js';
+const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+const workflowsPath = resolve(packageRoot, 'dist/temporal/workflows/index.js');
+const subscriber = subscriberFactory();
+export function createDefinitionsModule({ sourceControl, agentToolSelectionCatalogs, loadWorkspaceConnectionSnapshot, getIntegrationConnectionById }) {
+    const integrationValidation = agentToolSelectionCatalogs === undefined || loadWorkspaceConnectionSnapshot === undefined || getIntegrationConnectionById === undefined ? undefined : {
+        agentToolSelectionCatalogs,
+        loadWorkspaceConnectionSnapshot,
+        getIntegrationConnectionById
+    };
+    return {
+        name: 'definitions',
+        database: {
+            db,
+            migrationsPath
+        },
+        routes: createDefinitionRoutes({
+            agentToolSelectionCatalogs,
+            loadWorkspaceConnectionSnapshot,
+            getIntegrationConnectionById
+        }),
+        publishers: [
+            {
+                name: 'definitions',
+                table: definitionsOutbox,
+                db,
+                eventSchemas: definitionsEventSchemas
+            }
+        ],
+        subscribers: [
+            subscriber(DEFINITION_RESOLVED, (_payload, event)=>{
+                logger().info({
+                    event
+                }, 'Definition resolved');
+                return Promise.resolve();
+            }),
+            subscriber(PROJECT_SOURCE_BOUND, onProjectSourceBound),
+            subscriber(PROJECT_SOURCE_COMMIT_OBSERVED, onProjectSourceCommitObserved)
+        ],
+        workers: [
+            {
+                taskQueue: DEFINITIONS_TASK_QUEUE,
+                workflowsPath,
+                activities: ()=>createDefinitionSyncActivities(sourceControl, integrationValidation),
+                workflows: []
+            }
+        ]
+    };
+}
+
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["import {dirname, resolve} from 'node:path';\nimport {fileURLToPath} from 'node:url';\nimport {\n  DEFINITION_RESOLVED,\n  type DefinitionsEventMap,\n  definitionsEventSchemas,\n} from '@shipfox/api-definitions-dto';\nimport type {\n  AgentToolSelectionCatalogs,\n  GetIntegrationConnectionByIdFn,\n  IntegrationSourceControlService,\n  LoadWorkspaceConnectionSnapshot,\n} from '@shipfox/api-integration-core';\nimport {\n  PROJECT_SOURCE_BOUND,\n  PROJECT_SOURCE_COMMIT_OBSERVED,\n  type ProjectsEventMap,\n} from '@shipfox/api-projects-dto';\nimport {type ShipfoxModule, subscriberFactory} from '@shipfox/node-module';\nimport {logger} from '@shipfox/node-opentelemetry';\nimport {db, definitionsOutbox, migrationsPath} from '#db/index.js';\nimport {createDefinitionRoutes} from '#presentation/index.js';\nimport {\n  onProjectSourceBound,\n  onProjectSourceCommitObserved,\n} from '#presentation/subscribers/index.js';\nimport {createDefinitionSyncActivities, DEFINITIONS_TASK_QUEUE} from '#temporal/index.js';\n\nexport type {\n  WorkflowDefinition,\n  WorkflowDefinitionPayload,\n  WorkflowEnvTemplates,\n  WorkflowModel,\n  WorkflowModelJobCheckout,\n  WorkflowSourceSnapshot,\n  WorkflowSpec,\n} from '#core/index.js';\nexport {\n  DEFAULT_JOB_CHECKOUT,\n  DEFAULT_JOB_SUCCESS,\n  DEFAULT_RUN_TIMEOUT_MS,\n  normalizeWorkflowDocument,\n} from '#core/index.js';\nexport {db, definitionsOutbox, getDefinitionById, migrationsPath} from '#db/index.js';\nexport {routes} from '#presentation/index.js';\n\nconst packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), '..');\nconst workflowsPath = resolve(packageRoot, 'dist/temporal/workflows/index.js');\n\nconst subscriber = subscriberFactory<DefinitionsEventMap & ProjectsEventMap>();\n\nexport interface CreateDefinitionsModuleOptions {\n  sourceControl: IntegrationSourceControlService;\n  agentToolSelectionCatalogs?: AgentToolSelectionCatalogs | undefined;\n  loadWorkspaceConnectionSnapshot?: LoadWorkspaceConnectionSnapshot | undefined;\n  getIntegrationConnectionById?: GetIntegrationConnectionByIdFn | undefined;\n}\n\nexport function createDefinitionsModule({\n  sourceControl,\n  agentToolSelectionCatalogs,\n  loadWorkspaceConnectionSnapshot,\n  getIntegrationConnectionById,\n}: CreateDefinitionsModuleOptions): ShipfoxModule {\n  const integrationValidation =\n    agentToolSelectionCatalogs === undefined ||\n    loadWorkspaceConnectionSnapshot === undefined ||\n    getIntegrationConnectionById === undefined\n      ? undefined\n      : {\n          agentToolSelectionCatalogs,\n          loadWorkspaceConnectionSnapshot,\n          getIntegrationConnectionById,\n        };\n\n  return {\n    name: 'definitions',\n    database: {db, migrationsPath},\n    routes: createDefinitionRoutes({\n      agentToolSelectionCatalogs,\n      loadWorkspaceConnectionSnapshot,\n      getIntegrationConnectionById,\n    }),\n    publishers: [\n      {name: 'definitions', table: definitionsOutbox, db, eventSchemas: definitionsEventSchemas},\n    ],\n    subscribers: [\n      subscriber(DEFINITION_RESOLVED, (_payload, event) => {\n        logger().info({event}, 'Definition resolved');\n        return Promise.resolve();\n      }),\n      subscriber(PROJECT_SOURCE_BOUND, onProjectSourceBound),\n      subscriber(PROJECT_SOURCE_COMMIT_OBSERVED, onProjectSourceCommitObserved),\n    ],\n    workers: [\n      {\n        taskQueue: DEFINITIONS_TASK_QUEUE,\n        workflowsPath,\n        activities: () => createDefinitionSyncActivities(sourceControl, integrationValidation),\n        workflows: [],\n      },\n    ],\n  };\n}\n"],"names":["dirname","resolve","fileURLToPath","DEFINITION_RESOLVED","definitionsEventSchemas","PROJECT_SOURCE_BOUND","PROJECT_SOURCE_COMMIT_OBSERVED","subscriberFactory","logger","db","definitionsOutbox","migrationsPath","createDefinitionRoutes","onProjectSourceBound","onProjectSourceCommitObserved","createDefinitionSyncActivities","DEFINITIONS_TASK_QUEUE","DEFAULT_JOB_CHECKOUT","DEFAULT_JOB_SUCCESS","DEFAULT_RUN_TIMEOUT_MS","normalizeWorkflowDocument","getDefinitionById","routes","packageRoot","url","workflowsPath","subscriber","createDefinitionsModule","sourceControl","agentToolSelectionCatalogs","loadWorkspaceConnectionSnapshot","getIntegrationConnectionById","integrationValidation","undefined","name","database","publishers","table","eventSchemas","subscribers","_payload","event","info","Promise","workers","taskQueue","activities","workflows"],"mappings":"AAAA,SAAQA,OAAO,EAAEC,OAAO,QAAO,YAAY;AAC3C,SAAQC,aAAa,QAAO,WAAW;AACvC,SACEC,mBAAmB,EAEnBC,uBAAuB,QAClB,+BAA+B;AAOtC,SACEC,oBAAoB,EACpBC,8BAA8B,QAEzB,4BAA4B;AACnC,SAA4BC,iBAAiB,QAAO,uBAAuB;AAC3E,SAAQC,MAAM,QAAO,8BAA8B;AACnD,SAAQC,EAAE,EAAEC,iBAAiB,EAAEC,cAAc,QAAO,eAAe;AACnE,SAAQC,sBAAsB,QAAO,yBAAyB;AAC9D,SACEC,oBAAoB,EACpBC,6BAA6B,QACxB,qCAAqC;AAC5C,SAAQC,8BAA8B,EAAEC,sBAAsB,QAAO,qBAAqB;AAW1F,SACEC,oBAAoB,EACpBC,mBAAmB,EACnBC,sBAAsB,EACtBC,yBAAyB,QACpB,iBAAiB;AACxB,SAAQX,EAAE,EAAEC,iBAAiB,EAAEW,iBAAiB,EAAEV,cAAc,QAAO,eAAe;AACtF,SAAQW,MAAM,QAAO,yBAAyB;AAE9C,MAAMC,cAActB,QAAQD,QAAQE,cAAc,YAAYsB,GAAG,IAAI;AACrE,MAAMC,gBAAgBxB,QAAQsB,aAAa;AAE3C,MAAMG,aAAanB;AASnB,OAAO,SAASoB,wBAAwB,EACtCC,aAAa,EACbC,0BAA0B,EAC1BC,+BAA+B,EAC/BC,4BAA4B,EACG;IAC/B,MAAMC,wBACJH,+BAA+BI,aAC/BH,oCAAoCG,aACpCF,iCAAiCE,YAC7BA,YACA;QACEJ;QACAC;QACAC;IACF;IAEN,OAAO;QACLG,MAAM;QACNC,UAAU;YAAC1B;YAAIE;QAAc;QAC7BW,QAAQV,uBAAuB;YAC7BiB;YACAC;YACAC;QACF;QACAK,YAAY;YACV;gBAACF,MAAM;gBAAeG,OAAO3B;gBAAmBD;gBAAI6B,cAAclC;YAAuB;SAC1F;QACDmC,aAAa;YACXb,WAAWvB,qBAAqB,CAACqC,UAAUC;gBACzCjC,SAASkC,IAAI,CAAC;oBAACD;gBAAK,GAAG;gBACvB,OAAOE,QAAQ1C,OAAO;YACxB;YACAyB,WAAWrB,sBAAsBQ;YACjCa,WAAWpB,gCAAgCQ;SAC5C;QACD8B,SAAS;YACP;gBACEC,WAAW7B;gBACXS;gBACAqB,YAAY,IAAM/B,+BAA+Ba,eAAeI;gBAChEe,WAAW,EAAE;YACf;SACD;IACH;AACF"}

package/dist/presentation/dto/definition.d.ts

@@ -0,0 +1,6 @@
+import type { DefinitionDto, DefinitionSyncSummaryDto } from '@shipfox/api-definitions-dto';
+import type { DefinitionSyncState } from '#core/entities/sync-state.js';
+import type { WorkflowDefinition } from '#core/entities/workflow-definition.js';
+export declare function toDefinitionDto(definition: WorkflowDefinition): DefinitionDto;
+export declare function toDefinitionSyncSummaryDto(syncState: DefinitionSyncState | undefined): DefinitionSyncSummaryDto | null;
+//# sourceMappingURL=definition.d.ts.map

package/dist/presentation/dto/definition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../../src/presentation/dto/definition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,aAAa,EAAE,wBAAwB,EAAC,MAAM,8BAA8B,CAAC;AAC1F,OAAO,KAAK,EAAC,mBAAmB,EAAC,MAAM,8BAA8B,CAAC;AACtE,OAAO,KAAK,EAAC,kBAAkB,EAAC,MAAM,uCAAuC,CAAC;AAG9E,wBAAgB,eAAe,CAAC,UAAU,EAAE,kBAAkB,GAAG,aAAa,CAmB7E;AAED,wBAAgB,0BAA0B,CACxC,SAAS,EAAE,mBAAmB,GAAG,SAAS,GACzC,wBAAwB,GAAG,IAAI,CAYjC"}

package/dist/presentation/dto/definition.js

@@ -0,0 +1,35 @@
+import { UNRESOLVED_SYNC_REF } from '#core/sync-definitions.js';
+export function toDefinitionDto(definition) {
+    const manualEntry = Object.entries(definition.document.triggers ?? {}).find(([, trigger])=>trigger.source === 'manual');
+    return {
+        id: definition.id,
+        project_id: definition.projectId,
+        config_path: definition.configPath,
+        source: definition.source,
+        sha: definition.sha,
+        ref: definition.ref,
+        name: definition.name,
+        workflow_document: definition.document,
+        workflow_model: definition.model,
+        manual_trigger: manualEntry ? {
+            name: manualEntry[0]
+        } : null,
+        fetched_at: definition.fetchedAt.toISOString(),
+        created_at: definition.createdAt.toISOString(),
+        updated_at: definition.updatedAt.toISOString()
+    };
+}
+export function toDefinitionSyncSummaryDto(syncState) {
+    if (!syncState) return null;
+    return {
+        ref: syncState.ref === UNRESOLVED_SYNC_REF ? null : syncState.ref,
+        status: syncState.status,
+        last_sync_at: (syncState.finishedAt ?? syncState.updatedAt).toISOString(),
+        started_at: syncState.startedAt?.toISOString() ?? null,
+        finished_at: syncState.finishedAt?.toISOString() ?? null,
+        last_error_code: syncState.lastErrorCode,
+        last_error_message: syncState.lastErrorMessage
+    };
+}
+
+//# sourceMappingURL=definition.js.map

package/dist/presentation/dto/definition.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/presentation/dto/definition.ts"],"sourcesContent":["import type {DefinitionDto, DefinitionSyncSummaryDto} from '@shipfox/api-definitions-dto';\nimport type {DefinitionSyncState} from '#core/entities/sync-state.js';\nimport type {WorkflowDefinition} from '#core/entities/workflow-definition.js';\nimport {UNRESOLVED_SYNC_REF} from '#core/sync-definitions.js';\n\nexport function toDefinitionDto(definition: WorkflowDefinition): DefinitionDto {\n  const manualEntry = Object.entries(definition.document.triggers ?? {}).find(\n    ([, trigger]) => trigger.source === 'manual',\n  );\n  return {\n    id: definition.id,\n    project_id: definition.projectId,\n    config_path: definition.configPath,\n    source: definition.source,\n    sha: definition.sha,\n    ref: definition.ref,\n    name: definition.name,\n    workflow_document: definition.document,\n    workflow_model: definition.model,\n    manual_trigger: manualEntry ? {name: manualEntry[0]} : null,\n    fetched_at: definition.fetchedAt.toISOString(),\n    created_at: definition.createdAt.toISOString(),\n    updated_at: definition.updatedAt.toISOString(),\n  };\n}\n\nexport function toDefinitionSyncSummaryDto(\n  syncState: DefinitionSyncState | undefined,\n): DefinitionSyncSummaryDto | null {\n  if (!syncState) return null;\n\n  return {\n    ref: syncState.ref === UNRESOLVED_SYNC_REF ? null : syncState.ref,\n    status: syncState.status,\n    last_sync_at: (syncState.finishedAt ?? syncState.updatedAt).toISOString(),\n    started_at: syncState.startedAt?.toISOString() ?? null,\n    finished_at: syncState.finishedAt?.toISOString() ?? null,\n    last_error_code: syncState.lastErrorCode,\n    last_error_message: syncState.lastErrorMessage,\n  };\n}\n"],"names":["UNRESOLVED_SYNC_REF","toDefinitionDto","definition","manualEntry","Object","entries","document","triggers","find","trigger","source","id","project_id","projectId","config_path","configPath","sha","ref","name","workflow_document","workflow_model","model","manual_trigger","fetched_at","fetchedAt","toISOString","created_at","createdAt","updated_at","updatedAt","toDefinitionSyncSummaryDto","syncState","status","last_sync_at","finishedAt","started_at","startedAt","finished_at","last_error_code","lastErrorCode","last_error_message","lastErrorMessage"],"mappings":"AAGA,SAAQA,mBAAmB,QAAO,4BAA4B;AAE9D,OAAO,SAASC,gBAAgBC,UAA8B;IAC5D,MAAMC,cAAcC,OAAOC,OAAO,CAACH,WAAWI,QAAQ,CAACC,QAAQ,IAAI,CAAC,GAAGC,IAAI,CACzE,CAAC,GAAGC,QAAQ,GAAKA,QAAQC,MAAM,KAAK;IAEtC,OAAO;QACLC,IAAIT,WAAWS,EAAE;QACjBC,YAAYV,WAAWW,SAAS;QAChCC,aAAaZ,WAAWa,UAAU;QAClCL,QAAQR,WAAWQ,MAAM;QACzBM,KAAKd,WAAWc,GAAG;QACnBC,KAAKf,WAAWe,GAAG;QACnBC,MAAMhB,WAAWgB,IAAI;QACrBC,mBAAmBjB,WAAWI,QAAQ;QACtCc,gBAAgBlB,WAAWmB,KAAK;QAChCC,gBAAgBnB,cAAc;YAACe,MAAMf,WAAW,CAAC,EAAE;QAAA,IAAI;QACvDoB,YAAYrB,WAAWsB,SAAS,CAACC,WAAW;QAC5CC,YAAYxB,WAAWyB,SAAS,CAACF,WAAW;QAC5CG,YAAY1B,WAAW2B,SAAS,CAACJ,WAAW;IAC9C;AACF;AAEA,OAAO,SAASK,2BACdC,SAA0C;IAE1C,IAAI,CAACA,WAAW,OAAO;IAEvB,OAAO;QACLd,KAAKc,UAAUd,GAAG,KAAKjB,sBAAsB,OAAO+B,UAAUd,GAAG;QACjEe,QAAQD,UAAUC,MAAM;QACxBC,cAAc,AAACF,CAAAA,UAAUG,UAAU,IAAIH,UAAUF,SAAS,AAAD,EAAGJ,WAAW;QACvEU,YAAYJ,UAAUK,SAAS,EAAEX,iBAAiB;QAClDY,aAAaN,UAAUG,UAAU,EAAET,iBAAiB;QACpDa,iBAAiBP,UAAUQ,aAAa;QACxCC,oBAAoBT,UAAUU,gBAAgB;IAChD;AACF"}

package/dist/presentation/dto/index.d.ts

@@ -0,0 +1,2 @@
+export { toDefinitionDto, toDefinitionSyncSummaryDto } from './definition.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/presentation/dto/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/presentation/dto/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,eAAe,EAAE,0BAA0B,EAAC,MAAM,iBAAiB,CAAC"}

package/dist/presentation/dto/index.js

@@ -0,0 +1,3 @@
+export { toDefinitionDto, toDefinitionSyncSummaryDto } from './definition.js';
+
+//# sourceMappingURL=index.js.map

package/dist/presentation/dto/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/presentation/dto/index.ts"],"sourcesContent":["export {toDefinitionDto, toDefinitionSyncSummaryDto} from './definition.js';\n"],"names":["toDefinitionDto","toDefinitionSyncSummaryDto"],"mappings":"AAAA,SAAQA,eAAe,EAAEC,0BAA0B,QAAO,kBAAkB"}

package/dist/presentation/index.d.ts

@@ -0,0 +1,2 @@
+export { createDefinitionRoutes, definitionRoutes as routes } from './routes/index.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/presentation/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,sBAAsB,EAAE,gBAAgB,IAAI,MAAM,EAAC,MAAM,mBAAmB,CAAC"}

package/dist/presentation/index.js

@@ -0,0 +1,3 @@
+export { createDefinitionRoutes, definitionRoutes as routes } from './routes/index.js';
+
+//# sourceMappingURL=index.js.map

package/dist/presentation/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/presentation/index.ts"],"sourcesContent":["export {createDefinitionRoutes, definitionRoutes as routes} from './routes/index.js';\n"],"names":["createDefinitionRoutes","definitionRoutes","routes"],"mappings":"AAAA,SAAQA,sBAAsB,EAAEC,oBAAoBC,MAAM,QAAO,oBAAoB"}

package/dist/presentation/routes/create-definition.d.ts

@@ -0,0 +1,9 @@
+import type { AgentToolSelectionCatalogs, GetIntegrationConnectionByIdFn, LoadWorkspaceConnectionSnapshot } from '@shipfox/api-integration-core';
+export interface CreateDefinitionRouteOptions {
+    agentToolSelectionCatalogs?: AgentToolSelectionCatalogs | undefined;
+    loadWorkspaceConnectionSnapshot?: LoadWorkspaceConnectionSnapshot | undefined;
+    getIntegrationConnectionById?: GetIntegrationConnectionByIdFn | undefined;
+}
+export declare function buildCreateDefinitionRoute(options?: CreateDefinitionRouteOptions): import("@shipfox/node-fastify").RouteDefinition;
+export declare const createDefinitionRoute: import("@shipfox/node-fastify").RouteDefinition;
+//# sourceMappingURL=create-definition.d.ts.map

package/dist/presentation/routes/create-definition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-definition.d.ts","sourceRoot":"","sources":["../../../src/presentation/routes/create-definition.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EACV,0BAA0B,EAC1B,8BAA8B,EAC9B,+BAA+B,EAChC,MAAM,+BAA+B,CAAC;AAUvC,MAAM,WAAW,4BAA4B;IAC3C,0BAA0B,CAAC,EAAE,0BAA0B,GAAG,SAAS,CAAC;IACpE,+BAA+B,CAAC,EAAE,+BAA+B,GAAG,SAAS,CAAC;IAC9E,4BAA4B,CAAC,EAAE,8BAA8B,GAAG,SAAS,CAAC;CAC3E;AAED,wBAAgB,0BAA0B,CAAC,OAAO,GAAE,4BAAiC,mDAyEpF;AAED,eAAO,MAAM,qBAAqB,iDAA+B,CAAC"}