@shipfox/api-definitions 2.0.0

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

@@ -0,0 +1,237 @@
+import type { WorkflowDefinition, WorkflowDefinitionPayload } from '#core/entities/workflow-definition.js';
+export declare const definitionSourceEnum: import("drizzle-orm/pg-core").PgEnum<["manual", "vcs"]>;
+export declare const workflowDefinitions: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "workflow_definitions";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "workflow_definitions";
+            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: "workflow_definitions";
+            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: "workflow_definitions";
+            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;
+        }, {}, {}>;
+        source: import("drizzle-orm/pg-core").PgColumn<{
+            name: "source";
+            tableName: "workflow_definitions";
+            dataType: "string";
+            columnType: "PgEnumColumn";
+            data: "manual" | "vcs";
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["manual", "vcs"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        sha: import("drizzle-orm/pg-core").PgColumn<{
+            name: "sha";
+            tableName: "workflow_definitions";
+            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;
+        }, {}, {}>;
+        ref: import("drizzle-orm/pg-core").PgColumn<{
+            name: "ref";
+            tableName: "workflow_definitions";
+            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;
+        }, {}, {}>;
+        name: import("drizzle-orm/pg-core").PgColumn<{
+            name: "name";
+            tableName: "workflow_definitions";
+            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;
+        }, {}, {}>;
+        definition: import("drizzle-orm/pg-core").PgColumn<{
+            name: "definition";
+            tableName: "workflow_definitions";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: WorkflowDefinitionPayload;
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: WorkflowDefinitionPayload;
+        }>;
+        contentHash: import("drizzle-orm/pg-core").PgColumn<{
+            name: "content_hash";
+            tableName: "workflow_definitions";
+            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;
+        }, {}, {}>;
+        fetchedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "fetched_at";
+            tableName: "workflow_definitions";
+            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;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "workflow_definitions";
+            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: "workflow_definitions";
+            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;
+        }, {}, {}>;
+        deletedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "deleted_at";
+            tableName: "workflow_definitions";
+            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;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+export type DefinitionDb = typeof workflowDefinitions.$inferSelect;
+export type DefinitionCreateDb = typeof workflowDefinitions.$inferInsert;
+export type DefinitionUpdateDb = Partial<DefinitionCreateDb>;
+export declare function toDefinition(row: DefinitionDb): WorkflowDefinition;
+//# sourceMappingURL=definitions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"definitions.d.ts","sourceRoot":"","sources":["../../../src/db/schema/definitions.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,kBAAkB,EAClB,yBAAyB,EAC1B,MAAM,uCAAuC,CAAC;AAG/C,eAAO,MAAM,oBAAoB,yDAAkD,CAAC;AAEpF,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuC/B,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG,OAAO,mBAAmB,CAAC,YAAY,CAAC;AACnE,MAAM,MAAM,kBAAkB,GAAG,OAAO,mBAAmB,CAAC,YAAY,CAAC;AACzE,MAAM,MAAM,kBAAkB,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAAC;AAE7D,wBAAgB,YAAY,CAAC,GAAG,EAAE,YAAY,GAAG,kBAAkB,CAmBlE"}

package/dist/db/schema/definitions.js

@@ -0,0 +1,63 @@
+import { uuidv7PrimaryKey } from '@shipfox/node-drizzle';
+import { sql } from 'drizzle-orm';
+import { check, index, jsonb, pgEnum, text, timestamp, uniqueIndex, uuid } from 'drizzle-orm/pg-core';
+import { pgTable } from './common.js';
+export const definitionSourceEnum = pgEnum('definitions_source', [
+    'manual',
+    'vcs'
+]);
+export const workflowDefinitions = pgTable('workflow_definitions', {
+    id: uuidv7PrimaryKey(),
+    projectId: uuid('project_id').notNull(),
+    configPath: text('config_path'),
+    source: definitionSourceEnum('source').notNull().default('manual'),
+    sha: text('sha'),
+    ref: text('ref'),
+    name: text('name').notNull(),
+    definition: jsonb('definition').notNull().$type(),
+    contentHash: text('content_hash'),
+    fetchedAt: timestamp('fetched_at', {
+        withTimezone: true
+    }).notNull().defaultNow(),
+    createdAt: timestamp('created_at', {
+        withTimezone: true
+    }).notNull().defaultNow(),
+    updatedAt: timestamp('updated_at', {
+        withTimezone: true
+    }).notNull().defaultNow(),
+    deletedAt: timestamp('deleted_at', {
+        withTimezone: true
+    })
+}, (table)=>[
+        // Manual definitions only (no ref, no sha); VCS uniqueness is sha_lookup/ref_lookup.
+        // A source-agnostic predicate here collides VCS upserts on a non-arbiter index. ENG-659.
+        uniqueIndex('definitions_wd_manual_unique').on(table.projectId, table.configPath).where(sql`"config_path" IS NOT NULL AND "ref" IS NULL AND "sha" IS NULL`),
+        uniqueIndex('definitions_wd_sha_lookup').on(table.projectId, table.sha, table.configPath).where(sql`"sha" IS NOT NULL`),
+        uniqueIndex('definitions_wd_ref_lookup').on(table.projectId, table.ref, table.configPath).where(sql`"ref" IS NOT NULL`),
+        index('definitions_wd_project_name_id_idx').on(table.projectId, table.name, table.id).where(sql`"deleted_at" IS NULL`),
+        // Binds source to its git coordinates so the partial indexes above stay
+        // unambiguous: vcs rows carry a ref or sha; manual rows carry neither.
+        check('definitions_wd_source_ref_sha_consistent', sql`("source" = 'vcs') = ("ref" IS NOT NULL OR "sha" IS NOT NULL)`)
+    ]);
+export function toDefinition(row) {
+    return {
+        id: row.id,
+        projectId: row.projectId,
+        configPath: row.configPath,
+        source: row.source,
+        sha: row.sha,
+        ref: row.ref,
+        name: row.name,
+        definition: row.definition.document,
+        document: row.definition.document,
+        model: row.definition.model,
+        sourceSnapshot: row.definition.sourceSnapshot ?? null,
+        contentHash: row.contentHash,
+        fetchedAt: row.fetchedAt,
+        createdAt: row.createdAt,
+        updatedAt: row.updatedAt,
+        deletedAt: row.deletedAt
+    };
+}
+
+//# sourceMappingURL=definitions.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/db/schema/definitions.ts"],"sourcesContent":["import {uuidv7PrimaryKey} from '@shipfox/node-drizzle';\nimport {sql} from 'drizzle-orm';\nimport {check, index, jsonb, pgEnum, text, timestamp, uniqueIndex, uuid} from 'drizzle-orm/pg-core';\nimport type {\n  WorkflowDefinition,\n  WorkflowDefinitionPayload,\n} from '#core/entities/workflow-definition.js';\nimport {pgTable} from './common.js';\n\nexport const definitionSourceEnum = pgEnum('definitions_source', ['manual', 'vcs']);\n\nexport const workflowDefinitions = pgTable(\n  'workflow_definitions',\n  {\n    id: uuidv7PrimaryKey(),\n    projectId: uuid('project_id').notNull(),\n    configPath: text('config_path'),\n    source: definitionSourceEnum('source').notNull().default('manual'),\n    sha: text('sha'),\n    ref: text('ref'),\n    name: text('name').notNull(),\n    definition: jsonb('definition').notNull().$type<WorkflowDefinitionPayload>(),\n    contentHash: text('content_hash'),\n    fetchedAt: timestamp('fetched_at', {withTimezone: true}).notNull().defaultNow(),\n    createdAt: timestamp('created_at', {withTimezone: true}).notNull().defaultNow(),\n    updatedAt: timestamp('updated_at', {withTimezone: true}).notNull().defaultNow(),\n    deletedAt: timestamp('deleted_at', {withTimezone: true}),\n  },\n  (table) => [\n    // Manual definitions only (no ref, no sha); VCS uniqueness is sha_lookup/ref_lookup.\n    // A source-agnostic predicate here collides VCS upserts on a non-arbiter index. ENG-659.\n    uniqueIndex('definitions_wd_manual_unique')\n      .on(table.projectId, table.configPath)\n      .where(sql`\"config_path\" IS NOT NULL AND \"ref\" IS NULL AND \"sha\" IS NULL`),\n    uniqueIndex('definitions_wd_sha_lookup')\n      .on(table.projectId, table.sha, table.configPath)\n      .where(sql`\"sha\" IS NOT NULL`),\n    uniqueIndex('definitions_wd_ref_lookup')\n      .on(table.projectId, table.ref, table.configPath)\n      .where(sql`\"ref\" IS NOT NULL`),\n    index('definitions_wd_project_name_id_idx')\n      .on(table.projectId, table.name, table.id)\n      .where(sql`\"deleted_at\" IS NULL`),\n    // Binds source to its git coordinates so the partial indexes above stay\n    // unambiguous: vcs rows carry a ref or sha; manual rows carry neither.\n    check(\n      'definitions_wd_source_ref_sha_consistent',\n      sql`(\"source\" = 'vcs') = (\"ref\" IS NOT NULL OR \"sha\" IS NOT NULL)`,\n    ),\n  ],\n);\n\nexport type DefinitionDb = typeof workflowDefinitions.$inferSelect;\nexport type DefinitionCreateDb = typeof workflowDefinitions.$inferInsert;\nexport type DefinitionUpdateDb = Partial<DefinitionCreateDb>;\n\nexport function toDefinition(row: DefinitionDb): WorkflowDefinition {\n  return {\n    id: row.id,\n    projectId: row.projectId,\n    configPath: row.configPath,\n    source: row.source,\n    sha: row.sha,\n    ref: row.ref,\n    name: row.name,\n    definition: row.definition.document,\n    document: row.definition.document,\n    model: row.definition.model,\n    sourceSnapshot: row.definition.sourceSnapshot ?? null,\n    contentHash: row.contentHash,\n    fetchedAt: row.fetchedAt,\n    createdAt: row.createdAt,\n    updatedAt: row.updatedAt,\n    deletedAt: row.deletedAt,\n  };\n}\n"],"names":["uuidv7PrimaryKey","sql","check","index","jsonb","pgEnum","text","timestamp","uniqueIndex","uuid","pgTable","definitionSourceEnum","workflowDefinitions","id","projectId","notNull","configPath","source","default","sha","ref","name","definition","$type","contentHash","fetchedAt","withTimezone","defaultNow","createdAt","updatedAt","deletedAt","table","on","where","toDefinition","row","document","model","sourceSnapshot"],"mappings":"AAAA,SAAQA,gBAAgB,QAAO,wBAAwB;AACvD,SAAQC,GAAG,QAAO,cAAc;AAChC,SAAQC,KAAK,EAAEC,KAAK,EAAEC,KAAK,EAAEC,MAAM,EAAEC,IAAI,EAAEC,SAAS,EAAEC,WAAW,EAAEC,IAAI,QAAO,sBAAsB;AAKpG,SAAQC,OAAO,QAAO,cAAc;AAEpC,OAAO,MAAMC,uBAAuBN,OAAO,sBAAsB;IAAC;IAAU;CAAM,EAAE;AAEpF,OAAO,MAAMO,sBAAsBF,QACjC,wBACA;IACEG,IAAIb;IACJc,WAAWL,KAAK,cAAcM,OAAO;IACrCC,YAAYV,KAAK;IACjBW,QAAQN,qBAAqB,UAAUI,OAAO,GAAGG,OAAO,CAAC;IACzDC,KAAKb,KAAK;IACVc,KAAKd,KAAK;IACVe,MAAMf,KAAK,QAAQS,OAAO;IAC1BO,YAAYlB,MAAM,cAAcW,OAAO,GAAGQ,KAAK;IAC/CC,aAAalB,KAAK;IAClBmB,WAAWlB,UAAU,cAAc;QAACmB,cAAc;IAAI,GAAGX,OAAO,GAAGY,UAAU;IAC7EC,WAAWrB,UAAU,cAAc;QAACmB,cAAc;IAAI,GAAGX,OAAO,GAAGY,UAAU;IAC7EE,WAAWtB,UAAU,cAAc;QAACmB,cAAc;IAAI,GAAGX,OAAO,GAAGY,UAAU;IAC7EG,WAAWvB,UAAU,cAAc;QAACmB,cAAc;IAAI;AACxD,GACA,CAACK,QAAU;QACT,qFAAqF;QACrF,yFAAyF;QACzFvB,YAAY,gCACTwB,EAAE,CAACD,MAAMjB,SAAS,EAAEiB,MAAMf,UAAU,EACpCiB,KAAK,CAAChC,GAAG,CAAC,6DAA6D,CAAC;QAC3EO,YAAY,6BACTwB,EAAE,CAACD,MAAMjB,SAAS,EAAEiB,MAAMZ,GAAG,EAAEY,MAAMf,UAAU,EAC/CiB,KAAK,CAAChC,GAAG,CAAC,iBAAiB,CAAC;QAC/BO,YAAY,6BACTwB,EAAE,CAACD,MAAMjB,SAAS,EAAEiB,MAAMX,GAAG,EAAEW,MAAMf,UAAU,EAC/CiB,KAAK,CAAChC,GAAG,CAAC,iBAAiB,CAAC;QAC/BE,MAAM,sCACH6B,EAAE,CAACD,MAAMjB,SAAS,EAAEiB,MAAMV,IAAI,EAAEU,MAAMlB,EAAE,EACxCoB,KAAK,CAAChC,GAAG,CAAC,oBAAoB,CAAC;QAClC,wEAAwE;QACxE,uEAAuE;QACvEC,MACE,4CACAD,GAAG,CAAC,6DAA6D,CAAC;KAErE,EACD;AAMF,OAAO,SAASiC,aAAaC,GAAiB;IAC5C,OAAO;QACLtB,IAAIsB,IAAItB,EAAE;QACVC,WAAWqB,IAAIrB,SAAS;QACxBE,YAAYmB,IAAInB,UAAU;QAC1BC,QAAQkB,IAAIlB,MAAM;QAClBE,KAAKgB,IAAIhB,GAAG;QACZC,KAAKe,IAAIf,GAAG;QACZC,MAAMc,IAAId,IAAI;QACdC,YAAYa,IAAIb,UAAU,CAACc,QAAQ;QACnCA,UAAUD,IAAIb,UAAU,CAACc,QAAQ;QACjCC,OAAOF,IAAIb,UAAU,CAACe,KAAK;QAC3BC,gBAAgBH,IAAIb,UAAU,CAACgB,cAAc,IAAI;QACjDd,aAAaW,IAAIX,WAAW;QAC5BC,WAAWU,IAAIV,SAAS;QACxBG,WAAWO,IAAIP,SAAS;QACxBC,WAAWM,IAAIN,SAAS;QACxBC,WAAWK,IAAIL,SAAS;IAC1B;AACF"}

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

@@ -0,0 +1,195 @@
+export declare const definitionsOutbox: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "outbox";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "outbox";
+            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;
+        }, {}, {}>;
+        eventType: import("drizzle-orm/pg-core").PgColumn<{
+            name: "event_type";
+            tableName: "outbox";
+            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;
+        }, {}, {}>;
+        orderingKey: import("drizzle-orm/pg-core").PgColumn<{
+            name: "ordering_key";
+            tableName: "outbox";
+            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;
+        }, {}, {}>;
+        payload: import("drizzle-orm/pg-core").PgColumn<{
+            name: "payload";
+            tableName: "outbox";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: unknown;
+            driverParam: unknown;
+            notNull: true;
+            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: "outbox";
+            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;
+        }, {}, {}>;
+        dispatchedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "dispatched_at";
+            tableName: "outbox";
+            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;
+        }, {}, {}>;
+        dispatchAttempts: import("drizzle-orm/pg-core").PgColumn<{
+            name: "dispatch_attempts";
+            tableName: "outbox";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        nextDispatchAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "next_dispatch_at";
+            tableName: "outbox";
+            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;
+        }, {}, {}>;
+        lastDispatchError: import("drizzle-orm/pg-core").PgColumn<{
+            name: "last_dispatch_error";
+            tableName: "outbox";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: unknown;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        lastDispatchFailedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "last_dispatch_failed_at";
+            tableName: "outbox";
+            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;
+        }, {}, {}>;
+        deadLetteredAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "dead_lettered_at";
+            tableName: "outbox";
+            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;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+//# sourceMappingURL=outbox.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"outbox.d.ts","sourceRoot":"","sources":["../../../src/db/schema/outbox.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAA6B,CAAC"}

package/dist/db/schema/outbox.js

@@ -0,0 +1,5 @@
+import { createOutboxTable } from '@shipfox/node-outbox';
+import { pgTable } from './common.js';
+export const definitionsOutbox = createOutboxTable(pgTable);
+
+//# sourceMappingURL=outbox.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/db/schema/outbox.ts"],"sourcesContent":["import {createOutboxTable} from '@shipfox/node-outbox';\nimport {pgTable} from './common.js';\n\nexport const definitionsOutbox = createOutboxTable(pgTable);\n"],"names":["createOutboxTable","pgTable","definitionsOutbox"],"mappings":"AAAA,SAAQA,iBAAiB,QAAO,uBAAuB;AACvD,SAAQC,OAAO,QAAO,cAAc;AAEpC,OAAO,MAAMC,oBAAoBF,kBAAkBC,SAAS"}