@orthacms/webhooks-server 0.5.0

package/dist/lib/docs/describe-webhooks-api.js

@@ -0,0 +1,170 @@
+"use strict";
+/**
+ * The webhooks plugin's pass over the host's OpenAPI document.
+ *
+ * The routes here are ordinary decorated controllers, so `@nestjs/swagger`
+ * already knows their paths, parameters and request bodies. What it cannot
+ * know is what comes **back**: every response view is a TypeScript
+ * `interface`, erased before the scanner runs, which is why each operation
+ * arrives carrying a bare `200`/`201` with no content. This pass writes the
+ * response schemas onto the operations the plugin owns and nothing else.
+ *
+ * Pure: it takes the document and mutates only its own paths.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.describeWebhooksApi = describeWebhooksApi;
+const webhook_schemas_1 = require("./webhook-schemas");
+/** The endpoint routes, keyed by what follows `/webhooks`. */
+const ENDPOINT_ROUTES = {
+    '': {
+        get: {
+            schema: 'WebhookEndpoint',
+            list: true,
+            description: 'Every endpoint, newest first. No signing secrets.'
+        },
+        post: {
+            schema: 'WebhookEndpointWithSecret',
+            description: 'The created endpoint and its signing secret — the secret’s only appearance.',
+            validatesUrl: true
+        }
+    },
+    '/{id}': {
+        get: { schema: 'WebhookEndpoint', description: 'The endpoint.' },
+        patch: {
+            schema: 'WebhookEndpoint',
+            description: 'The endpoint as it now stands.',
+            validatesUrl: true
+        }
+    },
+    '/{id}/secret': {
+        post: {
+            schema: 'WebhookEndpointWithSecret',
+            description: 'The endpoint and the new signing secret, returned once. The previous secret stops verifying immediately, including for deliveries already queued.'
+        }
+    },
+    '/{id}/test': {
+        post: {
+            schema: 'WebhookTestResult',
+            description: 'What the receiver answered.'
+        }
+    },
+    '/{id}/deliveries': {
+        get: {
+            schema: 'WebhookDeliveryPage',
+            description: 'One page of the endpoint’s delivery log, newest first.'
+        }
+    },
+    '/{id}/deliveries/{deliveryId}': {
+        get: {
+            schema: 'WebhookDeliveryDetail',
+            description: 'The delivery, with its frozen body and the response.'
+        }
+    },
+    // Declared as the detail shape, and that is not a copy-paste of the route
+    // above: `redeliver` is *typed* `WebhookDeliveryView` but returns
+    // `findDetail(...)`, so the queued row comes back with `payload` and
+    // `responseSnippet` (null, since nothing has been sent yet) on it. The
+    // document describes what the route answers with.
+    '/{id}/deliveries/{deliveryId}/redeliver': {
+        post: {
+            schema: 'WebhookDeliveryDetail',
+            description: 'The newly queued delivery. It carries a new delivery `id` and the original `eventId`, so a receiver that deduplicates still recognises the repeat.'
+        }
+    }
+};
+/** The event catalogue, keyed by what follows `/webhook-events`. */
+const EVENT_ROUTES = {
+    '': {
+        get: {
+            schema: 'WebhookEventDescriptor',
+            list: true,
+            description: 'Every kind an endpoint may subscribe to.'
+        }
+    }
+};
+/**
+ * Matches `<prefix>/webhooks<rest>` and `<prefix>/webhook-events<rest>`.
+ *
+ * The prefix is whatever the host configured (`/api` here), so it is matched
+ * rather than assumed — but it is matched as segments **containing no `{`**,
+ * which is what keeps a hypothetical `/api/workspaces/{id}/webhooks` from being
+ * described with the global endpoint's shapes. A global prefix never holds a
+ * path parameter; a nested resource route almost always does. The content
+ * plugin learned this the expensive way, where a laxer pattern put the admin's
+ * schemas onto thirteen published operations.
+ */
+const ENDPOINT_ROUTE_RE = /^(?:\/[^/{}]+)*\/webhooks(\/.*)?$/;
+/** Matches `<prefix>/webhook-events<rest>`, under the same rule. */
+const EVENT_ROUTE_RE = /^(?:\/[^/{}]+)*\/webhook-events(\/.*)?$/;
+/**
+ * Writes a success response's schema onto whichever 2xx key the scanner already
+ * emitted (Nest's default is 201 for `@Post`, 200 elsewhere, and a `@HttpCode`
+ * moves it), so this never invents a status code the API does not return. A
+ * `204` is left exactly as it is: it has no body, and describing one would be
+ * a lie about the delete route.
+ */
+function setSuccessResponse(operation, schema, description) {
+    const responses = operation.responses ?? {};
+    const key = Object.keys(responses).find((code) => /^2\d\d$/.test(code));
+    if (!key || key === '204') {
+        return;
+    }
+    responses[key] = {
+        description,
+        content: { 'application/json': { schema } }
+    };
+    operation.responses = responses;
+}
+/** Adds a documented failure response, leaving any existing one alone. */
+function addErrorResponse(operation, code, description) {
+    const responses = operation.responses ?? {};
+    if (responses[code]) {
+        return;
+    }
+    responses[code] = { description };
+    operation.responses = responses;
+}
+/** Adds this plugin's schemas and describes its own operations' responses. */
+function describeWebhooksApi(document) {
+    document.components ??= {};
+    document.components.schemas ??= {};
+    Object.assign(document.components.schemas, (0, webhook_schemas_1.buildWebhookSchemas)());
+    const surfaces = [
+        [EVENT_ROUTE_RE, EVENT_ROUTES],
+        [ENDPOINT_ROUTE_RE, ENDPOINT_ROUTES]
+    ];
+    for (const [route, item] of Object.entries(document.paths)) {
+        let rest;
+        let routes;
+        for (const [pattern, candidate] of surfaces) {
+            const match = pattern.exec(route);
+            if (match) {
+                rest = match[1] ?? '';
+                routes = candidate;
+                break;
+            }
+        }
+        if (rest === undefined || !routes) {
+            continue;
+        }
+        const byMethod = routes[rest];
+        if (!byMethod) {
+            continue;
+        }
+        for (const [method, operation] of Object.entries(item)) {
+            const spec = byMethod[method];
+            if (!spec || !operation || typeof operation !== 'object') {
+                continue;
+            }
+            setSuccessResponse(operation, spec.list
+                ? { type: 'array', items: (0, webhook_schemas_1.ref)(spec.schema) }
+                : (0, webhook_schemas_1.ref)(spec.schema), spec.description);
+            if (rest !== '') {
+                addErrorResponse(operation, '404', 'No endpoint with this id — or, on a delivery route, no delivery with this id belonging to it.');
+            }
+            if (spec.validatesUrl) {
+                addErrorResponse(operation, '422', 'The URL was refused by policy (scheme, or a private/loopback address), or a header name is reserved for the delivery’s own metadata.');
+            }
+        }
+    }
+}

