@orthacms/webhooks-server 0.5.0

package/dist/lib/infrastructure/webhook-endpoint.repository.js

@@ -0,0 +1,306 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebhookEndpointRepository = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const database_1 = require("@orthacms/database");
+const drizzle_orm_1 = require("drizzle-orm");
+const webhook_secret_1 = require("../domain/webhook-secret");
+const webhook_deliveries_1 = require("./schema/webhook-deliveries");
+const webhook_endpoints_1 = require("./schema/webhook-endpoints");
+/** Reads and writes over the two endpoint tables. */
+let WebhookEndpointRepository = class WebhookEndpointRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    /**
+     * Every enabled endpoint with its workspace set, for fan-out.
+     *
+     * One query with an aggregated sub-select rather than a join: a join would
+     * return one row per workspace and force the caller to regroup, and this
+     * runs on every content write.
+     */
+    async listSubscriptions() {
+        const rows = await this.db
+            .select({
+            id: webhook_endpoints_1.webhookEndpoints.id,
+            enabled: webhook_endpoints_1.webhookEndpoints.enabled,
+            allWorkspaces: webhook_endpoints_1.webhookEndpoints.allWorkspaces,
+            eventKinds: webhook_endpoints_1.webhookEndpoints.eventKinds,
+            contentTypes: webhook_endpoints_1.webhookEndpoints.contentTypes,
+            workspaceIds: (0, drizzle_orm_1.sql) `coalesce((select array_agg(${webhook_endpoints_1.webhookEndpointWorkspaces.workspaceId}) from ${webhook_endpoints_1.webhookEndpointWorkspaces} where ${webhook_endpoints_1.webhookEndpointWorkspaces.endpointId} = ${webhook_endpoints_1.webhookEndpoints.id}), '{}')`
+        })
+            .from(webhook_endpoints_1.webhookEndpoints)
+            .where((0, drizzle_orm_1.eq)(webhook_endpoints_1.webhookEndpoints.enabled, true));
+        return rows.map((row) => ({
+            id: row.id,
+            enabled: row.enabled,
+            allWorkspaces: row.allWorkspaces,
+            workspaceIds: row.workspaceIds ?? [],
+            eventKinds: asStringArray(row.eventKinds),
+            contentTypes: asStringArray(row.contentTypes)
+        }));
+    }
+    /** The endpoint the worker is about to POST to, or null when it is gone. */
+    async findForDelivery(id) {
+        const [row] = await this.db
+            .select({
+            id: webhook_endpoints_1.webhookEndpoints.id,
+            name: webhook_endpoints_1.webhookEndpoints.name,
+            url: webhook_endpoints_1.webhookEndpoints.url,
+            secret: webhook_endpoints_1.webhookEndpoints.secret,
+            headers: webhook_endpoints_1.webhookEndpoints.headers,
+            enabled: webhook_endpoints_1.webhookEndpoints.enabled
+        })
+            .from(webhook_endpoints_1.webhookEndpoints)
+            .where((0, drizzle_orm_1.eq)(webhook_endpoints_1.webhookEndpoints.id, id))
+            .limit(1);
+        if (!row)
+            return null;
+        return { ...row, headers: asHeaderMap(row.headers) };
+    }
+    /** Every endpoint, newest first, each with its last delivery. */
+    async list() {
+        const rows = await this.db
+            .select()
+            .from(webhook_endpoints_1.webhookEndpoints)
+            .orderBy((0, drizzle_orm_1.desc)(webhook_endpoints_1.webhookEndpoints.createdAt));
+        if (rows.length === 0)
+            return [];
+        const ids = rows.map((row) => row.id);
+        const [workspaces, lastDeliveries] = await Promise.all([
+            this.workspacesFor(ids),
+            this.lastDeliveriesFor(ids)
+        ]);
+        return rows.map((row) => toView(row, workspaces.get(row.id) ?? [], lastDeliveries.get(row.id) ?? null));
+    }
+    /** One endpoint, or null. */
+    async findById(id) {
+        const [row] = await this.db
+            .select()
+            .from(webhook_endpoints_1.webhookEndpoints)
+            .where((0, drizzle_orm_1.eq)(webhook_endpoints_1.webhookEndpoints.id, id))
+            .limit(1);
+        if (!row)
+            return null;
+        const [workspaces, lastDeliveries] = await Promise.all([
+            this.workspacesFor([id]),
+            this.lastDeliveriesFor([id])
+        ]);
+        return toView(row, workspaces.get(id) ?? [], lastDeliveries.get(id) ?? null);
+    }
+    /**
+     * Creates an endpoint and its workspace set in one transaction, so an
+     * endpoint can never exist with half its subscription.
+     */
+    async create(model, secret, createdBy) {
+        return this.db.transaction(async (tx) => {
+            const [row] = await tx
+                .insert(webhook_endpoints_1.webhookEndpoints)
+                .values({
+                name: model.name,
+                url: model.url,
+                secret,
+                secretHint: (0, webhook_secret_1.secretHint)(secret),
+                enabled: model.enabled,
+                eventKinds: model.eventKinds,
+                contentTypes: model.contentTypes,
+                allWorkspaces: model.allWorkspaces,
+                headers: model.headers,
+                createdBy
+            })
+                .returning({ id: webhook_endpoints_1.webhookEndpoints.id });
+            await this.replaceWorkspaces(tx, row.id, model);
+            return row.id;
+        });
+    }
+    /** Applies a full write model to an existing endpoint. */
+    async update(id, model) {
+        await this.db.transaction(async (tx) => {
+            await tx
+                .update(webhook_endpoints_1.webhookEndpoints)
+                .set({
+                name: model.name,
+                url: model.url,
+                enabled: model.enabled,
+                eventKinds: model.eventKinds,
+                contentTypes: model.contentTypes,
+                allWorkspaces: model.allWorkspaces,
+                headers: model.headers,
+                // Re-enabling by hand clears the auto-disable state, so the
+                // reason shown in the UI can never outlive the condition.
+                disabledReason: model.enabled ? null : undefined,
+                consecutiveFailures: model.enabled ? 0 : undefined,
+                updatedAt: new Date()
+            })
+                .where((0, drizzle_orm_1.eq)(webhook_endpoints_1.webhookEndpoints.id, id));
+            await this.replaceWorkspaces(tx, id, model);
+        });
+    }
+    /** Rotates the signing secret. */
+    async replaceSecret(id, secret) {
+        await this.db
+            .update(webhook_endpoints_1.webhookEndpoints)
+            .set({
+            secret,
+            secretHint: (0, webhook_secret_1.secretHint)(secret),
+            updatedAt: new Date()
+        })
+            .where((0, drizzle_orm_1.eq)(webhook_endpoints_1.webhookEndpoints.id, id));
+    }
+    /** Deletes the endpoint; its workspaces and deliveries cascade. */
+    async delete(id) {
+        await this.db
+            .delete(webhook_endpoints_1.webhookEndpoints)
+            .where((0, drizzle_orm_1.eq)(webhook_endpoints_1.webhookEndpoints.id, id));
+    }
+    /** Whether an endpoint with this id exists. */
+    async exists(id) {
+        const [row] = await this.db
+            .select({ id: webhook_endpoints_1.webhookEndpoints.id })
+            .from(webhook_endpoints_1.webhookEndpoints)
+            .where((0, drizzle_orm_1.eq)(webhook_endpoints_1.webhookEndpoints.id, id))
+            .limit(1);
+        return row !== undefined;
+    }
+    /** Clears the consecutive-failure count after a delivery succeeded. */
+    async recordSuccess(id) {
+        await this.db
+            .update(webhook_endpoints_1.webhookEndpoints)
+            .set({ consecutiveFailures: 0 })
+            .where((0, drizzle_orm_1.eq)(webhook_endpoints_1.webhookEndpoints.id, id));
+    }
+    /**
+     * Counts one dead delivery against the endpoint and switches it off once
+     * `threshold` of them have arrived in a row.
+     *
+     * The increment and the test are one statement so two workers finishing
+     * failed deliveries at the same moment cannot both read the old count and
+     * both decide not to disable.
+     *
+     * @returns whether this failure switched the endpoint off.
+     */
+    async recordFailure(id, threshold) {
+        const reason = `Disabled automatically after ${threshold} consecutive failed deliveries.`;
+        const [row] = await this.db
+            .update(webhook_endpoints_1.webhookEndpoints)
+            .set({
+            consecutiveFailures: (0, drizzle_orm_1.sql) `${webhook_endpoints_1.webhookEndpoints.consecutiveFailures} + 1`,
+            enabled: (0, drizzle_orm_1.sql) `case when ${webhook_endpoints_1.webhookEndpoints.consecutiveFailures} + 1 >= ${threshold} then false else ${webhook_endpoints_1.webhookEndpoints.enabled} end`,
+            disabledReason: (0, drizzle_orm_1.sql) `case when ${webhook_endpoints_1.webhookEndpoints.consecutiveFailures} + 1 >= ${threshold} then ${reason} else ${webhook_endpoints_1.webhookEndpoints.disabledReason} end`
+        })
+            .where((0, drizzle_orm_1.eq)(webhook_endpoints_1.webhookEndpoints.id, id))
+            .returning({ enabled: webhook_endpoints_1.webhookEndpoints.enabled });
+        return row !== undefined && !row.enabled;
+    }
+    /** Replaces an endpoint's workspace rows to match `model`. */
+    async replaceWorkspaces(tx, endpointId, model) {
+        await tx
+            .delete(webhook_endpoints_1.webhookEndpointWorkspaces)
+            .where((0, drizzle_orm_1.eq)(webhook_endpoints_1.webhookEndpointWorkspaces.endpointId, endpointId));
+        // "All workspaces" is the flag, not a row per workspace: enumerating
+        // them would silently stop covering the next workspace created.
+        if (model.allWorkspaces || model.workspaceIds.length === 0)
+            return;
+        await tx.insert(webhook_endpoints_1.webhookEndpointWorkspaces).values(model.workspaceIds.map((workspaceId) => ({
+            endpointId,
+            workspaceId
+        })));
+    }
+    /** Workspace ids per endpoint, for a set of endpoints. */
+    async workspacesFor(endpointIds) {
+        const rows = await this.db
+            .select()
+            .from(webhook_endpoints_1.webhookEndpointWorkspaces)
+            .where((0, drizzle_orm_1.inArray)(webhook_endpoints_1.webhookEndpointWorkspaces.endpointId, endpointIds));
+        const grouped = new Map();
+        for (const row of rows) {
+            const list = grouped.get(row.endpointId) ?? [];
+            list.push(row.workspaceId);
+            grouped.set(row.endpointId, list);
+        }
+        return grouped;
+    }
+    /**
+     * The most recent delivery per endpoint.
+     *
+     * `DISTINCT ON` rather than a window function or N queries: one index scan
+     * over `(endpoint_id, created_at)` answers the whole list page.
+     */
+    async lastDeliveriesFor(endpointIds) {
+        const rows = await this.db
+            .selectDistinctOn([webhook_deliveries_1.webhookDeliveries.endpointId], {
+            id: webhook_deliveries_1.webhookDeliveries.id,
+            endpointId: webhook_deliveries_1.webhookDeliveries.endpointId,
+            status: webhook_deliveries_1.webhookDeliveries.status,
+            eventKind: webhook_deliveries_1.webhookDeliveries.eventKind,
+            statusCode: webhook_deliveries_1.webhookDeliveries.lastStatusCode,
+            createdAt: webhook_deliveries_1.webhookDeliveries.createdAt
+        })
+            .from(webhook_deliveries_1.webhookDeliveries)
+            .where((0, drizzle_orm_1.inArray)(webhook_deliveries_1.webhookDeliveries.endpointId, endpointIds))
+            .orderBy(webhook_deliveries_1.webhookDeliveries.endpointId, (0, drizzle_orm_1.desc)(webhook_deliveries_1.webhookDeliveries.createdAt));
+        return new Map(rows.map((row) => [
+            row.endpointId,
+            {
+                id: row.id,
+                status: row.status,
+                eventKind: row.eventKind,
+                statusCode: row.statusCode,
+                createdAt: row.createdAt.toISOString()
+            }
+        ]));
+    }
+};
+exports.WebhookEndpointRepository = WebhookEndpointRepository;
+exports.WebhookEndpointRepository = WebhookEndpointRepository = tslib_1.__decorate([
+    (0, common_1.Injectable)(),
+    tslib_1.__param(0, (0, database_1.InjectDatabase)()),
+    tslib_1.__metadata("design:paramtypes", [Object])
+], WebhookEndpointRepository);
+/** Row + its relations → the API shape. */
+function toView(row, workspaceIds, lastDelivery) {
+    return {
+        id: row.id,
+        name: row.name,
+        url: row.url,
+        secretHint: row.secretHint,
+        enabled: row.enabled,
+        eventKinds: asStringArray(row.eventKinds),
+        contentTypes: asStringArray(row.contentTypes),
+        allWorkspaces: row.allWorkspaces,
+        workspaceIds: row.allWorkspaces ? [] : workspaceIds,
+        headers: asHeaderMap(row.headers),
+        disabledReason: row.disabledReason,
+        consecutiveFailures: row.consecutiveFailures,
+        createdAt: row.createdAt.toISOString(),
+        updatedAt: row.updatedAt.toISOString(),
+        lastDelivery
+    };
+}
+/**
+ * A `jsonb` column read back as a string array.
+ *
+ * Drizzle types `jsonb` as `unknown`, and a row written before a column's shape
+ * settled — or by hand — could hold anything. Coercing here keeps every reader
+ * from repeating the check, and an unexpected shape degrades to "empty", which
+ * for these two columns means "everything" rather than a crash.
+ */
+function asStringArray(value) {
+    return Array.isArray(value)
+        ? value.filter((item) => typeof item === 'string')
+        : [];
+}
+/** A `jsonb` column read back as a header map, dropping non-string values. */
+function asHeaderMap(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+        return {};
+    }
+    const headers = {};
+    for (const [key, item] of Object.entries(value)) {
+        if (typeof item === 'string')
+            headers[key] = item;
+    }
+    return headers;
+}

