webhook-delivery-engine 0.0.0-stage → 1.0.0

package/dist/src/features/delivery/delivery.classify.d.ts

@@ -0,0 +1,28 @@
+import type { AttemptOutcome, EventStatus } from '../../core/types.js';
+/** Inputs needed to classify one completed outbound dispatch. */
+export interface ClassifyDeliveryResultInput {
+    /** HTTP response status, or null when dispatch did not receive a response. */
+    readonly statusCode: number | null;
+    /** 1-based attempt count reserved when the event was claimed. */
+    readonly attemptCount: number;
+    /** Configured maximum number of dispatch attempts. */
+    readonly maxAttempts: number;
+}
+/** Terminal event transition and corresponding durable attempt outcome. */
+export interface DeliveryClassification {
+    readonly outcome: AttemptOutcome;
+    readonly nextStatus: Extract<EventStatus, 'delivered' | 'retry' | 'failed'>;
+}
+/**
+ * Classifies the HTTP result and attempt ceiling into the next event state.
+ *
+ * Only 2xx responses succeed. 4xx responses retry only for 408, 409, and 429;
+ * other 4xx responses fail immediately. All other unsuccessful results retry
+ * until `maxAttempts`. The existing `exhausted` outcome marks either kind of
+ * terminal unsuccessful delivery.
+ *
+ * @param input - Dispatch status and configured retry limit.
+ * @returns The persisted outcome and next event state.
+ * @throws {RangeError} When the attempt count, limit, or status code is invalid.
+ */
+export declare function classifyDeliveryResult(input: ClassifyDeliveryResultInput): DeliveryClassification;

package/dist/src/features/delivery/delivery.classify.js

@@ -0,0 +1,38 @@
+const RETRYABLE_CLIENT_ERRORS = new Set([408, 409, 429]);
+/**
+ * Classifies the HTTP result and attempt ceiling into the next event state.
+ *
+ * Only 2xx responses succeed. 4xx responses retry only for 408, 409, and 429;
+ * other 4xx responses fail immediately. All other unsuccessful results retry
+ * until `maxAttempts`. The existing `exhausted` outcome marks either kind of
+ * terminal unsuccessful delivery.
+ *
+ * @param input - Dispatch status and configured retry limit.
+ * @returns The persisted outcome and next event state.
+ * @throws {RangeError} When the attempt count, limit, or status code is invalid.
+ */
+export function classifyDeliveryResult(input) {
+    if (!Number.isSafeInteger(input.attemptCount) || input.attemptCount < 1) {
+        throw new RangeError('attemptCount must be a positive safe integer.');
+    }
+    if (!Number.isSafeInteger(input.maxAttempts) || input.maxAttempts < 1) {
+        throw new RangeError('maxAttempts must be a positive safe integer.');
+    }
+    if (input.statusCode !== null &&
+        (!Number.isSafeInteger(input.statusCode) || input.statusCode < 100 || input.statusCode > 599)) {
+        throw new RangeError('statusCode must be null or an HTTP status from 100 through 599.');
+    }
+    if (input.statusCode !== null && input.statusCode >= 200 && input.statusCode < 300) {
+        return { outcome: 'success', nextStatus: 'delivered' };
+    }
+    if (input.statusCode !== null &&
+        input.statusCode >= 400 &&
+        input.statusCode < 500 &&
+        !RETRYABLE_CLIENT_ERRORS.has(input.statusCode)) {
+        return { outcome: 'exhausted', nextStatus: 'failed' };
+    }
+    if (input.attemptCount >= input.maxAttempts) {
+        return { outcome: 'exhausted', nextStatus: 'failed' };
+    }
+    return { outcome: 'retry_scheduled', nextStatus: 'retry' };
+}

package/dist/src/features/delivery/delivery.dispatcher.d.ts