package/dist/lib/docs/webhook-schemas.d.ts

@@ -0,0 +1,21 @@
+/**
+ * The OpenAPI schemas the webhooks plugin contributes.
+ *
+ * Every response view in this package is a TypeScript `interface`, which is
+ * erased before `@nestjs/swagger` ever runs — so the scanner emits an empty
+ * `200` for each route and a reader learns nothing. These are the same shapes
+ * written as plain schema objects, attached to the finished document by
+ * {@link describeWebhooksApi}.
+ *
+ * The vocabularies (`DELIVERY_STATUSES`, the event catalogue) are **imported**
+ * from `@orthacms/webhooks-domain` rather than restated: an enum in the
+ * reference that drifts from the one the server validates against is worse
+ * than a bare string, because it looks authoritative.
+ */
+/** A JSON Schema fragment, as it appears in the OpenAPI document. */
+export type OpenApiSchema = Record<string, unknown>;
+/** `#/components/schemas/<name>`. */
+export declare function ref(name: string): OpenApiSchema;
+/** Every schema this plugin adds, keyed by component name. */
+export declare function buildWebhookSchemas(): Record<string, OpenApiSchema>;
+//# sourceMappingURL=webhook-schemas.d.ts.map

package/dist/lib/docs/webhook-schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webhook-schemas.d.ts","sourceRoot":"","sources":["../../../src/lib/docs/webhook-schemas.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAQH,qEAAqE;AACrE,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAEpD,qCAAqC;AACrC,wBAAgB,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,aAAa,CAE/C;AAuWD,8DAA8D;AAC9D,wBAAgB,mBAAmB,IAAI,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAYnE"}