package/dist/lib/infrastructure/webhook-fanout.subscriber.d.ts

@@ -0,0 +1,36 @@
+import { type OnApplicationBootstrap } from '@nestjs/common';
+import { OutboxDispatcher, type DomainEvent, type DomainEventSubscriber } from '@orthacms/database';
+import { WebhookDeliveryRepository } from './webhook-delivery.repository';
+import { WebhookEndpointRepository } from './webhook-endpoint.repository';
+/**
+ * Turns a domain event into queued deliveries — and does **nothing else**.
+ *
+ * This subscriber runs inside `OutboxDispatcher`'s claim transaction, which is
+ * the single most important fact about it. One `SELECT` over the endpoints and
+ * one batched `INSERT` is all it may cost: an outgoing HTTP request here would
+ * hold that transaction and its pool client open for a stranger's response
+ * time, and a thrown error would count against the **outbox row's** attempt
+ * budget, eventually dead-lettering an event the activity log and the alarms
+ * evaluator were also waiting for.
+ *
+ * The actual sending is {@link WebhookDeliveryWorker}'s job, with no
+ * transaction open.
+ *
+ * Delivery from the outbox is at-least-once, so this may see the same event
+ * twice; `unique(endpoint_id, event_id)` on the delivery row makes the repeat a
+ * no-op rather than a second POST.
+ */
+export declare class WebhookFanoutSubscriber implements DomainEventSubscriber, OnApplicationBootstrap {
+    private readonly dispatcher;
+    private readonly endpoints;
+    private readonly deliveries;
+    private readonly logger;
+    /** The dispatcher's delivery allow-list — the catalogue, minus `ping`. */
+    readonly kinds: readonly string[];
+    constructor(dispatcher: OutboxDispatcher, endpoints: WebhookEndpointRepository, deliveries: WebhookDeliveryRepository);
+    /** Registers with the dispatcher once the app is up. */
+    onApplicationBootstrap(): void;
+    /** Queues one delivery per endpoint that subscribes to this event. */
+    handle(event: DomainEvent): Promise<void>;
+}
+//# sourceMappingURL=webhook-fanout.subscriber.d.ts.map

