@beignet/next 0.0.50 → 0.0.52

package/dist/index.js

@@ -241,31 +241,51 @@ async function storageResponse(storage, req, basePath, options, includeBody) {
     if (!key)
         return storageNotFoundResponse();
     const object = await storage.get(key);
-    if (object?.visibility !== "public") {
+    if (!object) {
         return storageNotFoundResponse();
     }
-    const headers = new Headers(resolveHeaders(options.headers, req));
-    headers.set("content-length", String(object.size));
-    headers.set("last-modified", object.lastModified.toUTCString());
-    if (!headers.has("x-content-type-options")) {
-        headers.set("x-content-type-options", "nosniff");
-    }
-    if (object.contentType && !headers.has("content-type")) {
-        headers.set("content-type", object.contentType);
+    if (object.visibility !== "public") {
+        await object.cancel().catch(() => undefined);
+        return storageNotFoundResponse();
     }
-    if (!headers.has("content-disposition")) {
-        const contentDisposition = resolveStorageContentDisposition(options, req, object);
-        if (contentDisposition) {
-            headers.set("content-disposition", contentDisposition);
+    try {
+        const headers = new Headers(resolveHeaders(options.headers, req));
+        headers.set("content-length", String(object.size));
+        headers.set("last-modified", object.lastModified.toUTCString());
+        if (!headers.has("x-content-type-options")) {
+            headers.set("x-content-type-options", "nosniff");
+        }
+        if (object.contentType && !headers.has("content-type")) {
+            headers.set("content-type", object.contentType);
+        }
+        if (!headers.has("content-disposition")) {
+            const contentDisposition = resolveStorageContentDisposition(options, req, object);
+            if (contentDisposition) {
+                headers.set("content-disposition", contentDisposition);
+            }
+        }
+        if (object.cacheControl && !headers.has("cache-control")) {
+            headers.set("cache-control", object.cacheControl);
+        }
+        if (!includeBody) {
+            await object.cancel();
+            return new Response(null, { status: 200, headers });
+        }
+        const body = object.stream();
+        try {
+            return new Response(body, { status: 200, headers });
+        }
+        catch (error) {
+            await body.cancel(error).catch(() => undefined);
+            throw error;
         }
     }
-    if (object.cacheControl && !headers.has("cache-control")) {
-        headers.set("cache-control", object.cacheControl);
+    catch (error) {
+        if (!object.bodyUsed) {
+            await object.cancel(error).catch(() => undefined);
+        }
+        throw error;
     }
-    return new Response(includeBody ? object.stream() : null, {
-        status: 200,
-        headers,
-    });
 }
 function currentRequestServer(req) {
     const url = new URL(req.url);
@@ -466,12 +486,84 @@ function toHttpResponseHeaders(headers) {
  * creation then receives a rehydrated request carrying the same method, URL,
  * headers, and raw body.
  */
-function toContextRequest(req, rawBody) {
-    return toRequestLike(new Request(req.url, {
+function rehydrateWebhookRequest(req, rawBody) {
+    return new Request(req.url, {
         method: req.method,
         headers: req.headers,
         body: rawBody,
-    }));
+        signal: req.signal,
+    });
+}
+const DEFAULT_WEBHOOK_BODY_MAX_BYTES = 1024 * 1024;
+class WebhookBodyTooLargeError extends Error {
+    maxBytes;
+    constructor(maxBytes) {
+        super("Webhook body exceeds the configured size limit.");
+        this.maxBytes = maxBytes;
+        this.name = "WebhookBodyTooLargeError";
+    }
+}
+function webhookBodyLimit(maxBytes) {
+    const resolved = maxBytes ?? DEFAULT_WEBHOOK_BODY_MAX_BYTES;
+    if (!Number.isFinite(resolved) || resolved <= 0) {
+        throw new Error("Webhook maxBodyBytes must be a positive number.");
+    }
+    return resolved;
+}
+function cancelWebhookBody(source, reason) {
+    try {
+        void source.cancel(reason).catch(() => { });
+    }
+    catch {
+        // Cancellation is best-effort and must not replace the selected response.
+    }
+}
+function cancelWebhookRequestBody(req, reason) {
+    const body = req.raw?.body ?? nativeRequestOf(req).body;
+    if (body)
+        cancelWebhookBody(body, reason);
+}
+async function readWebhookBody(req, maxBytes) {
+    const body = req.raw?.body ?? nativeRequestOf(req).body;
+    const contentLength = req.headers.get("content-length");
+    if (contentLength !== null) {
+        const declaredBytes = Number(contentLength);
+        if (Number.isFinite(declaredBytes) && declaredBytes > maxBytes) {
+            const error = new WebhookBodyTooLargeError(maxBytes);
+            if (body)
+                cancelWebhookBody(body, error);
+            throw error;
+        }
+    }
+    if (!body) {
+        const text = await req.text();
+        if (new TextEncoder().encode(text).byteLength > maxBytes) {
+            throw new WebhookBodyTooLargeError(maxBytes);
+        }
+        return text;
+    }
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    let receivedBytes = 0;
+    let text = "";
+    try {
+        while (true) {
+            const result = await reader.read();
+            if (result.done)
+                break;
+            receivedBytes += result.value.byteLength;
+            if (receivedBytes > maxBytes) {
+                const error = new WebhookBodyTooLargeError(maxBytes);
+                cancelWebhookBody(reader, error);
+                throw error;
+            }
+            text += decoder.decode(result.value, { stream: true });
+        }
+        return text + decoder.decode();
+    }
+    finally {
+        reader.releaseLock();
+    }
 }
 function headersToRecord(headers) {
     const result = {};
@@ -539,9 +631,15 @@ async function runOutboxDrainWithContext(ctx, registry, options, mechanism) {
         eventBus: ctx.ports.eventBus,
         jobs: ctx.ports.jobs,
         batchSize: options.batchSize,
+        concurrency: options.concurrency,
         leaseMs: options.leaseMs,
+        heartbeatMs: options.heartbeatMs,
+        maxActiveMs: options.maxActiveMs,
         retryDelayMs: options.retryDelayMs,
-        instrumentation: resolveProviderInstrumentationPort(ctx.ports),
+        instrumentation: {
+            instrumentation: resolveProviderInstrumentationPort(ctx.ports),
+            tracing: ctx.ports.tracing,
+        },
         instrumentationContext: {
             requestId: ctx.requestId,
             traceId: ctx.traceId,
@@ -584,10 +682,47 @@ async function runOutboxDrainWithContext(ctx, registry, options, mechanism) {
                 },
             });
         },
-        async onSettlementError(settlementError, message) {
+        async onLeaseError(failure) {
+            const outcome = failure.state === "lost"
+                ? "leaseLost"
+                : failure.state === "recovered"
+                    ? "leaseRecovered"
+                    : "leaseDegraded";
+            await tryReportException({
+                reporter: ctx.ports.errorReporter,
+                error: failure.error,
+                reportOptions: {
+                    level: failure.state === "lost" ? "error" : "warning",
+                    mechanism,
+                    handled: failure.state !== "lost",
+                    requestId: ctx.requestId,
+                    traceId: ctx.traceId,
+                    tags: {
+                        "beignet.kind": "outbox",
+                        "beignet.outbox.kind": failure.message.kind,
+                        "beignet.outbox.name": failure.message.name,
+                        "beignet.outbox.outcome": outcome,
+                    },
+                    contexts: {
+                        outbox: {
+                            messageId: failure.message.id,
+                            kind: failure.message.kind,
+                            name: failure.message.name,
+                            attempts: failure.message.attempts,
+                            maxAttempts: failure.message.maxAttempts,
+                            operation: failure.operation,
+                            state: failure.state,
+                            confirmedLost: failure.confirmedLost,
+                            outcome,
+                        },
+                    },
+                },
+            });
+        },
+        async onSettlementError(failure) {
             await tryReportException({
                 reporter: ctx.ports.errorReporter,
-                error: settlementError,
+                error: failure.error,
                 reportOptions: {
                     level: "error",
                     mechanism,
@@ -596,17 +731,19 @@ async function runOutboxDrainWithContext(ctx, registry, options, mechanism) {
                     traceId: ctx.traceId,
                     tags: {
                         "beignet.kind": "outbox",
-                        "beignet.outbox.kind": message.kind,
-                        "beignet.outbox.name": message.name,
+                        "beignet.outbox.kind": failure.message.kind,
+                        "beignet.outbox.name": failure.message.name,
                         "beignet.outbox.outcome": "settlementFailed",
                     },
                     contexts: {
                         outbox: {
-                            messageId: message.id,
-                            kind: message.kind,
-                            name: message.name,
-                            attempts: message.attempts,
-                            maxAttempts: message.maxAttempts,
+                            messageId: failure.message.id,
+                            kind: failure.message.kind,
+                            name: failure.message.name,
+                            attempts: failure.message.attempts,
+                            maxAttempts: failure.message.maxAttempts,
+                            operation: failure.operation,
+                            deliverySucceeded: failure.deliverySucceeded,
                             outcome: "settlementFailed",
                         },
                     },
@@ -620,7 +757,7 @@ async function runOutboxDrainWithContext(ctx, registry, options, mechanism) {
             watcher: "outbox",
             name: "outbox.drain",
             label: "Outbox drain",
-            summary: `${result.delivered} delivered, ${result.retried} retried, ${result.deadLettered} dead-lettered`,
+            summary: `${result.delivered} delivered, ${result.retried} retried, ${result.deadLettered} dead-lettered, ${result.settlementFailed} settlement-uncertain, ${result.leaseLost} lease-lost`,
             requestId: ctx.requestId,
             traceId: ctx.traceId,
             details: result,
@@ -633,6 +770,12 @@ async function runOutboxDrainWithContext(ctx, registry, options, mechanism) {
     }
     return result;
 }
+function hasUncertainOutboxResult(result) {
+    return result.settlementFailed > 0 || result.leaseLost > 0;
+}
+function uncertainOutboxError(result) {
+    return new Error(`Outbox drain completed with ${result.settlementFailed} settlement failure(s) and ${result.leaseLost} lost lease(s).`);
+}
 async function resolveOutboxRegistry(source) {
     return typeof source === "function" ? source() : source;
 }
@@ -704,7 +847,11 @@ export function createNextOutboxDrainTrigger(options) {
                 try {
                     ctx = await options.createContext();
                     const registry = await resolveOutboxRegistry(options.registry);
-                    await runOutboxDrainWithContext(ctx, registry, options, "beignet.outbox.next.after");
+                    const result = await runOutboxDrainWithContext(ctx, registry, options, "beignet.outbox.next.after");
+                    if (hasUncertainOutboxResult(result)) {
+                        const error = uncertainOutboxError(result);
+                        await notifyDeferredWorkError(options.onError, error);
+                    }
                 }
                 catch (error) {
                     if (ctx) {
@@ -747,6 +894,16 @@ export function createOutboxDrainRoute(options) {
         const headers = resolveHeaders(options.headers, nativeReq);
         try {
             const result = await runOutboxDrainWithContext(ctx, options.registry, options, "beignet.outbox.next");
+            if (hasUncertainOutboxResult(result)) {
+                return routeJson({
+                    ok: false,
+                    error: {
+                        code: "OUTBOX_DRAIN_UNCERTAIN",
+                        message: "Outbox drain completed with unconfirmed delivery state.",
+                    },
+                    result,
+                }, 500, headers);
+            }
             return routeJson({
                 ok: true,
                 result,
@@ -798,23 +955,31 @@ export function createOutboxDrainRoute(options) {
 /**
  * Create a Next.js POST handler for generic verified inbound webhooks.
  *
- * The route reads the raw request body as text, normalizes request headers,
- * builds app context from the real request through
+ * The route bounds and reads the raw request body before resolving the server,
+ * then normalizes request headers and builds app context from a rehydrated
+ * request through
  * `server.createRequestContext(...)`, verifies the event through the webhook
  * definition or a context-aware verifier, validates the matching event
  * payload schema, and delegates fulfillment to app code.
  */
 export function createWebhookRoute(options) {
-    const handleWebhookRequest = async ({ req, ctx, }) => {
+    const maxBodyBytes = webhookBodyLimit(options.maxBodyBytes);
+    const preflightBodies = new WeakMap();
+    const handleWebhookRequest = async ({ req, ctx, rawBody: providedRawBody, }) => {
         const nativeReq = nativeRequestOf(req);
         const headers = resolveHeaders(options.headers, nativeReq);
         const requestHeaders = headersToRecord(new Headers(req.headers));
-        let rawBody;
-        try {
-            rawBody = await req.text();
-        }
-        catch {
-            return operationalErrorJson("WEBHOOK_BODY_READ_FAILED", "Webhook body read failed.", 400, headers);
+        let rawBody = providedRawBody ?? preflightBodies.get(nativeReq);
+        preflightBodies.delete(nativeReq);
+        if (rawBody === undefined) {
+            try {
+                rawBody = await readWebhookBody(req, maxBodyBytes);
+            }
+            catch (error) {
+                return error instanceof WebhookBodyTooLargeError
+                    ? operationalErrorJson("WEBHOOK_BODY_TOO_LARGE", "Webhook body exceeds the configured size limit.", 413, headers)
+                    : operationalErrorJson("WEBHOOK_BODY_READ_FAILED", "Webhook body read failed.", 400, headers);
+            }
         }
         let event;
         try {
@@ -900,37 +1065,47 @@ export function createWebhookRoute(options) {
     }, handleWebhookRequest);
     return {
         POST: async (req) => {
-            const server = await resolveServerSource(options.server);
-            const pipelined = runPipeline(server);
-            if (pipelined)
-                return pipelined(req);
-            // Minimal servers without rawRoute(...) — usually test fakes — build
-            // context directly and run the same handler outside the hooks pipeline.
             const headers = resolveHeaders(options.headers, req);
             let rawBody;
             try {
-                rawBody = await req.text();
+                rawBody = await readWebhookBody(toRequestLike(req), maxBodyBytes);
             }
-            catch {
-                return operationalErrorJson("WEBHOOK_BODY_READ_FAILED", "Webhook body read failed.", 400, headers);
+            catch (error) {
+                return error instanceof WebhookBodyTooLargeError
+                    ? operationalErrorJson("WEBHOOK_BODY_TOO_LARGE", "Webhook body exceeds the configured size limit.", 413, headers)
+                    : operationalErrorJson("WEBHOOK_BODY_READ_FAILED", "Webhook body read failed.", 400, headers);
+            }
+            const contextRequest = rehydrateWebhookRequest(req, rawBody);
+            const server = await resolveServerSource(options.server);
+            const pipelined = runPipeline(server);
+            if (pipelined) {
+                preflightBodies.set(contextRequest, rawBody);
+                return pipelined(contextRequest);
             }
-            const contextRequest = toContextRequest(req, rawBody);
+            // Minimal servers without rawRoute(...) — usually test fakes — build
+            // context directly and run the same handler outside the hooks pipeline.
+            const requestLike = toRequestLike(contextRequest);
             let ctx;
             try {
-                ctx = await server.createRequestContext(contextRequest);
+                ctx = await server.createRequestContext(requestLike);
             }
             catch {
                 return operationalErrorJson("WEBHOOK_CONTEXT_FAILED", "Webhook context failed.", 500, headers);
             }
-            return handleWebhookRequest({ req: toContextRequest(req, rawBody), ctx });
+            return handleWebhookRequest({
+                req: requestLike,
+                ctx,
+                rawBody,
+            });
         },
     };
 }
 /**
  * Create a Next.js POST handler for provider-verified payment webhooks.
  *
- * The route extracts the provider signature header, reads the raw request
- * body as text, builds app context from the real request through
+ * The route checks the provider signature header and bounds the raw request
+ * body before resolving the server, then builds app context from a rehydrated
+ * request through
  * `server.createRequestContext(...)`, verifies the event through
  * `ctx.ports.payments`, and then delegates fulfillment to app code. This is the canonical helper for Beignet
  * billing flows backed by `PaymentsPort`. Keep this route on the Node.js
@@ -938,19 +1113,27 @@ export function createWebhookRoute(options) {
  */
 export function createPaymentWebhookRoute(options) {
     const signatureHeader = options.signatureHeader ?? "stripe-signature";
-    const handlePaymentWebhook = async ({ req, ctx, }) => {
+    const maxBodyBytes = webhookBodyLimit(options.maxBodyBytes);
+    const preflightBodies = new WeakMap();
+    const handlePaymentWebhook = async ({ req, ctx, rawBody: providedRawBody, }) => {
         const nativeReq = nativeRequestOf(req);
         const headers = resolveHeaders(options.headers, nativeReq);
         const signature = new Headers(req.headers).get(signatureHeader);
         if (!signature) {
+            cancelWebhookRequestBody(req, new Error(`Missing ${signatureHeader} header.`));
             return operationalErrorJson("PAYMENT_WEBHOOK_SIGNATURE_MISSING", `Missing ${signatureHeader} header.`, 400, headers);
         }
-        let rawBody;
-        try {
-            rawBody = await req.text();
-        }
-        catch {
-            return operationalErrorJson("PAYMENT_WEBHOOK_BODY_READ_FAILED", "Payment webhook body read failed.", 400, headers);
+        let rawBody = providedRawBody ?? preflightBodies.get(nativeReq);
+        preflightBodies.delete(nativeReq);
+        if (rawBody === undefined) {
+            try {
+                rawBody = await readWebhookBody(req, maxBodyBytes);
+            }
+            catch (error) {
+                return error instanceof WebhookBodyTooLargeError
+                    ? operationalErrorJson("PAYMENT_WEBHOOK_BODY_TOO_LARGE", "Payment webhook body exceeds the configured size limit.", 413, headers)
+                    : operationalErrorJson("PAYMENT_WEBHOOK_BODY_READ_FAILED", "Payment webhook body read failed.", 400, headers);
+            }
         }
         let event;
         try {
@@ -1013,32 +1196,44 @@ export function createPaymentWebhookRoute(options) {
     }, handlePaymentWebhook);
     return {
         POST: async (req) => {
-            const server = await resolveServerSource(options.server);
-            const pipelined = runPipeline(server);
-            if (pipelined)
-                return pipelined(req);
-            // Minimal servers without rawRoute(...) — usually test fakes — build
-            // context directly and run the same handler outside the hooks pipeline.
-            // The signature gate runs first so no context is created without one.
             const headers = resolveHeaders(options.headers, req);
             if (!req.headers.get(signatureHeader)) {
+                if (req.body) {
+                    cancelWebhookBody(req.body, new Error(`Missing ${signatureHeader} header.`));
+                }
                 return operationalErrorJson("PAYMENT_WEBHOOK_SIGNATURE_MISSING", `Missing ${signatureHeader} header.`, 400, headers);
             }
             let rawBody;
             try {
-                rawBody = await req.text();
+                rawBody = await readWebhookBody(toRequestLike(req), maxBodyBytes);
             }
-            catch {
-                return operationalErrorJson("PAYMENT_WEBHOOK_BODY_READ_FAILED", "Payment webhook body read failed.", 400, headers);
+            catch (error) {
+                return error instanceof WebhookBodyTooLargeError
+                    ? operationalErrorJson("PAYMENT_WEBHOOK_BODY_TOO_LARGE", "Payment webhook body exceeds the configured size limit.", 413, headers)
+                    : operationalErrorJson("PAYMENT_WEBHOOK_BODY_READ_FAILED", "Payment webhook body read failed.", 400, headers);
             }
+            const contextRequest = rehydrateWebhookRequest(req, rawBody);
+            const server = await resolveServerSource(options.server);
+            const pipelined = runPipeline(server);
+            if (pipelined) {
+                preflightBodies.set(contextRequest, rawBody);
+                return pipelined(contextRequest);
+            }
+            // Minimal servers without rawRoute(...) — usually test fakes — build
+            // context directly and run the same handler outside the hooks pipeline.
+            const requestLike = toRequestLike(contextRequest);
             let ctx;
             try {
-                ctx = await server.createRequestContext(toContextRequest(req, rawBody));
+                ctx = await server.createRequestContext(requestLike);
             }
             catch {
                 return operationalErrorJson("PAYMENT_WEBHOOK_CONTEXT_FAILED", "Payment webhook context failed.", 500, headers);
             }
-            return handlePaymentWebhook({ req: toContextRequest(req, rawBody), ctx });
+            return handlePaymentWebhook({
+                req: requestLike,
+                ctx,
+                rawBody,
+            });
         },
     };
 }