package/dist/lib/docs/webhook-schemas.js

@@ -0,0 +1,360 @@
+"use strict";
+/**
+ * The OpenAPI schemas the webhooks plugin contributes.
+ *
+ * Every response view in this package is a TypeScript `interface`, which is
+ * erased before `@nestjs/swagger` ever runs — so the scanner emits an empty
+ * `200` for each route and a reader learns nothing. These are the same shapes
+ * written as plain schema objects, attached to the finished document by
+ * {@link describeWebhooksApi}.
+ *
+ * The vocabularies (`DELIVERY_STATUSES`, the event catalogue) are **imported**
+ * from `@orthacms/webhooks-domain` rather than restated: an enum in the
+ * reference that drifts from the one the server validates against is worse
+ * than a bare string, because it looks authoritative.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ref = ref;
+exports.buildWebhookSchemas = buildWebhookSchemas;
+const webhooks_domain_1 = require("@orthacms/webhooks-domain");
+/** `#/components/schemas/<name>`. */
+function ref(name) {
+    return { $ref: `#/components/schemas/${name}` };
+}
+const UUID = { type: 'string', format: 'uuid' };
+const DATE_TIME = { type: 'string', format: 'date-time' };
+/** A nullable `date-time`, which several delivery timestamps are. */
+const NULLABLE_DATE_TIME = {
+    type: 'string',
+    format: 'date-time',
+    nullable: true
+};
+/** The delivery state vocabulary, straight from the domain. */
+const DELIVERY_STATUS = {
+    type: 'string',
+    enum: [...webhooks_domain_1.DELIVERY_STATUSES],
+    description: '`succeeded` and `dead` are terminal; a `failed` delivery has another attempt scheduled.'
+};
+/**
+ * The endpoint as every read returns it.
+ *
+ * The absent property is the point: there is no `secret` here, and no route
+ * that answers with this schema can produce one. `secretHint` is the trailing
+ * four characters, which is enough to tell two secrets apart and far too little
+ * to shorten an attack on a 256-bit key.
+ */
+const ENDPOINT = {
+    type: 'object',
+    description: 'A configured webhook endpoint. Never carries the signing secret — see WebhookEndpointWithSecret.',
+    required: [
+        'id',
+        'name',
+        'url',
+        'secretHint',
+        'enabled',
+        'eventKinds',
+        'contentTypes',
+        'allWorkspaces',
+        'workspaceIds',
+        'headers',
+        'disabledReason',
+        'consecutiveFailures',
+        'createdAt',
+        'updatedAt',
+        'lastDelivery'
+    ],
+    properties: {
+        id: UUID,
+        name: { type: 'string' },
+        url: {
+            type: 'string',
+            format: 'uri',
+            description: 'Where deliveries are POSTed.'
+        },
+        secretHint: {
+            type: 'string',
+            description: 'The last four characters of the signing secret. The secret itself is returned only on create and rotate.'
+        },
+        enabled: { type: 'boolean' },
+        eventKinds: {
+            type: 'array',
+            items: { type: 'string', enum: [...webhooks_domain_1.WEBHOOK_EVENT_KINDS] },
+            description: 'The subscribed kinds. **Empty means every kind, including ones added later.**'
+        },
+        contentTypes: {
+            type: 'array',
+            items: { type: 'string' },
+            description: 'Content types this endpoint is scoped to. Empty means every type, including ones that do not exist yet.'
+        },
+        allWorkspaces: {
+            type: 'boolean',
+            description: 'True when the endpoint spans every workspace.'
+        },
+        workspaceIds: {
+            type: 'array',
+            items: UUID,
+            description: 'Empty when `allWorkspaces` is true.'
+        },
+        headers: {
+            type: 'object',
+            additionalProperties: { type: 'string' },
+            description: 'Extra request headers sent with every delivery.'
+        },
+        disabledReason: {
+            type: 'string',
+            nullable: true,
+            description: 'Set when the endpoint switched itself off after consecutive failures; null otherwise.'
+        },
+        consecutiveFailures: { type: 'integer' },
+        createdAt: DATE_TIME,
+        updatedAt: DATE_TIME,
+        // A bare `$ref`: OpenAPI 3.0 ignores keywords written beside one, so
+        // "or null" lives on the referenced schema (`nullable`) rather than in
+        // a sibling `description` that no reader would ever be shown.
+        lastDelivery: ref('WebhookLastDelivery')
+    }
+};
+/**
+ * The one-line delivery summary the list column renders.
+ *
+ * Nullable through the property that references it rather than here: OpenAPI
+ * 3.0 ignores sibling keywords next to a `$ref`, so `lastDelivery` is described
+ * as `allOf`-free and this schema itself carries the `nullable`.
+ */
+const LAST_DELIVERY = {
+    type: 'object',
+    nullable: true,
+    required: ['id', 'status', 'eventKind', 'statusCode', 'createdAt'],
+    properties: {
+        id: UUID,
+        status: DELIVERY_STATUS,
+        eventKind: { type: 'string' },
+        statusCode: {
+            type: 'integer',
+            nullable: true,
+            description: 'The receiver’s HTTP status, or null if nothing answered.'
+        },
+        createdAt: DATE_TIME
+    }
+};
+/**
+ * Create and rotate — and **only** those two — answer with the endpoint plus
+ * the secret.
+ *
+ * A separate schema rather than an optional `secret` on {@link ENDPOINT}: an
+ * optional field says "sometimes present, look and see", which is exactly the
+ * belief that makes someone build a UI that reads it on a `GET` and shows an
+ * empty box forever. Two schemas say which two responses carry it.
+ */
+const ENDPOINT_WITH_SECRET = {
+    type: 'object',
+    description: 'Returned by POST /webhooks and POST /webhooks/{id}/secret only. The secret is shown once and is never retrievable again — not by any read, and not by whoever created it.',
+    required: ['endpoint', 'secret'],
+    properties: {
+        endpoint: ref('WebhookEndpoint'),
+        secret: {
+            type: 'string',
+            pattern: '^whsec_',
+            description: 'The signing secret: `whsec_` followed by 32 random bytes, base64url-encoded. Store it now; every later read returns only `secretHint`.',
+            example: 'whsec_XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX'
+        }
+    }
+};
+/** The delivery row, without the bodies. */
+const DELIVERY = {
+    type: 'object',
+    description: 'One queued or completed delivery attempt-set.',
+    required: [
+        'id',
+        'endpointId',
+        'eventId',
+        'eventKind',
+        'workspaceId',
+        'contentType',
+        'status',
+        'attempts',
+        'nextAttemptAt',
+        'statusCode',
+        'error',
+        'durationMs',
+        'createdAt',
+        'completedAt'
+    ],
+    properties: {
+        id: {
+            ...UUID,
+            description: 'The delivery’s own id, sent as `X-Ortha-Delivery`. A redelivery gets a new one.'
+        },
+        endpointId: UUID,
+        eventId: {
+            ...UUID,
+            description: 'The originating outbox event, sent as `X-Ortha-Event-Id`. Stable across every redelivery — this is the key a receiver deduplicates on.'
+        },
+        eventKind: { type: 'string' },
+        workspaceId: { ...UUID, nullable: true },
+        contentType: { type: 'string', nullable: true },
+        status: DELIVERY_STATUS,
+        attempts: { type: 'integer' },
+        nextAttemptAt: {
+            ...NULLABLE_DATE_TIME,
+            description: 'When the next attempt is due; null when none is scheduled.'
+        },
+        statusCode: { type: 'integer', nullable: true },
+        error: { type: 'string', nullable: true },
+        durationMs: { type: 'integer', nullable: true },
+        createdAt: DATE_TIME,
+        completedAt: NULLABLE_DATE_TIME
+    }
+};
+/** The delivery row with the frozen request body and the response snippet. */
+const DELIVERY_DETAIL = {
+    allOf: [
+        ref('WebhookDelivery'),
+        {
+            type: 'object',
+            required: ['payload', 'responseSnippet'],
+            properties: {
+                payload: ref('WebhookEnvelope'),
+                responseSnippet: {
+                    type: 'string',
+                    nullable: true,
+                    description: 'The first couple of kilobytes of the receiver’s response body, or null when nothing answered.'
+                }
+            }
+        }
+    ],
+    description: 'A delivery with the exact body that was, or will be, posted.'
+};
+/**
+ * The body a receiver is sent.
+ *
+ * Described here because it is frozen onto the delivery row and handed back by
+ * the detail route, so the reference is where an integrator reads what their
+ * own handler will be parsing. It carries **references, not content**: a
+ * receiver reads the record back through the public API with its own token, so
+ * the read still passes through visibility rules and audience entitlements.
+ */
+const ENVELOPE = {
+    type: 'object',
+    description: 'The JSON body POSTed to a receiver, signed with the endpoint’s secret in `X-Ortha-Signature`.',
+    required: [
+        'id',
+        'event',
+        'eventId',
+        'occurredAt',
+        'workspaceId',
+        'actor',
+        'data'
+    ],
+    properties: {
+        id: {
+            ...UUID,
+            description: 'The delivery id. Changes on a redelivery.'
+        },
+        event: { type: 'string', description: 'The event kind.' },
+        eventId: {
+            ...UUID,
+            description: 'The outbox event id — stable across redeliveries, and the receiver’s deduplication key.'
+        },
+        occurredAt: {
+            ...DATE_TIME,
+            description: 'Domain time: when the fact happened, not when it was sent.'
+        },
+        workspaceId: { ...UUID, nullable: true },
+        actor: {
+            type: 'object',
+            nullable: true,
+            description: 'Who did it, or null for a token-authenticated or system write.',
+            required: ['id', 'email'],
+            properties: {
+                id: UUID,
+                email: { type: 'string', nullable: true }
+            }
+        },
+        data: {
+            type: 'object',
+            description: 'What the event is about: the aggregate’s `kind` and `id`, plus whatever else the kind carries.',
+            required: ['kind', 'id'],
+            properties: {
+                kind: {
+                    type: 'string',
+                    description: 'The aggregate type, e.g. `content_entry`.',
+                    example: 'content_entry'
+                },
+                id: UUID
+            },
+            additionalProperties: true
+        }
+    }
+};
+/** One page of the delivery log. */
+const DELIVERY_PAGE = {
+    type: 'object',
+    required: ['items', 'total', 'page', 'pageSize', 'pageCount'],
+    properties: {
+        items: { type: 'array', items: ref('WebhookDelivery') },
+        total: { type: 'integer' },
+        page: { type: 'integer' },
+        pageSize: { type: 'integer' },
+        pageCount: { type: 'integer' }
+    }
+};
+/** What "Send test" reports. Synchronous — nothing is queued. */
+const TEST_RESULT = {
+    type: 'object',
+    description: 'The outcome of a synthetic `ping`, reported synchronously. It is not queued and does not count towards automatic disabling.',
+    required: ['ok', 'statusCode', 'error', 'durationMs', 'responseSnippet'],
+    properties: {
+        ok: {
+            type: 'boolean',
+            description: 'Whether the receiver answered 2xx.'
+        },
+        statusCode: { type: 'integer', nullable: true },
+        error: {
+            type: 'string',
+            nullable: true,
+            description: 'Why it failed, when it did.'
+        },
+        durationMs: { type: 'integer' },
+        responseSnippet: { type: 'string', nullable: true }
+    }
+};
+/** One entry of the subscribable-event catalogue. */
+const EVENT_DESCRIPTOR = {
+    type: 'object',
+    description: 'One kind an endpoint may subscribe to. Read this rather than compiling a list into a client: a newer server offers the kinds it actually knows about.',
+    required: [
+        'kind',
+        'group',
+        'label',
+        'scopedByContentType',
+        'carriesWorkspace'
+    ],
+    properties: {
+        kind: { type: 'string', enum: [...webhooks_domain_1.WEBHOOK_EVENT_KINDS] },
+        group: { type: 'string', enum: [...webhooks_domain_1.WEBHOOK_EVENT_GROUPS] },
+        label: { type: 'string', description: 'Default English label.' },
+        scopedByContentType: {
+            type: 'boolean',
+            description: 'Whether an endpoint’s content-type filter applies to this kind.'
+        },
+        carriesWorkspace: {
+            type: 'boolean',
+            description: 'Whether an endpoint’s workspace filter applies to this kind.'
+        }
+    }
+};
+/** Every schema this plugin adds, keyed by component name. */
+function buildWebhookSchemas() {
+    return {
+        WebhookEndpoint: ENDPOINT,
+        WebhookLastDelivery: LAST_DELIVERY,
+        WebhookEndpointWithSecret: ENDPOINT_WITH_SECRET,
+        WebhookDelivery: DELIVERY,
+        WebhookDeliveryDetail: DELIVERY_DETAIL,
+        WebhookDeliveryPage: DELIVERY_PAGE,
+        WebhookEnvelope: ENVELOPE,
+        WebhookTestResult: TEST_RESULT,
+        WebhookEventDescriptor: EVENT_DESCRIPTOR
+    };
+}