@@ -0,0 +1,57 @@
+import type { WebhookEvent } from '../../core/types.js';
+/**
+ * Input required to dispatch one outbound webhook delivery attempt.
+ */
+export interface DispatchInput {
+    /** The claimed event to dispatch. */
+    readonly event: WebhookEvent;
+    /** HMAC secret used by the signing module (must be non-empty). */
+    readonly hmacSecret: string;
+    /** Maximum duration of the outbound HTTP request in milliseconds. */
+    readonly timeoutLimitMs: number;
+}
+/**
+ * Structured result of a single outbound HTTP dispatch attempt.
+ *
+ * Does NOT include the attempt outcome classification or DB writes — those
+ * are the responsibility of WBS 5.4.
+ */
+export interface DispatchResult {
+    /** HTTP response status code, or null when no response was received. */
+    readonly statusCode: number | null;
+    /** Round-trip duration in whole milliseconds. */
+    readonly latencyMs: number;
+    /**
+     * First 1 KB of the response body, or null when the body is empty or no
+     * response was received.
+     */
+    readonly responseSnippet: string | null;
+    /**
+     * Non-secret error description for timeout or transport failures, or null
+     * on a successful HTTP exchange (any status code).
+     */
+    readonly error: string | null;
+}
+/**
+ * Executes one outbound HTTP POST to the event's destination URL.
+ *
+ * Responsibilities:
+ * - Serialise the event payload plus `webhookEventId` into a JSON body.
+ * - Sign the request with HMAC-SHA256 via {@link signRequest}.
+ * - Merge event-specific headers; engine-owned signing headers take
+ *   precedence over any event-level header with the same name.
+ * - Re-resolve and classify the destination for this attempt, then pin one
+ *   validated address in a request-scoped Undici Agent.
+ * - Bind an `AbortController` timer to `timeoutLimitMs`.
+ * - Capture status code, latency, and a ≤ 1 KB response snippet.
+ * - Map `AbortError` to `{ statusCode: null, error: 'timeout' }`.
+ * - Map other transport errors to `{ statusCode: null, error: '<generic>' }`
+ *   without leaking internal details.
+ *
+ * Does NOT persist attempt records or apply outcome classification — those
+ * are handled by WBS 5.4.
+ *
+ * @param input - Event, HMAC secret, and timeout configuration.
+ * @returns A structured dispatch result.
+ */
+export declare function dispatchEvent(input: DispatchInput): Promise<DispatchResult>;

package/dist/src/features/delivery/delivery.dispatcher.js