package/dist/lib/infrastructure/webhook-fanout.subscriber.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webhook-fanout.subscriber.d.ts","sourceRoot":"","sources":["../../../src/lib/infrastructure/webhook-fanout.subscriber.ts"],"names":[],"mappings":"AAAA,OAAO,EAGH,KAAK,sBAAsB,EAC9B,MAAM,gBAAgB,CAAC;AAExB,OAAO,EACH,gBAAgB,EAChB,KAAK,WAAW,EAChB,KAAK,qBAAqB,EAC7B,MAAM,oBAAoB,CAAC;AAM5B,OAAO,EAAE,yBAAyB,EAAE,MAAM,+BAA+B,CAAC;AAC1E,OAAO,EAAE,yBAAyB,EAAE,MAAM,+BAA+B,CAAC;AAG1E;;;;;;;;;;;;;;;;;GAiBG;AACH,qBACa,uBACT,YAAW,qBAAqB,EAAE,sBAAsB;IAQpD,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,UAAU;IAR/B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA4C;IAEnE,0EAA0E;IAC1E,QAAQ,CAAC,KAAK,oBAA6B;gBAGtB,UAAU,EAAE,gBAAgB,EAC5B,SAAS,EAAE,yBAAyB,EACpC,UAAU,EAAE,yBAAyB;IAG1D,wDAAwD;IACxD,sBAAsB,IAAI,IAAI;IAI9B,sEAAsE;IAChE,MAAM,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;CAmClD"}