package/dist/lib/domain/errors/index.d.ts

@@ -0,0 +1,3 @@
+export { WebhookEndpointNotFoundError } from './webhook-endpoint-not-found.error';
+export { WebhookDeliveryNotFoundError } from './webhook-delivery-not-found.error';
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/domain/errors/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/lib/domain/errors/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,4BAA4B,EAAE,MAAM,oCAAoC,CAAC;AAClF,OAAO,EAAE,4BAA4B,EAAE,MAAM,oCAAoC,CAAC"}

package/dist/lib/domain/errors/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebhookDeliveryNotFoundError = exports.WebhookEndpointNotFoundError = void 0;
+var webhook_endpoint_not_found_error_1 = require("./webhook-endpoint-not-found.error");
+Object.defineProperty(exports, "WebhookEndpointNotFoundError", { enumerable: true, get: function () { return webhook_endpoint_not_found_error_1.WebhookEndpointNotFoundError; } });
+var webhook_delivery_not_found_error_1 = require("./webhook-delivery-not-found.error");
+Object.defineProperty(exports, "WebhookDeliveryNotFoundError", { enumerable: true, get: function () { return webhook_delivery_not_found_error_1.WebhookDeliveryNotFoundError; } });

package/dist/lib/domain/errors/webhook-delivery-not-found.error.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Raised when a delivery id does not name a row **on the endpoint asked for**.
+ *
+ * Scoped to the endpoint deliberately: a delivery that exists elsewhere and one
+ * that does not exist at all must be indistinguishable, or the log becomes a
+ * way to probe for ids across endpoints.
+ */
+export declare class WebhookDeliveryNotFoundError extends Error {
+    readonly deliveryId: string;
+    constructor(deliveryId: string);
+}
+//# sourceMappingURL=webhook-delivery-not-found.error.d.ts.map

