@shipfox/api-integration-core 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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAIlB,CAAC;AAIF,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 { integrationConnections } from './schema/connections.js';
+import { integrationsOutbox } from './schema/outbox.js';
+import { integrationsWebhookDeliveries } from './schema/webhook-deliveries.js';
+export const schema = {
+    integrationConnections,
+    integrationsOutbox,
+    integrationsWebhookDeliveries
+};
+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 {integrationConnections} from './schema/connections.js';\nimport {integrationsOutbox} from './schema/outbox.js';\nimport {integrationsWebhookDeliveries} from './schema/webhook-deliveries.js';\n\nexport const schema = {\n  integrationConnections,\n  integrationsOutbox,\n  integrationsWebhookDeliveries,\n};\n\nlet _db: NodePgDatabase<typeof schema> | undefined;\n\nexport function db() {\n  if (!_db) _db = drizzle(pgClient(), {schema});\n  return _db;\n}\n\nexport function closeDb(): void {\n  _db = undefined;\n}\n"],"names":["drizzle","pgClient","integrationConnections","integrationsOutbox","integrationsWebhookDeliveries","schema","_db","db","closeDb","undefined"],"mappings":"AAAA,SAAQA,OAAO,QAA4B,wBAAwB;AACnE,SAAQC,QAAQ,QAAO,yBAAyB;AAChD,SAAQC,sBAAsB,QAAO,0BAA0B;AAC/D,SAAQC,kBAAkB,QAAO,qBAAqB;AACtD,SAAQC,6BAA6B,QAAO,iCAAiC;AAE7E,OAAO,MAAMC,SAAS;IACpBH;IACAC;IACAC;AACF,EAAE;AAEF,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/migrations.d.ts

@@ -0,0 +1,2 @@
+export declare const migrationsPath: string;
+//# sourceMappingURL=migrations.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"migrations.d.ts","sourceRoot":"","sources":["../../src/db/migrations.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,cAAc,QAAoE,CAAC"}

package/dist/db/migrations.js

@@ -0,0 +1,5 @@
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+export const migrationsPath = resolve(dirname(fileURLToPath(import.meta.url)), '../../drizzle');
+
+//# sourceMappingURL=migrations.js.map

package/dist/db/migrations.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/db/migrations.ts"],"sourcesContent":["import {dirname, resolve} from 'node:path';\nimport {fileURLToPath} from 'node:url';\n\nexport const migrationsPath = resolve(dirname(fileURLToPath(import.meta.url)), '../../drizzle');\n"],"names":["dirname","resolve","fileURLToPath","migrationsPath","url"],"mappings":"AAAA,SAAQA,OAAO,EAAEC,OAAO,QAAO,YAAY;AAC3C,SAAQC,aAAa,QAAO,WAAW;AAEvC,OAAO,MAAMC,iBAAiBF,QAAQD,QAAQE,cAAc,YAAYE,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,oDAAmD,CAAC"}

package/dist/db/schema/common.js

