@orthacms/webhooks-server 0.5.0

package/dist/lib/infrastructure/event-mapping.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toRoutableEvent = toRoutableEvent;
+exports.toSourceEvent = toSourceEvent;
+/**
+ * Turns an outbox `DomainEvent` into the shapes the webhooks domain works in.
+ *
+ * This is the only file that knows both vocabularies. Keeping it at the edge is
+ * what lets `@orthacms/webhooks-domain` — and therefore the contract external
+ * receivers depend on — stay ignorant of how the outbox happens to store an
+ * event today.
+ */
+/** The payload keys that are envelope metadata rather than event data. */
+const ENVELOPE_KEYS = new Set(['actor', 'workspaceId']);
+/** The routing facts, for the subscription filters. */
+function toRoutableEvent(event) {
+    return {
+        kind: event.kind,
+        workspaceId: readString(event.payload, 'workspaceId'),
+        contentType: readString(event.payload, 'contentType')
+    };
+}
+/**
+ * The full source event, for the envelope.
+ *
+ * `actor` and `workspaceId` are lifted out of the payload into the envelope's
+ * own fields, so `data` carries what the event kind is *about* and nothing that
+ * every event has.
+ */
+function toSourceEvent(event) {
+    const data = {};
+    for (const [key, value] of Object.entries(event.payload)) {
+        if (!ENVELOPE_KEYS.has(key))
+            data[key] = value;
+    }
+    return {
+        eventId: event.eventId,
+        kind: event.kind,
+        occurredAt: event.occurredAt,
+        workspaceId: readString(event.payload, 'workspaceId'),
+        aggregateType: event.aggregateType,
+        aggregateId: event.aggregateId,
+        data,
+        actor: readActor(event.payload)
+    };
+}
+/** A string payload key, or `null` when it is absent or the wrong shape. */
+function readString(payload, key) {
+    const value = payload[key];
+    return typeof value === 'string' && value.length > 0 ? value : null;
+}
+/**
+ * The acting user off the payload, as `attachActor` wrote it.
+ *
+ * Absent for a write made with an API token or by the system, and `null` is the
+ * honest answer there — naming a user who did not do it would be worse than
+ * saying nothing.
+ */
+function readActor(payload) {
+    const actor = payload['actor'];
+    if (typeof actor !== 'object' || actor === null)
+        return null;
+    const record = actor;
+    const id = record['id'];
+    if (typeof id !== 'string')
+        return null;
+    const email = record['email'];
+    return { id, email: typeof email === 'string' ? email : null };
+}

package/dist/lib/infrastructure/purge/webhook-workspaces.purger.d.ts

@@ -0,0 +1,42 @@
+import { OnModuleInit } from '@nestjs/common';
+import { UnitOfWork } from '@orthacms/database';
+import { WorkspacePurgeRegistry, type WorkspacePurger, type WorkspacePurgeOutcome } from '@orthacms/workspaces-server';
+/**
+ * Removes a deleted workspace from every endpoint that subscribed to it.
+ *
+ * `webhook_endpoint_workspaces.workspace_id` is a plain uuid with no foreign
+ * key — the `workspaces` table belongs to another plugin — and the only other
+ * delete is the cascade from `webhook_endpoints`, which fires when the
+ * *endpoint* goes, never when the workspace does. So a deleted workspace left
+ * its subscription rows behind, and fan-out kept reading them on every content
+ * write, matching an id that could never appear in an event again.
+ *
+ * ## Why pruning is safe here and not in `segments`
+ *
+ * The two look identical — a workspace id with no FK, in a set that decides who
+ * receives something — and they get opposite treatment, so the difference is
+ * worth stating. An audience's empty `workspace_ids` **means "every
+ * workspace"**, so pruning the last id would widen who may read. An endpoint's
+ * empty set means nothing at all: `all_workspaces` is a separate boolean, held
+ * explicitly for this exact reason ("fan-out must never have to disambiguate
+ * 'no rows' between 'all' and 'none'"). Pruning here can only narrow.
+ *
+ * ## The endpoint itself stays
+ *
+ * An endpoint that named only the deleted workspace is left enabled with an
+ * empty set, which `matches` reads as "no workspace-carrying event" — it still
+ * receives the kinds whose descriptor carries no workspace. Deleting the
+ * endpoint instead would destroy a signing secret and a URL somebody
+ * configured, on the strength of a workspace delete that says nothing about
+ * either; and disabling it would be a state the admin cannot distinguish from
+ * a human having switched it off.
+ */
+export declare class WebhookWorkspacesPurger implements WorkspacePurger, OnModuleInit {
+    private readonly uow;
+    private readonly registry?;
+    readonly purgeName = "webhooks:endpoint-workspaces";
+    constructor(uow: UnitOfWork, registry?: WorkspacePurgeRegistry | undefined);
+    onModuleInit(): void;
+    purge(workspaceId: string): Promise<WorkspacePurgeOutcome>;
+}
+//# sourceMappingURL=webhook-workspaces.purger.d.ts.map