@@ -0,0 +1,155 @@
+import { isIP } from 'node:net';
+import { Agent, fetch, Headers as UndiciHeaders } from 'undici';
+import { resolveDestinationForDispatch } from '../../security/ssrf.js';
+import { signRequest } from './delivery.hmac.js';
+/** Maximum response body length captured as a snippet (SDD §4.2). */
+const MAX_SNIPPET_BYTES = 1024;
+function pinnedLookup(expectedHostname, addresses) {
+    const pinnedAddress = addresses[0];
+    const pinnedFamily = pinnedAddress === undefined ? 0 : isIP(pinnedAddress);
+    return (hostname, options, callback) => {
+        const requestedHostname = hostname.toLowerCase().replace(/\.$/u, '');
+        const pinnedHostname = expectedHostname.toLowerCase().replace(/\.$/u, '');
+        if (requestedHostname !== pinnedHostname) {
+            const error = Object.assign(new Error('Pinned destination mismatch'), { code: 'EAI_FAIL' });
+            if (options.all) {
+                callback(error, []);
+            }
+            else {
+                callback(error, '', 0);
+            }
+            return;
+        }
+        if (pinnedAddress === undefined || pinnedFamily === 0) {
+            const error = Object.assign(new Error('No validated destination address'), {
+                code: 'EAI_NONAME',
+            });
+            if (options.all) {
+                callback(error, []);
+            }
+            else {
+                callback(error, '', 0);
+            }
+            return;
+        }
+        if (options.all) {
+            callback(null, [{ address: pinnedAddress, family: pinnedFamily }]);
+        }
+        else {
+            callback(null, pinnedAddress, pinnedFamily);
+        }
+    };
+}
+/**
+ * Executes one outbound HTTP POST to the event's destination URL.
+ *
+ * Responsibilities:
+ * - Serialise the event payload plus `webhookEventId` into a JSON body.
+ * - Sign the request with HMAC-SHA256 via {@link signRequest}.
+ * - Merge event-specific headers; engine-owned signing headers take
+ *   precedence over any event-level header with the same name.
+ * - Re-resolve and classify the destination for this attempt, then pin one
+ *   validated address in a request-scoped Undici Agent.
+ * - Bind an `AbortController` timer to `timeoutLimitMs`.
+ * - Capture status code, latency, and a ≤ 1 KB response snippet.
+ * - Map `AbortError` to `{ statusCode: null, error: 'timeout' }`.
+ * - Map other transport errors to `{ statusCode: null, error: '<generic>' }`
+ *   without leaking internal details.
+ *
+ * Does NOT persist attempt records or apply outcome classification — those
+ * are handled by WBS 5.4.
+ *
+ * @param input - Event, HMAC secret, and timeout configuration.
+ * @returns A structured dispatch result.
+ */
+export async function dispatchEvent(input) {
+    const { event, hmacSecret, timeoutLimitMs } = input;
+    // Build the outbound JSON body: payload merged with the engine-injected id.
+    const bodyObject = {
+        ...(typeof event.payload === 'object' && event.payload !== null && !Array.isArray(event.payload)
+            ? event.payload
+            : { payload: event.payload }),
+        webhookEventId: event.id,
+    };
+    const bodyString = JSON.stringify(bodyObject);
+    // Compute HMAC-signed engine headers.
+    const signedHeaders = signRequest({
+        secret: hmacSecret,
+        eventId: event.id,
+        body: bodyString,
+    });
+    // Merge headers: event-specific first, engine-owned last (engine wins).
+    const mergedHeaders = new UndiciHeaders({
+        'content-type': 'application/json',
+        ...event.headers,
+        ...signedHeaders,
+    });
+    // Bind an AbortController to enforce the request timeout.
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutLimitMs);
+    let rejectOnAbort;
+    const abortPromise = new Promise((_resolve, reject) => {
+        rejectOnAbort = reject;
+    });
+    const onAbort = () => rejectOnAbort?.(new DOMException('The operation was aborted', 'AbortError'));
+    controller.signal.addEventListener('abort', onAbort, { once: true });
+    const startMs = Date.now();
+    let agent;
+    try {
+        const resolution = await Promise.race([
+            resolveDestinationForDispatch(event.destinationUrl),
+            abortPromise,
+        ]);
+        if (!resolution.valid) {
+            return {
+                statusCode: null,
+                latencyMs: Date.now() - startMs,
+                responseSnippet: null,
+                error: 'network error',
+            };
+        }
+        agent = new Agent({
+            connections: 1,
+            pipelining: 0,
+            maxCachedSessions: 0,
+            connect: {
+                lookup: pinnedLookup(resolution.hostname, resolution.addresses),
+            },
+        });
+        const response = await fetch(resolution.url, {
+            method: 'POST',
+            headers: mergedHeaders,
+            body: bodyString,
+            signal: controller.signal,
+            dispatcher: agent,
+            redirect: 'error', // never follow redirects (SDD §5.1 / ADR-0006)
+        });
+        clearTimeout(timer);
+        const latencyMs = Date.now() - startMs;
+        const rawBody = await response.text();
+        const responseSnippet = rawBody.length === 0 ? null : rawBody.slice(0, MAX_SNIPPET_BYTES);
+        return {
+            statusCode: response.status,
+            latencyMs,
+            responseSnippet,
+            error: null,
+        };
+    }
+    catch (error) {
+        const latencyMs = Date.now() - startMs;
+        const isAbort = controller.signal.aborted || (error instanceof DOMException && error.name === 'AbortError');
+        return {
+            statusCode: null,
+            latencyMs,
+            responseSnippet: null,
+            error: isAbort ? 'timeout' : 'network error',
+        };
+    }
+    finally {
+        clearTimeout(timer);
+        controller.signal.removeEventListener('abort', onAbort);
+        if (agent !== undefined) {
+            await agent.close();
+        }
+    }
+}