package/dist/lib/infrastructure/webhook-fanout.subscriber.js

@@ -0,0 +1,83 @@
+"use strict";
+var WebhookFanoutSubscriber_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebhookFanoutSubscriber = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const node_crypto_1 = require("node:crypto");
+const database_1 = require("@orthacms/database");
+const webhooks_domain_1 = require("@orthacms/webhooks-domain");
+const webhook_delivery_repository_1 = require("./webhook-delivery.repository");
+const webhook_endpoint_repository_1 = require("./webhook-endpoint.repository");
+const event_mapping_1 = require("./event-mapping");
+/**
+ * Turns a domain event into queued deliveries — and does **nothing else**.
+ *
+ * This subscriber runs inside `OutboxDispatcher`'s claim transaction, which is
+ * the single most important fact about it. One `SELECT` over the endpoints and
+ * one batched `INSERT` is all it may cost: an outgoing HTTP request here would
+ * hold that transaction and its pool client open for a stranger's response
+ * time, and a thrown error would count against the **outbox row's** attempt
+ * budget, eventually dead-lettering an event the activity log and the alarms
+ * evaluator were also waiting for.
+ *
+ * The actual sending is {@link WebhookDeliveryWorker}'s job, with no
+ * transaction open.
+ *
+ * Delivery from the outbox is at-least-once, so this may see the same event
+ * twice; `unique(endpoint_id, event_id)` on the delivery row makes the repeat a
+ * no-op rather than a second POST.
+ */
+let WebhookFanoutSubscriber = WebhookFanoutSubscriber_1 = class WebhookFanoutSubscriber {
+    dispatcher;
+    endpoints;
+    deliveries;
+    logger = new common_1.Logger(WebhookFanoutSubscriber_1.name);
+    /** The dispatcher's delivery allow-list — the catalogue, minus `ping`. */
+    kinds = webhooks_domain_1.SUBSCRIBABLE_OUTBOX_KINDS;
+    constructor(dispatcher, endpoints, deliveries) {
+        this.dispatcher = dispatcher;
+        this.endpoints = endpoints;
+        this.deliveries = deliveries;
+    }
+    /** Registers with the dispatcher once the app is up. */
+    onApplicationBootstrap() {
+        this.dispatcher.register(this);
+    }
+    /** Queues one delivery per endpoint that subscribes to this event. */
+    async handle(event) {
+        const subscriptions = await this.endpoints.listSubscriptions();
+        if (subscriptions.length === 0)
+            return;
+        const routable = (0, event_mapping_1.toRoutableEvent)(event);
+        const interested = subscriptions.filter((subscription) => (0, webhooks_domain_1.matches)(subscription, routable));
+        if (interested.length === 0)
+            return;
+        const source = (0, event_mapping_1.toSourceEvent)(event);
+        const queued = await this.deliveries.enqueue(interested.map((subscription) => {
+            // The id is minted here rather than by the database because the
+            // envelope carries it: the body and the `X-Ortha-Delivery`
+            // header have to name the same delivery.
+            const deliveryId = (0, node_crypto_1.randomUUID)();
+            return {
+                id: deliveryId,
+                endpointId: subscription.id,
+                eventId: event.eventId,
+                eventKind: event.kind,
+                workspaceId: routable.workspaceId,
+                contentType: routable.contentType,
+                payload: (0, webhooks_domain_1.buildEnvelope)(deliveryId, source)
+            };
+        }));
+        if (queued > 0) {
+            this.logger.debug(`Queued ${queued} webhook deliver${queued === 1 ? 'y' : 'ies'} for ${event.kind}.`);
+        }
+    }
+};
+exports.WebhookFanoutSubscriber = WebhookFanoutSubscriber;
+exports.WebhookFanoutSubscriber = WebhookFanoutSubscriber = WebhookFanoutSubscriber_1 = tslib_1.__decorate([
+    (0, common_1.Injectable)(),
+    tslib_1.__metadata("design:paramtypes", [database_1.OutboxDispatcher,
+        webhook_endpoint_repository_1.WebhookEndpointRepository,
+        webhook_delivery_repository_1.WebhookDeliveryRepository])
+], WebhookFanoutSubscriber);