package/dist/lib/infrastructure/purge/webhook-workspaces.purger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webhook-workspaces.purger.d.ts","sourceRoot":"","sources":["../../../../src/lib/infrastructure/purge/webhook-workspaces.purger.ts"],"names":[],"mappings":"AAAA,OAAO,EAAc,YAAY,EAAY,MAAM,gBAAgB,CAAC;AAEpE,OAAO,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAChD,OAAO,EACH,sBAAsB,EACtB,KAAK,eAAe,EACpB,KAAK,qBAAqB,EAC7B,MAAM,6BAA6B,CAAC;AAGrC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,qBACa,uBAAwB,YAAW,eAAe,EAAE,YAAY;IAIrE,OAAO,CAAC,QAAQ,CAAC,GAAG;IACR,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAC;IAJ1C,QAAQ,CAAC,SAAS,kCAAkC;gBAG/B,GAAG,EAAE,UAAU,EACH,QAAQ,CAAC,EAAE,sBAAsB,YAAA;IAGlE,YAAY,IAAI,IAAI;IAId,KAAK,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,qBAAqB,CAAC;CASnE"}

package/dist/lib/infrastructure/purge/webhook-workspaces.purger.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebhookWorkspacesPurger = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const drizzle_orm_1 = require("drizzle-orm");
+const database_1 = require("@orthacms/database");
+const workspaces_server_1 = require("@orthacms/workspaces-server");
+const webhook_endpoints_1 = require("../schema/webhook-endpoints");
+/**
+ * Removes a deleted workspace from every endpoint that subscribed to it.
+ *
+ * `webhook_endpoint_workspaces.workspace_id` is a plain uuid with no foreign
+ * key — the `workspaces` table belongs to another plugin — and the only other
+ * delete is the cascade from `webhook_endpoints`, which fires when the
+ * *endpoint* goes, never when the workspace does. So a deleted workspace left
+ * its subscription rows behind, and fan-out kept reading them on every content
+ * write, matching an id that could never appear in an event again.
+ *
+ * ## Why pruning is safe here and not in `segments`
+ *
+ * The two look identical — a workspace id with no FK, in a set that decides who
+ * receives something — and they get opposite treatment, so the difference is
+ * worth stating. An audience's empty `workspace_ids` **means "every
+ * workspace"**, so pruning the last id would widen who may read. An endpoint's
+ * empty set means nothing at all: `all_workspaces` is a separate boolean, held
+ * explicitly for this exact reason ("fan-out must never have to disambiguate
+ * 'no rows' between 'all' and 'none'"). Pruning here can only narrow.
+ *
+ * ## The endpoint itself stays
+ *
+ * An endpoint that named only the deleted workspace is left enabled with an
+ * empty set, which `matches` reads as "no workspace-carrying event" — it still
+ * receives the kinds whose descriptor carries no workspace. Deleting the
+ * endpoint instead would destroy a signing secret and a URL somebody
+ * configured, on the strength of a workspace delete that says nothing about
+ * either; and disabling it would be a state the admin cannot distinguish from
+ * a human having switched it off.
+ */
+let WebhookWorkspacesPurger = class WebhookWorkspacesPurger {
+    uow;
+    registry;
+    purgeName = 'webhooks:endpoint-workspaces';
+    constructor(uow, registry) {
+        this.uow = uow;
+        this.registry = registry;
+    }
+    onModuleInit() {
+        this.registry?.register(this);
+    }
+    async purge(workspaceId) {
+        const removed = await this.uow
+            .current()
+            .delete(webhook_endpoints_1.webhookEndpointWorkspaces)
+            .where((0, drizzle_orm_1.eq)(webhook_endpoints_1.webhookEndpointWorkspaces.workspaceId, workspaceId))
+            .returning({ endpointId: webhook_endpoints_1.webhookEndpointWorkspaces.endpointId });
+        return { rows: removed.length };
+    }
+};
+exports.WebhookWorkspacesPurger = WebhookWorkspacesPurger;
+exports.WebhookWorkspacesPurger = WebhookWorkspacesPurger = tslib_1.__decorate([
+    (0, common_1.Injectable)(),
+    tslib_1.__param(1, (0, common_1.Optional)()),
+    tslib_1.__metadata("design:paramtypes", [database_1.UnitOfWork,
+        workspaces_server_1.WorkspacePurgeRegistry])
+], WebhookWorkspacesPurger);

