@voyant-travel/db 0.108.0

package/dist/schema/infra/event_outbox.d.ts

@@ -0,0 +1,232 @@
+/**
+ * Transactional outbox for domain events (RFC voyant#1687 Phase 2.1).
+ *
+ * An emitted event becomes a durable row BEFORE its subscribers run, so
+ * a Worker dying mid-delivery no longer silently loses invoice syncs,
+ * channel pushes, or workflow triggers. Services that need write
+ * atomicity insert rows inside their own transaction (via
+ * `enqueueOutboxEvents(tx, ...)` from `@voyant-travel/db/outbox`); the drain
+ * then delivers post-commit.
+ *
+ * Delivery semantics: **at-least-once**. A row is claimed with a
+ * visibility timeout (no separate "processing" status — a crashed
+ * claimer's row simply becomes due again), delivered to ALL subscribers,
+ * and either completed or rescheduled with exponential backoff until
+ * `max_attempts`, after which it dead-letters as `failed`. Subscribers
+ * must be idempotent — the workflow forwarder already dedups on
+ * `metadata.eventId`, and plugin subscribers key on external refs.
+ */
+export declare const eventOutboxTable: Omit<import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "event_outbox";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: string;
+            tableName: "event_outbox";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: true;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        eventId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "event_id";
+            tableName: "event_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;
+        }, {}, {}>;
+        name: import("drizzle-orm/pg-core").PgColumn<{
+            name: "name";
+            tableName: "event_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;
+        }, {}, {}>;
+        payload: import("drizzle-orm/pg-core").PgColumn<{
+            name: "payload";
+            tableName: "event_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;
+        }, {}, {}>;
+        metadata: import("drizzle-orm/pg-core").PgColumn<{
+            name: "metadata";
+            tableName: "event_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;
+        }, {}, {}>;
+        status: import("drizzle-orm/pg-core").PgColumn<{
+            name: "status";
+            tableName: "event_outbox";
+            dataType: "string";
+            columnType: "PgText";
+            data: "failed" | "pending" | "delivered";
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["pending", "delivered", "failed"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        attempts: import("drizzle-orm/pg-core").PgColumn<{
+            name: "attempts";
+            tableName: "event_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;
+        }, {}, {}>;
+        maxAttempts: import("drizzle-orm/pg-core").PgColumn<{
+            name: "max_attempts";
+            tableName: "event_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;
+        }, {}, {}>;
+        nextAttemptAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "next_attempt_at";
+            tableName: "event_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;
+        }, {}, {}>;
+        lastError: import("drizzle-orm/pg-core").PgColumn<{
+            name: "last_error";
+            tableName: "event_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;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "event_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;
+        }, {}, {}>;
+        deliveredAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "delivered_at";
+            tableName: "event_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";
+}>, "enableRLS">;
+export type EventOutboxRow = typeof eventOutboxTable.$inferSelect;
+export type InsertEventOutboxRow = typeof eventOutboxTable.$inferInsert;
+//# sourceMappingURL=event_outbox.d.ts.map

package/dist/schema/infra/event_outbox.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event_outbox.d.ts","sourceRoot":"","sources":["../../../src/schema/infra/event_outbox.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBA2ChB,CAAA;AAEb,MAAM,MAAM,cAAc,GAAG,OAAO,gBAAgB,CAAC,YAAY,CAAA;AACjE,MAAM,MAAM,oBAAoB,GAAG,OAAO,gBAAgB,CAAC,YAAY,CAAA"}

package/dist/schema/infra/event_outbox.js