package/dist/lib/infrastructure/webhook-http.client.d.ts

@@ -0,0 +1,76 @@
+import type { ResolvedWebhooksConfig } from '../types/webhooks-config';
+/** Everything one POST needs. */
+export interface WebhookRequest {
+    url: string;
+    secret: string;
+    /** Extra static headers from the endpoint's configuration. */
+    headers: Record<string, string>;
+    /** The envelope. Serialised once, because the signature covers the bytes. */
+    body: unknown;
+    eventKind: string;
+    deliveryId: string;
+    eventId: string;
+    workspaceId: string | null;
+    /** 1-based, sent as `X-Ortha-Attempt`. */
+    attempt: number;
+}
+/** What came back. */
+export interface WebhookResponse {
+    /** The HTTP status, or null when nothing answered. */
+    statusCode: number | null;
+    /** A `Retry-After`, in milliseconds from now, when the receiver sent one. */
+    retryAfterMs?: number;
+    /** Why it failed, when no status came back. */
+    error: string | null;
+    /** The first `responseSnippetBytes` of the body. */
+    responseSnippet: string | null;
+    durationMs: number;
+}
+/**
+ * Posts one delivery, under the policy that decides where this server may be
+ * talked into connecting.
+ *
+ * **Why an `undici.Agent` and not `fetch`.** The address has to be checked
+ * *after* the hostname resolves and the connection has to go to that same
+ * address. Global `fetch` gives no hook between the two, so a name that passes
+ * a pre-flight check and then resolves to `169.254.169.254` — DNS rebinding —
+ * connects anyway. A custom `lookup` is the seam where the resolved address is
+ * judged and either handed to the connector or refused.
+ *
+ * Redirects are not followed. A `3xx` is reported as a failed delivery rather
+ * than an invitation to make a second request, because following one is the
+ * simplest way to be walked to an internal address after the first hop passed.
+ */
+export declare class WebhookHttpClient {
+    private readonly config;
+    private readonly logger;
+    /**
+     * One agent for every delivery, so connections are pooled across them.
+     * Built lazily because it captures the policy from injected config.
+     */
+    private agent;
+    constructor(config: ResolvedWebhooksConfig);
+    /** Sends one delivery and reports what happened. Never throws. */
+    send(delivery: WebhookRequest): Promise<WebhookResponse>;
+    /** The URL policy this deployment configured. */
+    private policy;
+    /**
+     * The agent, with the address check wired into its DNS lookup.
+     *
+     * `lookup` is called by the connector with the hostname it is about to
+     * connect to; refusing here means the socket is never opened, and the
+     * address that was judged is the address that would have been used.
+     */
+    private dispatcher;
+    /** The headers one delivery travels with. */
+    private headersFor;
+    /**
+     * Reads at most `responseSnippetBytes` of the body, then abandons the rest.
+     *
+     * A receiver that answers with a gigabyte would otherwise be able to
+     * exhaust this process's memory from the far end of a connection we
+     * initiated.
+     */
+    private readSnippet;
+}
+//# sourceMappingURL=webhook-http.client.d.ts.map