package/dist/src/features/delivery/delivery.hmac.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Input required to produce a signed set of outbound delivery headers.
+ */
+export interface SignRequestInput {
+    /**
+     * HMAC secret used to compute the signature.
+     *
+     * Must be non-empty; an empty secret is rejected to enforce FR-13 (no
+     * unsigned dispatch).
+     */
+    readonly secret: string;
+    /**
+     * System-generated event id written into `x-webhook-event-id`.
+     *
+     * Enables the consumer to deduplicate at-least-once deliveries by a stable,
+     * non-enumerable identifier (A2, C4).
+     */
+    readonly eventId: string;
+    /**
+     * Raw JSON body string that will be sent in the request body.
+     *
+     * The signature is computed over `"${timestampSeconds}.${body}"` so the
+     * consumer can independently verify integrity and freshness.
+     */
+    readonly body: string;
+    /**
+     * Optional epoch millisecond clock override for testing.
+     *
+     * When omitted, `Date.now()` is used. Injecting a fixed value produces
+     * deterministic timestamps and signatures in tests without side effects.
+     */
+    readonly nowMs?: number;
+}
+/**
+ * The three engine-owned outbound headers produced by {@link signRequest}.
+ *
+ * All values are strings so the record is directly spreadable into any
+ * headers map accepted by the HTTP client.
+ */
+export interface SignedHeaders {
+    /** HMAC-SHA256 signature prefixed with `sha256=` (FR-11). */
+    readonly 'x-webhook-signature': string;
+    /** Request timestamp in Unix seconds as a decimal string (FR-12). */
+    readonly 'x-webhook-timestamp': string;
+    /** System event id for consumer deduplication (A2). */
+    readonly 'x-webhook-event-id': string;
+}
+/**
+ * Computes and returns the three engine-owned outbound delivery headers.
+ *
+ * The signature is `HMAC-SHA256(secret, timestampSeconds + '.' + body)` where
+ * `timestampSeconds` is the floor of `nowMs / 1000`. Including the timestamp
+ * in the signed material defeats replay attacks on captured requests (NFR-S2).
+ *
+ * @param input - Signing material: secret, event id, raw JSON body, and an
+ * optional fixed-clock override for deterministic testing.
+ * @returns The three canonical signed headers ready to merge into the outbound
+ * request headers map.
+ * @throws {Error} When `secret` is an empty string (FR-13: no unsigned
+ * dispatch).
+ */
+export declare function signRequest(input: SignRequestInput): SignedHeaders;

package/dist/src/features/delivery/delivery.hmac.js

@@ -0,0 +1,31 @@
+import { createHmac } from 'node:crypto';
+/**
+ * Computes and returns the three engine-owned outbound delivery headers.
+ *
+ * The signature is `HMAC-SHA256(secret, timestampSeconds + '.' + body)` where
+ * `timestampSeconds` is the floor of `nowMs / 1000`. Including the timestamp
+ * in the signed material defeats replay attacks on captured requests (NFR-S2).
+ *
+ * @param input - Signing material: secret, event id, raw JSON body, and an
+ * optional fixed-clock override for deterministic testing.
+ * @returns The three canonical signed headers ready to merge into the outbound
+ * request headers map.
+ * @throws {Error} When `secret` is an empty string (FR-13: no unsigned
+ * dispatch).
+ */
+export function signRequest(input) {
+    if (input.secret.length === 0) {
+        throw new Error('HMAC secret must not be empty; unsigned dispatch is not permitted (FR-13).');
+    }
+    const nowMs = input.nowMs ?? Date.now();
+    const timestampSeconds = String(Math.floor(nowMs / 1000));
+    const signedPayload = `${timestampSeconds}.${input.body}`;
+    const signature = createHmac('sha256', input.secret)
+        .update(signedPayload)
+        .digest('hex');
+    return {
+        'x-webhook-signature': `sha256=${signature}`,
+        'x-webhook-timestamp': timestampSeconds,
+        'x-webhook-event-id': input.eventId,
+    };
+}