@@ -0,0 +1,59 @@
+import { sql } from "drizzle-orm";
+import { index, integer, jsonb, pgTable, text, timestamp, uniqueIndex } from "drizzle-orm/pg-core";
+import { typeId } from "../../lib/index.js";
+/**
+ * Transactional outbox for domain events (RFC voyant#1687 Phase 2.1).
+ *
+ * An emitted event becomes a durable row BEFORE its subscribers run, so
+ * a Worker dying mid-delivery no longer silently loses invoice syncs,
+ * channel pushes, or workflow triggers. Services that need write
+ * atomicity insert rows inside their own transaction (via
+ * `enqueueOutboxEvents(tx, ...)` from `@voyant-travel/db/outbox`); the drain
+ * then delivers post-commit.
+ *
+ * Delivery semantics: **at-least-once**. A row is claimed with a
+ * visibility timeout (no separate "processing" status — a crashed
+ * claimer's row simply becomes due again), delivered to ALL subscribers,
+ * and either completed or rescheduled with exponential backoff until
+ * `max_attempts`, after which it dead-letters as `failed`. Subscribers
+ * must be idempotent — the workflow forwarder already dedups on
+ * `metadata.eventId`, and plugin subscribers key on external refs.
+ */
+export const eventOutboxTable = pgTable("event_outbox", {
+    id: typeId("event_outbox"),
+    /**
+     * Stable envelope id (`metadata.eventId`). Unique — re-emitting the
+     * same event (request retry, redelivered webhook) captures once.
+     */
+    eventId: text("event_id").notNull(),
+    /** Event name (`<resource>.<pastTenseAction>`). */
+    name: text("name").notNull(),
+    /** Envelope `data` payload. */
+    payload: jsonb("payload"),
+    /** Envelope `metadata` (includes eventId, correlation ids, ...). */
+    metadata: jsonb("metadata"),
+    /** pending → delivered | failed (dead-lettered). */
+    status: text("status", { enum: ["pending", "delivered", "failed"] })
+        .notNull()
+        .default("pending"),
+    /** Delivery attempts so far (incremented at claim time). */
+    attempts: integer("attempts").notNull().default(0),
+    /** Dead-letter threshold. */
+    maxAttempts: integer("max_attempts").notNull().default(8),
+    /**
+     * When the row is next due. Doubles as the visibility timeout while
+     * a claim is in flight and as the backoff schedule after a failure.
+     */
+    nextAttemptAt: timestamp("next_attempt_at", { withTimezone: true }).notNull().defaultNow(),
+    lastError: text("last_error"),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    deliveredAt: timestamp("delivered_at", { withTimezone: true }),
+}, (table) => [
+    uniqueIndex("event_outbox_event_id_uniq").on(table.eventId),
+    // The drain's working set: due pending rows only. Partial keeps the
+    // index tiny once delivered/failed rows accumulate.
+    // agent-quality: raw-sql reviewed -- owner: db; dynamic SQL interpolation uses Drizzle parameter binding or vetted SQL identifiers.
+    index("event_outbox_due_idx").on(table.nextAttemptAt).where(sql `${table.status} = 'pending'`),
+    index("event_outbox_created_idx").on(table.createdAt),
+]).enableRLS();
+//# sourceMappingURL=event_outbox.js.map

package/dist/schema/infra/event_outbox.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"event_outbox.js","sourceRoot":"","sources":["../../../src/schema/infra/event_outbox.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,aAAa,CAAA;AACjC,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAA;AAElG,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAA;AAE3C;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,OAAO,CACrC,cAAc,EACd;IACE,EAAE,EAAE,MAAM,CAAC,cAAc,CAAC;IAE1B;;;OAGG;IACH,OAAO,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC,OAAO,EAAE;IACnC,mDAAmD;IACnD,IAAI,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC,OAAO,EAAE;IAC5B,+BAA+B;IAC/B,OAAO,EAAE,KAAK,CAAC,SAAS,CAAC;IACzB,oEAAoE;IACpE,QAAQ,EAAE,KAAK,CAAC,UAAU,CAAC;IAE3B,oDAAoD;IACpD,MAAM,EAAE,IAAI,CAAC,QAAQ,EAAE,EAAE,IAAI,EAAE,CAAC,SAAS,EAAE,WAAW,EAAE,QAAQ,CAAC,EAAE,CAAC;SACjE,OAAO,EAAE;SACT,OAAO,CAAC,SAAS,CAAC;IACrB,4DAA4D;IAC5D,QAAQ,EAAE,OAAO,CAAC,UAAU,CAAC,CAAC,OAAO,EAAE,CAAC,OAAO,CAAC,CAAC,CAAC;IAClD,6BAA6B;IAC7B,WAAW,EAAE,OAAO,CAAC,cAAc,CAAC,CAAC,OAAO,EAAE,CAAC,OAAO,CAAC,CAAC,CAAC;IACzD;;;OAGG;IACH,aAAa,EAAE,SAAS,CAAC,iBAAiB,EAAE,EAAE,YAAY,EAAE,IAAI,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,UAAU,EAAE;IAC1F,SAAS,EAAE,IAAI,CAAC,YAAY,CAAC;IAE7B,SAAS,EAAE,SAAS,CAAC,YAAY,EAAE,EAAE,YAAY,EAAE,IAAI,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,UAAU,EAAE;IACjF,WAAW,EAAE,SAAS,CAAC,cAAc,EAAE,EAAE,YAAY,EAAE,IAAI,EAAE,CAAC;CAC/D,EACD,CAAC,KAAK,EAAE,EAAE,CAAC;IACT,WAAW,CAAC,4BAA4B,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,OAAO,CAAC;IAC3D,oEAAoE;IACpE,oDAAoD;IACpD,oIAAoI;IACpI,KAAK,CAAC,sBAAsB,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,aAAa,CAAC,CAAC,KAAK,CAAC,GAAG,CAAA,GAAG,KAAK,CAAC,MAAM,cAAc,CAAC;IAC7F,KAAK,CAAC,0BAA0B,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,SAAS,CAAC;CACtD,CACF,CAAC,SAAS,EAAE,CAAA"}