package/dist/lib/infrastructure/schema/index.d.ts

@@ -0,0 +1,3 @@
+export { webhookEndpoints, webhookEndpointWorkspaces } from './webhook-endpoints';
+export { webhookDeliveries } from './webhook-deliveries';
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/infrastructure/schema/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/lib/infrastructure/schema/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,gBAAgB,EAChB,yBAAyB,EAC5B,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC"}

package/dist/lib/infrastructure/schema/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.webhookDeliveries = exports.webhookEndpointWorkspaces = exports.webhookEndpoints = void 0;
+var webhook_endpoints_1 = require("./webhook-endpoints");
+Object.defineProperty(exports, "webhookEndpoints", { enumerable: true, get: function () { return webhook_endpoints_1.webhookEndpoints; } });
+Object.defineProperty(exports, "webhookEndpointWorkspaces", { enumerable: true, get: function () { return webhook_endpoints_1.webhookEndpointWorkspaces; } });
+var webhook_deliveries_1 = require("./webhook-deliveries");
+Object.defineProperty(exports, "webhookDeliveries", { enumerable: true, get: function () { return webhook_deliveries_1.webhookDeliveries; } });

package/dist/lib/infrastructure/schema/webhook-deliveries.d.ts

@@ -0,0 +1,332 @@
+/**
+ * One event's journey to one endpoint — the queue and the log at once.
+ *
+ * **Why this table exists at all.** `OutboxDispatcher` delivers to subscribers
+ * *inside* the transaction that claims the batch. A subscriber that made an
+ * outgoing HTTP request would hold that transaction and its pool client open
+ * for the whole round trip, stalling every other subscriber behind a stranger's
+ * server; worse, a thrown error would count against the **outbox row's**
+ * attempt budget and eventually dead-letter an event the activity log and the
+ * alarms evaluator also needed. So the subscriber only writes rows here, and a
+ * worker does the network with no transaction open.
+ *
+ * The partial unique index on `(endpoint_id, event_id)` is the idempotency:
+ * outbox delivery is at-least-once, and a re-delivered event must not queue the
+ * same webhook twice. It is *partial* so that a deliberate redelivery — which
+ * carries the same `event_id` on purpose, because that is what a receiver
+ * deduplicates on — is exempt from it.
+ */
+export declare const webhookDeliveries: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "webhook_deliveries";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "webhook_deliveries";
+            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;
+        }, {}, {}>;
+        endpointId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "endpoint_id";
+            tableName: "webhook_deliveries";
+            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;
+        }, {}, {}>;
+        eventId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "event_id";
+            tableName: "webhook_deliveries";
+            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;
+        }, {}, {}>;
+        eventKind: import("drizzle-orm/pg-core").PgColumn<{
+            name: "event_kind";
+            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;
+        }, {}, {}>;
+        workspaceId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "workspace_id";
+            tableName: "webhook_deliveries";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        contentType: import("drizzle-orm/pg-core").PgColumn<{
+            name: "content_type";
+            tableName: "webhook_deliveries";
+            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: "webhook_deliveries";
+            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;
+        }, {}, {}>;
+        status: import("drizzle-orm/pg-core").PgColumn<{
+            name: "status";
+            tableName: "webhook_deliveries";
+            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;
+        }, {}, {}>;
+        attempts: import("drizzle-orm/pg-core").PgColumn<{
+            name: "attempts";
+            tableName: "webhook_deliveries";
+            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: "webhook_deliveries";
+            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;
+        }, {}, {}>;
+        claimedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "claimed_at";
+            tableName: "webhook_deliveries";
+            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;
+        }, {}, {}>;
+        lastStatusCode: import("drizzle-orm/pg-core").PgColumn<{
+            name: "last_status_code";
+            tableName: "webhook_deliveries";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: false;
+            hasDefault: false;
+            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: "webhook_deliveries";
+            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;
+        }, {}, {}>;
+        responseSnippet: import("drizzle-orm/pg-core").PgColumn<{
+            name: "response_snippet";
+            tableName: "webhook_deliveries";
+            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;
+        }, {}, {}>;
+        durationMs: import("drizzle-orm/pg-core").PgColumn<{
+            name: "duration_ms";
+            tableName: "webhook_deliveries";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        redeliveryOf: import("drizzle-orm/pg-core").PgColumn<{
+            name: "redelivery_of";
+            tableName: "webhook_deliveries";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            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: "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;
+        }, {}, {}>;
+        completedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "completed_at";
+            tableName: "webhook_deliveries";
+            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=webhook-deliveries.d.ts.map

package/dist/lib/infrastructure/schema/webhook-deliveries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webhook-deliveries.d.ts","sourceRoot":"","sources":["../../../../src/lib/infrastructure/schema/webhook-deliveries.ts"],"names":[],"mappings":"AAaA;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0E7B,CAAC"}

package/dist/lib/infrastructure/schema/webhook-deliveries.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.webhookDeliveries = void 0;
+const drizzle_orm_1 = require("drizzle-orm");
+const pg_core_1 = require("drizzle-orm/pg-core");
+const webhook_endpoints_1 = require("./webhook-endpoints");
+/**
+ * One event's journey to one endpoint — the queue and the log at once.
+ *
+ * **Why this table exists at all.** `OutboxDispatcher` delivers to subscribers
+ * *inside* the transaction that claims the batch. A subscriber that made an
+ * outgoing HTTP request would hold that transaction and its pool client open
+ * for the whole round trip, stalling every other subscriber behind a stranger's
+ * server; worse, a thrown error would count against the **outbox row's**
+ * attempt budget and eventually dead-letter an event the activity log and the
+ * alarms evaluator also needed. So the subscriber only writes rows here, and a
+ * worker does the network with no transaction open.
+ *
+ * The partial unique index on `(endpoint_id, event_id)` is the idempotency:
+ * outbox delivery is at-least-once, and a re-delivered event must not queue the
+ * same webhook twice. It is *partial* so that a deliberate redelivery — which
+ * carries the same `event_id` on purpose, because that is what a receiver
+ * deduplicates on — is exempt from it.
+ */
+exports.webhookDeliveries = (0, pg_core_1.pgTable)('webhook_deliveries', {
+    /** Primary key, and the value sent as `X-Ortha-Delivery`. */
+    id: (0, pg_core_1.uuid)('id').primaryKey().defaultRandom(),
+    endpointId: (0, pg_core_1.uuid)('endpoint_id')
+        .notNull()
+        .references(() => webhook_endpoints_1.webhookEndpoints.id, { onDelete: 'cascade' }),
+    /**
+     * The originating outbox event. Sent as `X-Ortha-Event-Id` and stable
+     * across redeliveries, so it is the value a receiver deduplicates on.
+     * For a `ping` there is no outbox row, so this is a fresh uuid.
+     */
+    eventId: (0, pg_core_1.uuid)('event_id').notNull(),
+    eventKind: (0, pg_core_1.text)('event_kind').notNull(),
+    /** Denormalised for the log's filters; null when the event has none. */
+    workspaceId: (0, pg_core_1.uuid)('workspace_id'),
+    /** Denormalised for the log's filters; null for a non-content event. */
+    contentType: (0, pg_core_1.text)('content_type'),
+    /**
+     * The body, frozen when the row was queued. A redelivery sends exactly
+     * what the first attempt sent — reassembling it later would quietly
+     * send a *different* payload under the same event id.
+     */
+    payload: (0, pg_core_1.jsonb)('payload').notNull(),
+    /** One of `pending | delivering | succeeded | failed | dead`. */
+    status: (0, pg_core_1.text)('status').notNull().default('pending'),
+    attempts: (0, pg_core_1.integer)('attempts').notNull().default(0),
+    /** When the next attempt may be claimed; null means "now". */
+    nextAttemptAt: (0, pg_core_1.timestamp)('next_attempt_at', { withTimezone: true }),
+    /**
+     * When a worker claimed this row. The reaper uses it to recover rows
+     * left in `delivering` by a process that died mid-request — without it
+     * such a row is stuck forever with no error and no retry.
+     */
+    claimedAt: (0, pg_core_1.timestamp)('claimed_at', { withTimezone: true }),
+    lastStatusCode: (0, pg_core_1.integer)('last_status_code'),
+    lastError: (0, pg_core_1.text)('last_error'),
+    /** The first couple of kilobytes of the response, for the log. */
+    responseSnippet: (0, pg_core_1.text)('response_snippet'),
+    durationMs: (0, pg_core_1.integer)('duration_ms'),
+    /**
+     * The delivery this one repeats, when an operator pressed "Send again".
+     *
+     * It is also what exempts the row from the unique index below: a
+     * redelivery keeps the original `event_id` (so the receiver still
+     * recognises the repeat) and would otherwise collide with the row it is
+     * repeating.
+     */
+    redeliveryOf: (0, pg_core_1.uuid)('redelivery_of'),
+    createdAt: (0, pg_core_1.timestamp)('created_at', { withTimezone: true })
+        .notNull()
+        .defaultNow(),
+    completedAt: (0, pg_core_1.timestamp)('completed_at', { withTimezone: true })
+}, (table) => [
+    (0, pg_core_1.uniqueIndex)('webhook_deliveries_endpoint_event_unique')
+        .on(table.endpointId, table.eventId)
+        .where((0, drizzle_orm_1.sql) `${table.redeliveryOf} is null`),
+    // The worker's claim: `WHERE status IN ('pending','failed') ORDER BY
+    // next_attempt_at LIMIT n`. Partial and keyed on the sort column, like
+    // `outbox_events_pending_idx` — it serves the filter, the order and the
+    // limit together, and stays small because completed rows drop out of it.
+    (0, pg_core_1.index)('webhook_deliveries_claimable_idx')
+        .on(table.nextAttemptAt)
+        .where((0, drizzle_orm_1.sql) `${table.status} in ('pending', 'failed')`),
+    // The delivery log for one endpoint, newest first.
+    (0, pg_core_1.index)('webhook_deliveries_endpoint_idx').on(table.endpointId, table.createdAt),
+    // The retention sweep: completed rows older than the cutoff.
+    (0, pg_core_1.index)('webhook_deliveries_completed_idx').on(table.completedAt)
+]);