package/dist/lib/domain/errors/webhook-delivery-not-found.error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webhook-delivery-not-found.error.d.ts","sourceRoot":"","sources":["../../../../src/lib/domain/errors/webhook-delivery-not-found.error.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,qBAAa,4BAA6B,SAAQ,KAAK;aACvB,UAAU,EAAE,MAAM;gBAAlB,UAAU,EAAE,MAAM;CAIjD"}

package/dist/lib/domain/errors/webhook-delivery-not-found.error.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebhookDeliveryNotFoundError = void 0;
+/**
+ * Raised when a delivery id does not name a row **on the endpoint asked for**.
+ *
+ * Scoped to the endpoint deliberately: a delivery that exists elsewhere and one
+ * that does not exist at all must be indistinguishable, or the log becomes a
+ * way to probe for ids across endpoints.
+ */
+class WebhookDeliveryNotFoundError extends Error {
+    deliveryId;
+    constructor(deliveryId) {
+        super(`Webhook delivery ${deliveryId} was not found.`);
+        this.deliveryId = deliveryId;
+        this.name = 'WebhookDeliveryNotFoundError';
+    }
+}
+exports.WebhookDeliveryNotFoundError = WebhookDeliveryNotFoundError;

package/dist/lib/domain/errors/webhook-endpoint-not-found.error.d.ts