@@ -0,0 +1,4 @@
+import { pgTableCreator } from 'drizzle-orm/pg-core';
+export const pgTable = pgTableCreator((name)=>`integrations_${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) => `integrations_${name}`);\n"],"names":["pgTableCreator","pgTable","name"],"mappings":"AAAA,SAAQA,cAAc,QAAO,sBAAsB;AAEnD,OAAO,MAAMC,UAAUD,eAAe,CAACE,OAAS,CAAC,aAAa,EAAEA,MAAM,EAAE"}

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

@@ -0,0 +1,165 @@
+import type { IntegrationConnection } from '#core/entities/connection.js';
+export declare const integrationConnections: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "connections";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "connections";
+            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;
+        }, {}, {}>;
+        workspaceId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "workspace_id";
+            tableName: "connections";
+            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;
+        }, {}, {}>;
+        provider: import("drizzle-orm/pg-core").PgColumn<{
+            name: "provider";
+            tableName: "connections";
+            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;
+        }, {}, {}>;
+        externalAccountId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "external_account_id";
+            tableName: "connections";
+            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;
+        }, {}, {}>;
+        slug: import("drizzle-orm/pg-core").PgColumn<{
+            name: "slug";
+            tableName: "connections";
+            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;
+        }, {}, {}>;
+        displayName: import("drizzle-orm/pg-core").PgColumn<{
+            name: "display_name";
+            tableName: "connections";
+            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;
+        }, {}, {}>;
+        lifecycleStatus: import("drizzle-orm/pg-core").PgColumn<{
+            name: "lifecycle_status";
+            tableName: "connections";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "connections";
+            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: "connections";
+            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 IntegrationConnectionDb = typeof integrationConnections.$inferSelect;
+export type IntegrationConnectionCreateDb = typeof integrationConnections.$inferInsert;
+export declare function toIntegrationConnection(row: IntegrationConnectionDb): IntegrationConnection;
+//# sourceMappingURL=connections.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"connections.d.ts","sourceRoot":"","sources":["../../../src/db/schema/connections.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,qBAAqB,EAEtB,MAAM,8BAA8B,CAAC;AAItC,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsBlC,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG,OAAO,sBAAsB,CAAC,YAAY,CAAC;AACjF,MAAM,MAAM,6BAA6B,GAAG,OAAO,sBAAsB,CAAC,YAAY,CAAC;AAEvF,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,uBAAuB,GAAG,qBAAqB,CAY3F"}

package/dist/db/schema/connections.js

@@ -0,0 +1,37 @@
+import { uuidv7PrimaryKey } from '@shipfox/node-drizzle';
+import { index, text, timestamp, uniqueIndex, uuid } from 'drizzle-orm/pg-core';
+import { pgTable } from './common.js';
+export const integrationConnections = pgTable('connections', {
+    id: uuidv7PrimaryKey(),
+    workspaceId: uuid('workspace_id').notNull(),
+    provider: text('provider').notNull(),
+    externalAccountId: text('external_account_id').notNull(),
+    slug: text('slug').notNull(),
+    displayName: text('display_name').notNull(),
+    lifecycleStatus: text('lifecycle_status').notNull().default('active'),
+    createdAt: timestamp('created_at', {
+        withTimezone: true
+    }).notNull().defaultNow(),
+    updatedAt: timestamp('updated_at', {
+        withTimezone: true
+    }).notNull().defaultNow()
+}, (table)=>[
+        uniqueIndex('integrations_connections_workspace_external_unique').on(table.workspaceId, table.provider, table.externalAccountId),
+        uniqueIndex('integrations_connections_workspace_slug_unique').on(table.workspaceId, table.slug),
+        index('integrations_connections_workspace_id_idx').on(table.workspaceId)
+    ]);
+export function toIntegrationConnection(row) {
+    return {
+        id: row.id,
+        workspaceId: row.workspaceId,
+        provider: row.provider,
+        externalAccountId: row.externalAccountId,
+        slug: row.slug,
+        displayName: row.displayName,
+        lifecycleStatus: row.lifecycleStatus,
+        createdAt: row.createdAt,
+        updatedAt: row.updatedAt
+    };
+}
+
+//# sourceMappingURL=connections.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/db/schema/connections.ts"],"sourcesContent":["import {uuidv7PrimaryKey} from '@shipfox/node-drizzle';\nimport {index, text, timestamp, uniqueIndex, uuid} from 'drizzle-orm/pg-core';\nimport type {\n  IntegrationConnection,\n  IntegrationConnectionLifecycleStatus,\n} from '#core/entities/connection.js';\nimport type {IntegrationProviderKind} from '#core/entities/provider.js';\nimport {pgTable} from './common.js';\n\nexport const integrationConnections = pgTable(\n  'connections',\n  {\n    id: uuidv7PrimaryKey(),\n    workspaceId: uuid('workspace_id').notNull(),\n    provider: text('provider').notNull(),\n    externalAccountId: text('external_account_id').notNull(),\n    slug: text('slug').notNull(),\n    displayName: text('display_name').notNull(),\n    lifecycleStatus: text('lifecycle_status').notNull().default('active'),\n    createdAt: timestamp('created_at', {withTimezone: true}).notNull().defaultNow(),\n    updatedAt: timestamp('updated_at', {withTimezone: true}).notNull().defaultNow(),\n  },\n  (table) => [\n    uniqueIndex('integrations_connections_workspace_external_unique').on(\n      table.workspaceId,\n      table.provider,\n      table.externalAccountId,\n    ),\n    uniqueIndex('integrations_connections_workspace_slug_unique').on(table.workspaceId, table.slug),\n    index('integrations_connections_workspace_id_idx').on(table.workspaceId),\n  ],\n);\n\nexport type IntegrationConnectionDb = typeof integrationConnections.$inferSelect;\nexport type IntegrationConnectionCreateDb = typeof integrationConnections.$inferInsert;\n\nexport function toIntegrationConnection(row: IntegrationConnectionDb): IntegrationConnection {\n  return {\n    id: row.id,\n    workspaceId: row.workspaceId,\n    provider: row.provider as IntegrationProviderKind,\n    externalAccountId: row.externalAccountId,\n    slug: row.slug,\n    displayName: row.displayName,\n    lifecycleStatus: row.lifecycleStatus as IntegrationConnectionLifecycleStatus,\n    createdAt: row.createdAt,\n    updatedAt: row.updatedAt,\n  };\n}\n"],"names":["uuidv7PrimaryKey","index","text","timestamp","uniqueIndex","uuid","pgTable","integrationConnections","id","workspaceId","notNull","provider","externalAccountId","slug","displayName","lifecycleStatus","default","createdAt","withTimezone","defaultNow","updatedAt","table","on","toIntegrationConnection","row"],"mappings":"AAAA,SAAQA,gBAAgB,QAAO,wBAAwB;AACvD,SAAQC,KAAK,EAAEC,IAAI,EAAEC,SAAS,EAAEC,WAAW,EAAEC,IAAI,QAAO,sBAAsB;AAM9E,SAAQC,OAAO,QAAO,cAAc;AAEpC,OAAO,MAAMC,yBAAyBD,QACpC,eACA;IACEE,IAAIR;IACJS,aAAaJ,KAAK,gBAAgBK,OAAO;IACzCC,UAAUT,KAAK,YAAYQ,OAAO;IAClCE,mBAAmBV,KAAK,uBAAuBQ,OAAO;IACtDG,MAAMX,KAAK,QAAQQ,OAAO;IAC1BI,aAAaZ,KAAK,gBAAgBQ,OAAO;IACzCK,iBAAiBb,KAAK,oBAAoBQ,OAAO,GAAGM,OAAO,CAAC;IAC5DC,WAAWd,UAAU,cAAc;QAACe,cAAc;IAAI,GAAGR,OAAO,GAAGS,UAAU;IAC7EC,WAAWjB,UAAU,cAAc;QAACe,cAAc;IAAI,GAAGR,OAAO,GAAGS,UAAU;AAC/E,GACA,CAACE,QAAU;QACTjB,YAAY,sDAAsDkB,EAAE,CAClED,MAAMZ,WAAW,EACjBY,MAAMV,QAAQ,EACdU,MAAMT,iBAAiB;QAEzBR,YAAY,kDAAkDkB,EAAE,CAACD,MAAMZ,WAAW,EAAEY,MAAMR,IAAI;QAC9FZ,MAAM,6CAA6CqB,EAAE,CAACD,MAAMZ,WAAW;KACxE,EACD;AAKF,OAAO,SAASc,wBAAwBC,GAA4B;IAClE,OAAO;QACLhB,IAAIgB,IAAIhB,EAAE;QACVC,aAAae,IAAIf,WAAW;QAC5BE,UAAUa,IAAIb,QAAQ;QACtBC,mBAAmBY,IAAIZ,iBAAiB;QACxCC,MAAMW,IAAIX,IAAI;QACdC,aAAaU,IAAIV,WAAW;QAC5BC,iBAAiBS,IAAIT,eAAe;QACpCE,WAAWO,IAAIP,SAAS;QACxBG,WAAWI,IAAIJ,SAAS;IAC1B;AACF"}

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

@@ -0,0 +1,195 @@
+export declare const integrationsOutbox: 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,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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 integrationsOutbox = 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 integrationsOutbox = createOutboxTable(pgTable);\n"],"names":["createOutboxTable","pgTable","integrationsOutbox"],"mappings":"AAAA,SAAQA,iBAAiB,QAAO,uBAAuB;AACvD,SAAQC,OAAO,QAAO,cAAc;AAEpC,OAAO,MAAMC,qBAAqBF,kBAAkBC,SAAS"}

package/dist/db/schema/webhook-deliveries.d.ts

@@ -0,0 +1,76 @@
+export declare const integrationsWebhookDeliveries: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "webhook_deliveries";
+    schema: undefined;
+    columns: {
+        provider: import("drizzle-orm/pg-core").PgColumn<{
+            name: "provider";
+            tableName: "webhook_deliveries";
+            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;
+        }, {}, {}>;
+        dedupScope: import("drizzle-orm/pg-core").PgColumn<{
+            name: "dedup_scope";
+            tableName: "webhook_deliveries";
+            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;
+        }, {}, {}>;
+        deliveryId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "delivery_id";
+            tableName: "webhook_deliveries";
+            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;
+        }, {}, {}>;
+        receivedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "received_at";
+            tableName: "webhook_deliveries";
+            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";
+}>;
+//# sourceMappingURL=webhook-deliveries.d.ts.map

package/dist/db/schema/webhook-deliveries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webhook-deliveries.d.ts","sourceRoot":"","sources":["../../../src/db/schema/webhook-deliveries.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAezC,CAAC"}

package/dist/db/schema/webhook-deliveries.js

@@ -0,0 +1,22 @@
+import { index, primaryKey, text, timestamp } from 'drizzle-orm/pg-core';
+import { pgTable } from './common.js';
+export const integrationsWebhookDeliveries = pgTable('webhook_deliveries', {
+    provider: text('provider').notNull(),
+    dedupScope: text('dedup_scope').notNull(),
+    deliveryId: text('delivery_id').notNull(),
+    receivedAt: timestamp('received_at', {
+        withTimezone: true
+    }).notNull().defaultNow()
+}, (table)=>[
+        primaryKey({
+            name: 'integrations_webhook_deliveries_dedup_pk',
+            columns: [
+                table.provider,
+                table.dedupScope,
+                table.deliveryId
+            ]
+        }),
+        index('integrations_webhook_deliveries_received_at_idx').on(table.receivedAt)
+    ]);
+
+//# sourceMappingURL=webhook-deliveries.js.map

package/dist/db/schema/webhook-deliveries.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/db/schema/webhook-deliveries.ts"],"sourcesContent":["import {index, primaryKey, text, timestamp} from 'drizzle-orm/pg-core';\nimport {pgTable} from './common.js';\n\nexport const integrationsWebhookDeliveries = pgTable(\n  'webhook_deliveries',\n  {\n    provider: text('provider').notNull(),\n    dedupScope: text('dedup_scope').notNull(),\n    deliveryId: text('delivery_id').notNull(),\n    receivedAt: timestamp('received_at', {withTimezone: true}).notNull().defaultNow(),\n  },\n  (table) => [\n    primaryKey({\n      name: 'integrations_webhook_deliveries_dedup_pk',\n      columns: [table.provider, table.dedupScope, table.deliveryId],\n    }),\n    index('integrations_webhook_deliveries_received_at_idx').on(table.receivedAt),\n  ],\n);\n"],"names":["index","primaryKey","text","timestamp","pgTable","integrationsWebhookDeliveries","provider","notNull","dedupScope","deliveryId","receivedAt","withTimezone","defaultNow","table","name","columns","on"],"mappings":"AAAA,SAAQA,KAAK,EAAEC,UAAU,EAAEC,IAAI,EAAEC,SAAS,QAAO,sBAAsB;AACvE,SAAQC,OAAO,QAAO,cAAc;AAEpC,OAAO,MAAMC,gCAAgCD,QAC3C,sBACA;IACEE,UAAUJ,KAAK,YAAYK,OAAO;IAClCC,YAAYN,KAAK,eAAeK,OAAO;IACvCE,YAAYP,KAAK,eAAeK,OAAO;IACvCG,YAAYP,UAAU,eAAe;QAACQ,cAAc;IAAI,GAAGJ,OAAO,GAAGK,UAAU;AACjF,GACA,CAACC,QAAU;QACTZ,WAAW;YACTa,MAAM;YACNC,SAAS;gBAACF,MAAMP,QAAQ;gBAAEO,MAAML,UAAU;gBAAEK,MAAMJ,UAAU;aAAC;QAC/D;QACAT,MAAM,mDAAmDgB,EAAE,CAACH,MAAMH,UAAU;KAC7E,EACD"}

package/dist/db/webhook-deliveries.d.ts

@@ -0,0 +1,55 @@
+import { type IntegrationEventReceivedEvent, type SourcePushPayload } from '@shipfox/api-integration-core-dto';
+import { db } from './db.js';
+type IntegrationDb = ReturnType<typeof db>;
+type IntegrationTx = Parameters<Parameters<IntegrationDb['transaction']>[0]>[0];
+type Executor = IntegrationDb | IntegrationTx;
+export interface PublishIntegrationEventReceivedParams {
+    tx: Executor;
+    event: IntegrationEventReceivedEvent;
+}
+export interface PublishIntegrationEventReceivedResult {
+    published: boolean;
+}
+export declare function publishIntegrationEventReceived(params: PublishIntegrationEventReceivedParams): Promise<PublishIntegrationEventReceivedResult>;
+export interface PublishSourcePushParams {
+    tx: IntegrationTx;
+    provider: string;
+    source: string;
+    workspaceId: string;
+    connectionId: string;
+    connectionName: string;
+    deliveryId: string;
+    receivedAt: string;
+    rawPayload: unknown;
+    push: SourcePushPayload;
+}
+export declare function publishSourcePush(params: PublishSourcePushParams): Promise<{
+    published: boolean;
+}>;
+export interface PublishSourceCommitPushedParams {
+    provider: string;
+    workspaceId: string;
+    connectionId: string;
+    deliveryId: string;
+    receivedAt: string;
+    push: SourcePushPayload;
+}
+export declare function publishSourceCommitPushed(params: PublishSourceCommitPushedParams): Promise<void>;
+export interface RecordDeliveryOnlyParams {
+    tx: Executor;
+    provider: string;
+    deliveryId: string;
+}
+export declare function recordDeliveryOnly(params: RecordDeliveryOnlyParams): Promise<void>;
+export interface PruneWebhookDeliveriesParams {
+    olderThan: Date;
+}
+export declare function pruneWebhookDeliveries(params: PruneWebhookDeliveriesParams): Promise<{
+    deleted: number;
+}>;
+export type PublishIntegrationEventReceivedFn = typeof publishIntegrationEventReceived;
+export type PublishSourcePushFn = typeof publishSourcePush;
+export type PublishSourceCommitPushedFn = typeof publishSourceCommitPushed;
+export type RecordDeliveryOnlyFn = typeof recordDeliveryOnly;
+export {};
+//# sourceMappingURL=webhook-deliveries.d.ts.map