package/dist/schema/infra/idempotency_keys.d.ts

@@ -0,0 +1,186 @@
+/**
+ * Idempotency keys store the response of a previously-handled request keyed
+ * by `(scope, key)`. Replays of the same key with the same body hash return
+ * the stored response; replays with a *different* body hash conflict (409).
+ *
+ * Designed for non-idempotent POST endpoints — primarily booking creation,
+ * payment intent issuance, and similar money-affecting flows where a
+ * client retry must not produce duplicate side effects.
+ *
+ * Rows expire after `expiresAt`. Cleanup is the deployment's responsibility
+ * (typically a daily cron sweep).
+ *
+ * `scope` namespaces keys per endpoint family so that two unrelated
+ * endpoints can safely accept overlapping keys without colliding.
+ *
+ * `bodyHash` is a SHA-256 of the canonical request body — when the same
+ * key replays with the same hash, we return `responseStatus` /
+ * `responseBody` verbatim. Different hash → 409.
+ *
+ * `referenceId` (optional) lets callers point at the resource the original
+ * request created — typically a booking id — so that operational queries
+ * can correlate replays with the underlying entity.
+ */
+export declare const infraIdempotencyKeysTable: Omit<import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "idempotency_keys";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: string;
+            tableName: "idempotency_keys";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: true;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        scope: import("drizzle-orm/pg-core").PgColumn<{
+            name: "scope";
+            tableName: "idempotency_keys";
+            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;
+        }, {}, {}>;
+        key: import("drizzle-orm/pg-core").PgColumn<{
+            name: "key";
+            tableName: "idempotency_keys";
+            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;
+        }, {}, {}>;
+        bodyHash: import("drizzle-orm/pg-core").PgColumn<{
+            name: "body_hash";
+            tableName: "idempotency_keys";
+            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;
+        }, {}, {}>;
+        responseStatus: import("drizzle-orm/pg-core").PgColumn<{
+            name: "response_status";
+            tableName: "idempotency_keys";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        responseBody: import("drizzle-orm/pg-core").PgColumn<{
+            name: "response_body";
+            tableName: "idempotency_keys";
+            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;
+        }, {}, {}>;
+        referenceId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "reference_id";
+            tableName: "idempotency_keys";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "idempotency_keys";
+            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;
+        }, {}, {}>;
+        expiresAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "expires_at";
+            tableName: "idempotency_keys";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>, "enableRLS">;
+export type InsertInfraIdempotencyKey = typeof infraIdempotencyKeysTable.$inferInsert;
+export type SelectInfraIdempotencyKey = typeof infraIdempotencyKeysTable.$inferSelect;
+//# sourceMappingURL=idempotency_keys.d.ts.map

package/dist/schema/infra/idempotency_keys.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"idempotency_keys.d.ts","sourceRoot":"","sources":["../../../src/schema/infra/idempotency_keys.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAiBzB,CAAA;AAEb,MAAM,MAAM,yBAAyB,GAAG,OAAO,yBAAyB,CAAC,YAAY,CAAA;AACrF,MAAM,MAAM,yBAAyB,GAAG,OAAO,yBAAyB,CAAC,YAAY,CAAA"}

package/dist/schema/infra/idempotency_keys.js

@@ -0,0 +1,40 @@
+import { index, integer, jsonb, pgTable, text, timestamp, uniqueIndex } from "drizzle-orm/pg-core";
+import { typeId } from "../../lib/index.js";
+/**
+ * Idempotency keys store the response of a previously-handled request keyed
+ * by `(scope, key)`. Replays of the same key with the same body hash return
+ * the stored response; replays with a *different* body hash conflict (409).
+ *
+ * Designed for non-idempotent POST endpoints — primarily booking creation,
+ * payment intent issuance, and similar money-affecting flows where a
+ * client retry must not produce duplicate side effects.
+ *
+ * Rows expire after `expiresAt`. Cleanup is the deployment's responsibility
+ * (typically a daily cron sweep).
+ *
+ * `scope` namespaces keys per endpoint family so that two unrelated
+ * endpoints can safely accept overlapping keys without colliding.
+ *
+ * `bodyHash` is a SHA-256 of the canonical request body — when the same
+ * key replays with the same hash, we return `responseStatus` /
+ * `responseBody` verbatim. Different hash → 409.
+ *
+ * `referenceId` (optional) lets callers point at the resource the original
+ * request created — typically a booking id — so that operational queries
+ * can correlate replays with the underlying entity.
+ */
+export const infraIdempotencyKeysTable = pgTable("idempotency_keys", {
+    id: typeId("idempotency_keys"),
+    scope: text("scope").notNull(),
+    key: text("key").notNull(),
+    bodyHash: text("body_hash").notNull(),
+    responseStatus: integer("response_status").notNull(),
+    responseBody: jsonb("response_body").notNull(),
+    referenceId: text("reference_id"),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    expiresAt: timestamp("expires_at", { withTimezone: true }).notNull(),
+}, (table) => [
+    uniqueIndex("idx_infra_idempotency_keys_scope_key").on(table.scope, table.key),
+    index("idx_infra_idempotency_keys_expires_at").on(table.expiresAt),
+]).enableRLS();
+//# sourceMappingURL=idempotency_keys.js.map