@@ -0,0 +1,6 @@
+/** Raised when an endpoint id does not name a row. Mapped to 404 by the http layer. */
+export declare class WebhookEndpointNotFoundError extends Error {
+    readonly endpointId: string;
+    constructor(endpointId: string);
+}
+//# sourceMappingURL=webhook-endpoint-not-found.error.d.ts.map

package/dist/lib/domain/errors/webhook-endpoint-not-found.error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webhook-endpoint-not-found.error.d.ts","sourceRoot":"","sources":["../../../../src/lib/domain/errors/webhook-endpoint-not-found.error.ts"],"names":[],"mappings":"AAAA,uFAAuF;AACvF,qBAAa,4BAA6B,SAAQ,KAAK;aACvB,UAAU,EAAE,MAAM;gBAAlB,UAAU,EAAE,MAAM;CAIjD"}

package/dist/lib/domain/errors/webhook-endpoint-not-found.error.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebhookEndpointNotFoundError = void 0;
+/** Raised when an endpoint id does not name a row. Mapped to 404 by the http layer. */
+class WebhookEndpointNotFoundError extends Error {
+    endpointId;
+    constructor(endpointId) {
+        super(`Webhook endpoint ${endpointId} was not found.`);
+        this.endpointId = endpointId;
+        this.name = 'WebhookEndpointNotFoundError';
+    }
+}
+exports.WebhookEndpointNotFoundError = WebhookEndpointNotFoundError;