package/dist/src/features/delivery/delivery.worker.d.ts

@@ -0,0 +1,60 @@
+import type { RetryPolicy } from '../../config/engine.config.js';
+import type { DatabaseAdapter } from '../../core/ports.js';
+import type { AttemptRecord, EventStatus, Timestamp, WebhookEvent } from '../../core/types.js';
+import { dispatchEvent, type DispatchInput } from './delivery.dispatcher.js';
+import type { OnClaimCallback } from '../scheduler/scheduler.js';
+/** Narrow persistence boundary required by one delivery attempt. */
+export type DeliveryAttemptAdapter = Pick<DatabaseAdapter, 'recordAttemptAndTransition'>;
+/** Dependencies for processing one claimed event. */
+export interface DeliveryProcessorOptions {
+    readonly adapter: DeliveryAttemptAdapter;
+    readonly hmacSecret: string;
+    readonly timeoutLimitMs: number;
+    readonly retry: RetryPolicy;
+    /** Optional transport seam, primarily useful for deterministic tests. */
+    readonly dispatch?: (input: DispatchInput) => ReturnType<typeof dispatchEvent>;
+    /** UTC time source, called once before dispatch and once before persistence. */
+    readonly now?: () => Timestamp;
+    /** Identifier source for the append-only attempt row. */
+    readonly createId?: () => string;
+    /** Called after persistence returns the attempt transition result. */
+    readonly onAttemptCompleted?: (event: WebhookEvent, result: DeliveryAttemptCompletion) => void;
+}
+/** Safe, payload-free summary of an attempt and its persistence result. */
+export interface DeliveryAttemptCompletion {
+    readonly outcome: AttemptRecord['outcome'];
+    readonly nextStatus: Extract<EventStatus, 'delivered' | 'retry' | 'failed'>;
+    readonly statusCode: number | null;
+    readonly latencyMs: number;
+    readonly persisted: boolean;
+}
+/** Processing failure callback for the scheduler-compatible worker adapter. */
+export type DeliveryWorkerErrorHandler = (error: unknown, event: WebhookEvent) => void;
+/** Dependencies for adapting the async processor to the scheduler callback. */
+export interface DeliveryWorkerOptions extends DeliveryProcessorOptions {
+    readonly onError: DeliveryWorkerErrorHandler;
+    /** Called after dispatch starts with the promise that includes persistence. */
+    readonly onDispatchStarted?: (event: WebhookEvent, work: Promise<boolean>) => void;
+}
+/**
+ * Dispatches one claimed event, classifies its result, and atomically records
+ * the attempt with the resulting event transition.
+ *
+ * `WebhookEvent.attemptCount` is already reserved by the claim operation, so
+ * it is also this attempt's 1-based audit ordinal. A lost lease is returned as
+ * `false` by the adapter without writing a stale attempt or state transition.
+ *
+ * @param event - Processing event returned by the atomic claim operation.
+ * @param options - Adapter, signing, timeout, retry, and optional test seams.
+ * @returns Whether the adapter committed the attempt and state transition.
+ * @throws When the event has no active lease or a dependency fails.
+ */
+export declare function processDeliveryAttempt(event: WebhookEvent, options: DeliveryProcessorOptions): Promise<boolean>;
+/**
+ * Creates a synchronous callback accepted by `ClaimScheduler` while keeping
+ * delivery and database failures observable through the required error hook.
+ *
+ * @param options - Processor dependencies and mandatory error handler.
+ * @returns A scheduler-compatible callback that starts one async attempt.
+ */
+export declare function createDeliveryWorker(options: DeliveryWorkerOptions): OnClaimCallback;