package/dist/lib/infrastructure/webhook-http.client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webhook-http.client.d.ts","sourceRoot":"","sources":["../../../src/lib/infrastructure/webhook-http.client.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AAEvE,iCAAiC;AACjC,MAAM,WAAW,cAAc;IAC3B,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,8DAA8D;IAC9D,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,6EAA6E;IAC7E,IAAI,EAAE,OAAO,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,0CAA0C;IAC1C,OAAO,EAAE,MAAM,CAAC;CACnB;AAED,sBAAsB;AACtB,MAAM,WAAW,eAAe;IAC5B,sDAAsD;IACtD,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,6EAA6E;IAC7E,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,+CAA+C;IAC/C,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,oDAAoD;IACpD,eAAe,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,UAAU,EAAE,MAAM,CAAC;CACtB;AAED;;;;;;;;;;;;;;GAcG;AACH,qBACa,iBAAiB;IAWtB,OAAO,CAAC,QAAQ,CAAC,MAAM;IAV3B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAsC;IAE7D;;;OAGG;IACH,OAAO,CAAC,KAAK,CAAsB;gBAId,MAAM,EAAE,sBAAsB;IAGnD,kEAAkE;IAC5D,IAAI,CAAC,QAAQ,EAAE,cAAc,GAAG,OAAO,CAAC,eAAe,CAAC;IA4C9D,iDAAiD;IACjD,OAAO,CAAC,MAAM;IAOd;;;;;;OAMG;IACH,OAAO,CAAC,UAAU;IAiClB,6CAA6C;IAC7C,OAAO,CAAC,UAAU;IAiClB;;;;;;OAMG;YACW,WAAW;CA8B5B"}