package/dist/lib/domain/webhook-secret.d.ts

@@ -0,0 +1,29 @@
+/**
+ * The prefix every signing secret carries, so one found in a log or a config
+ * file is recognisable for what it is — and so a scanner can be taught to spot
+ * a leaked one.
+ */
+export declare const SECRET_PREFIX = "whsec_";
+/** A freshly minted signing secret and the hint stored alongside it. */
+export interface GeneratedSecret {
+    /** The full secret. Shown to the operator exactly once. */
+    secret: string;
+    /** The trailing characters, safe to display forever. */
+    hint: string;
+}
+/**
+ * Mints a signing secret.
+ *
+ * 32 bytes of `randomBytes` — the same order of entropy as the API tokens, and
+ * far more than an HMAC key needs. Base64url so it survives a shell, a YAML
+ * file and an environment variable without quoting.
+ */
+export declare function generateSecret(): GeneratedSecret;
+/**
+ * The displayable tail of a secret.
+ *
+ * Four characters is enough to tell "the one I rotated to" from "the one I
+ * replaced" and far too little to shorten a brute force against a 256-bit key.
+ */
+export declare function secretHint(secret: string): string;
+//# sourceMappingURL=webhook-secret.d.ts.map

package/dist/lib/domain/webhook-secret.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webhook-secret.d.ts","sourceRoot":"","sources":["../../../src/lib/domain/webhook-secret.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,eAAO,MAAM,aAAa,WAAW,CAAC;AAKtC,wEAAwE;AACxE,MAAM,WAAW,eAAe;IAC5B,2DAA2D;IAC3D,MAAM,EAAE,MAAM,CAAC;IACf,wDAAwD;IACxD,IAAI,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,IAAI,eAAe,CAGhD;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAEjD"}