package/dist/schema/infra/idempotency_keys.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"idempotency_keys.js","sourceRoot":"","sources":["../../../src/schema/infra/idempotency_keys.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAA;AAElG,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAA;AAE3C;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAG,OAAO,CAC9C,kBAAkB,EAClB;IACE,EAAE,EAAE,MAAM,CAAC,kBAAkB,CAAC;IAC9B,KAAK,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC,OAAO,EAAE;IAC9B,GAAG,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,OAAO,EAAE;IAC1B,QAAQ,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC,OAAO,EAAE;IACrC,cAAc,EAAE,OAAO,CAAC,iBAAiB,CAAC,CAAC,OAAO,EAAE;IACpD,YAAY,EAAE,KAAK,CAAC,eAAe,CAAC,CAAC,OAAO,EAAE;IAC9C,WAAW,EAAE,IAAI,CAAC,cAAc,CAAC;IACjC,SAAS,EAAE,SAAS,CAAC,YAAY,EAAE,EAAE,YAAY,EAAE,IAAI,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,UAAU,EAAE;IACjF,SAAS,EAAE,SAAS,CAAC,YAAY,EAAE,EAAE,YAAY,EAAE,IAAI,EAAE,CAAC,CAAC,OAAO,EAAE;CACrE,EACD,CAAC,KAAK,EAAE,EAAE,CAAC;IACT,WAAW,CAAC,sCAAsC,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,KAAK,EAAE,KAAK,CAAC,GAAG,CAAC;IAC9E,KAAK,CAAC,uCAAuC,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,SAAS,CAAC;CACnE,CACF,CAAC,SAAS,EAAE,CAAA"}

package/dist/schema/infra/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./domains.js";
+export * from "./event_outbox.js";
+export * from "./idempotency_keys.js";
+export * from "./public_document_delivery_grants.js";
+export * from "./rate_limit_buckets.js";
+export * from "./webhook_deliveries.js";
+export * from "./webhook_subscriptions.js";
+export * from "./write_intents.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/schema/infra/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/schema/infra/index.ts"],"names":[],"mappings":"AACA,cAAc,cAAc,CAAA;AAC5B,cAAc,mBAAmB,CAAA;AACjC,cAAc,uBAAuB,CAAA;AACrC,cAAc,sCAAsC,CAAA;AACpD,cAAc,yBAAyB,CAAA;AACvC,cAAc,yBAAyB,CAAA;AACvC,cAAc,4BAA4B,CAAA;AAC1C,cAAc,oBAAoB,CAAA"}

package/dist/schema/infra/index.js

@@ -0,0 +1,10 @@
+// audit_log: REMOVED - migrated to Tinybird (audit_log.datasource)
+export * from "./domains.js";
+export * from "./event_outbox.js";
+export * from "./idempotency_keys.js";
+export * from "./public_document_delivery_grants.js";
+export * from "./rate_limit_buckets.js";
+export * from "./webhook_deliveries.js";
+export * from "./webhook_subscriptions.js";
+export * from "./write_intents.js";
+//# sourceMappingURL=index.js.map

package/dist/schema/infra/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/schema/infra/index.ts"],"names":[],"mappings":"AAAA,mEAAmE;AACnE,cAAc,cAAc,CAAA;AAC5B,cAAc,mBAAmB,CAAA;AACjC,cAAc,uBAAuB,CAAA;AACrC,cAAc,sCAAsC,CAAA;AACpD,cAAc,yBAAyB,CAAA;AACvC,cAAc,yBAAyB,CAAA;AACvC,cAAc,4BAA4B,CAAA;AAC1C,cAAc,oBAAoB,CAAA"}