package/dist/src/features/delivery/delivery.worker.js

@@ -0,0 +1,136 @@
+import { randomUUID } from 'node:crypto';
+import { Buffer } from 'node:buffer';
+import { calculateNextRetryAt } from './delivery.backoff.js';
+import { classifyDeliveryResult } from './delivery.classify.js';
+import { dispatchEvent } from './delivery.dispatcher.js';
+/**
+ * Dispatches one claimed event, classifies its result, and atomically records
+ * the attempt with the resulting event transition.
+ *
+ * `WebhookEvent.attemptCount` is already reserved by the claim operation, so
+ * it is also this attempt's 1-based audit ordinal. A lost lease is returned as
+ * `false` by the adapter without writing a stale attempt or state transition.
+ *
+ * @param event - Processing event returned by the atomic claim operation.
+ * @param options - Adapter, signing, timeout, retry, and optional test seams.
+ * @returns Whether the adapter committed the attempt and state transition.
+ * @throws When the event has no active lease or a dependency fails.
+ */
+export async function processDeliveryAttempt(event, options) {
+    if (event.status !== 'processing' || event.lockedBy === null) {
+        throw new Error('The event must have an active processing lease before dispatch.');
+    }
+    if (!Number.isSafeInteger(event.attemptCount) || event.attemptCount < 1) {
+        throw new RangeError('event.attemptCount must be a positive safe integer.');
+    }
+    const attemptedAt = (options.now ?? defaultNow)();
+    const dispatch = options.dispatch ?? dispatchEvent;
+    const result = await dispatch({
+        event,
+        hmacSecret: options.hmacSecret,
+        timeoutLimitMs: options.timeoutLimitMs,
+    });
+    const updatedAt = (options.now ?? defaultNow)();
+    const classification = classifyDeliveryResult({
+        statusCode: result.statusCode,
+        attemptCount: event.attemptCount,
+        maxAttempts: options.retry.maxAttempts,
+    });
+    const nextRetryAt = classification.outcome === 'retry_scheduled'
+        ? calculateNextRetryAt({
+            attempt: event.attemptCount,
+            baseDelayMs: options.retry.baseDelayMs,
+            maxDelayMs: options.retry.maxDelayMs,
+            now: updatedAt,
+        }).nextRetryAt
+        : null;
+    const attempt = {
+        id: (options.createId ?? randomUUID)(),
+        eventId: event.id,
+        attemptNumber: event.attemptCount,
+        attemptedAt,
+        statusCode: result.statusCode,
+        responseSnippet: truncateSnippet(result.responseSnippet),
+        error: result.error ?? fallbackError(result.statusCode, classification.outcome),
+        latencyMs: result.latencyMs,
+        outcome: classification.outcome,
+    };
+    const transition = createTransition(attempt, event.lockedBy, classification.outcome, nextRetryAt, updatedAt);
+    const persisted = await options.adapter.recordAttemptAndTransition(transition);
+    options.onAttemptCompleted?.(event, {
+        outcome: classification.outcome,
+        nextStatus: transition.nextStatus,
+        statusCode: result.statusCode,
+        latencyMs: result.latencyMs,
+        persisted,
+    });
+    return persisted;
+}
+/**
+ * Creates a synchronous callback accepted by `ClaimScheduler` while keeping
+ * delivery and database failures observable through the required error hook.
+ *
+ * @param options - Processor dependencies and mandatory error handler.
+ * @returns A scheduler-compatible callback that starts one async attempt.
+ */
+export function createDeliveryWorker(options) {
+    return (event) => {
+        const work = processDeliveryAttempt(event, options);
+        options.onDispatchStarted?.(event, work);
+        void work.catch((error) => {
+            options.onError(error, event);
+        });
+    };
+}
+function createTransition(attempt, workerId, outcome, nextRetryAt, updatedAt) {
+    switch (outcome) {
+        case 'success':
+            return {
+                attempt: { ...attempt, outcome },
+                workerId,
+                nextStatus: 'delivered',
+                nextRetryAt: null,
+                updatedAt,
+            };
+        case 'retry_scheduled':
+            // This path is reached only after calculating the retry timestamp for
+            // the discriminated retry_scheduled outcome above.
+            return {
+                attempt: { ...attempt, outcome },
+                workerId,
+                nextStatus: 'retry',
+                nextRetryAt: nextRetryAt,
+                updatedAt,
+            };
+        case 'exhausted':
+            return {
+                attempt: { ...attempt, outcome },
+                workerId,
+                nextStatus: 'failed',
+                nextRetryAt: null,
+                updatedAt,
+            };
+    }
+}
+function fallbackError(statusCode, outcome) {
+    if (outcome === 'success')
+        return null;
+    return statusCode === null ? 'network error' : `HTTP ${statusCode}`;
+}
+function defaultNow() {
+    return new Date().toISOString();
+}
+function truncateSnippet(snippet) {
+    if (snippet === null || Buffer.byteLength(snippet, 'utf8') <= 1024)
+        return snippet;
+    let byteLength = 0;
+    let truncated = '';
+    for (const character of snippet) {
+        const characterBytes = Buffer.byteLength(character, 'utf8');
+        if (byteLength + characterBytes > 1024)
+            break;
+        truncated += character;
+        byteLength += characterBytes;
+    }
+    return truncated;
+}

package/dist/src/features/http/http.responses.d.ts

@@ -0,0 +1,6 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import type { AttemptRecord, WebhookEvent } from '../../core/types.js';
+export declare function sendJson(response: ServerResponse, statusCode: number, body: unknown): void;
+export declare function readJsonBody(request: IncomingMessage): Promise<unknown>;
+export declare function serializeEvent(event: WebhookEvent): Record<string, unknown>;
+export declare function serializeAttempt(attempt: AttemptRecord): Record<string, unknown>;

package/dist/src/features/http/http.responses.js

@@ -0,0 +1,45 @@
+export function sendJson(response, statusCode, body) {
+    response.writeHead(statusCode, {
+        'content-type': 'application/json; charset=utf-8',
+        'x-content-type-options': 'nosniff',
+    });
+    response.end(JSON.stringify(body));
+}
+export async function readJsonBody(request) {
+    const chunks = [];
+    for await (const chunk of request) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    return JSON.parse(Buffer.concat(chunks).toString('utf8'));
+}
+export function serializeEvent(event) {
+    return {
+        id: event.id,
+        idempotency_key: event.idempotencyKey,
+        client_id: event.clientId,
+        destination_url: event.destinationUrl,
+        payload: event.payload,
+        metadata: event.metadata,
+        headers: event.headers,
+        status: event.status,
+        attempt_count: event.attemptCount,
+        next_retry_at: event.nextRetryAt,
+        locked_at: event.lockedAt,
+        locked_by: event.lockedBy,
+        created_at: event.createdAt,
+        updated_at: event.updatedAt,
+    };
+}
+export function serializeAttempt(attempt) {
+    return {
+        id: attempt.id,
+        event_id: attempt.eventId,
+        attempt_number: attempt.attemptNumber,
+        attempted_at: attempt.attemptedAt,
+        status_code: attempt.statusCode,
+        response_snippet: attempt.responseSnippet,
+        error: attempt.error,
+        latency_ms: attempt.latencyMs,
+        outcome: attempt.outcome,
+    };
+}