@beignet/next 0.0.27 → 0.0.29

package/dist/index.js

@@ -19,6 +19,42 @@ function isServerLoader(source) {
 async function resolveServerSource(source) {
     return isServerLoader(source) ? source() : source;
 }
+function rawRoutePipeline(server) {
+    const candidate = server.rawRoute;
+    return typeof candidate === "function"
+        ? candidate.bind(server)
+        : undefined;
+}
+/**
+ * Per-route-factory memo for the pipeline-built handler. The handler is
+ * rebuilt only when the resolved server instance changes (fresh server per
+ * test, hot reload), never per request.
+ */
+function createRawPipelineRunner(init, fn) {
+    let cached;
+    return (server) => {
+        const pipeline = rawRoutePipeline(server);
+        if (!pipeline)
+            return undefined;
+        if (!cached || cached.server !== server) {
+            const built = pipeline(init).handle(fn);
+            cached = {
+                server,
+                handler: async (req) => toWebResponse((await built(req))),
+            };
+        }
+        return cached.handler;
+    };
+}
+/**
+ * Resolve the native `Request` behind a pipeline request. Requests routed
+ * through `createFetchHandler` carry it as `raw`; requests passed straight
+ * into a core handler are the native request itself.
+ */
+function nativeRequestOf(req) {
+    const raw = req.raw;
+    return (raw instanceof Request ? raw : req);
+}
 /**
  * Create a memoized Next server loader for route modules.
  *
@@ -478,8 +514,9 @@ async function isAuthorizedCronRequest(req, secret) {
  * lifecycle hooks in serverless apps.
  */
 export function createOutboxDrainRoute(options) {
-    const drainPendingOutbox = async (req) => {
-        const headers = resolveHeaders(options.headers, req);
+    const drainWithContext = async ({ req, ctx, }) => {
+        const nativeReq = nativeRequestOf(req);
+        const headers = resolveHeaders(options.headers, nativeReq);
         const secret = options.secret;
         if (!secret) {
             return cronRouteJson({
@@ -487,13 +524,10 @@ export function createOutboxDrainRoute(options) {
                 error: "CRON_SECRET is not configured.",
             }, 500, headers);
         }
-        if (!(await isAuthorizedCronRequest(req, secret))) {
+        if (!(await isAuthorizedCronRequest(nativeReq, secret))) {
             return cronRouteJson({ ok: false, error: "Unauthorized" }, 401, headers);
         }
-        let ctx;
         try {
-            const server = await resolveServerSource(options.server);
-            ctx = await server.createRequestContext(toRequestLike(req));
             const drainCtx = ctx;
             const result = await drainOutbox({
                 outbox: drainCtx.ports.outbox,
@@ -541,13 +575,54 @@ export function createOutboxDrainRoute(options) {
             }, 200, headers);
         }
         catch (error) {
-            ctx?.ports.logger?.error("Outbox drain failed", { error });
+            ctx.ports.logger?.error("Outbox drain failed", { error });
             return cronRouteJson({
                 ok: false,
                 error: "Outbox drain failed.",
             }, 500, headers);
         }
     };
+    const pipelineInit = {
+        name: options.pipeline?.name ?? "outbox.drain",
+        path: options.pipeline?.path ?? "/outbox/drain",
+        metadata: options.pipeline?.metadata,
+    };
+    const pipelineRunners = {
+        GET: createRawPipelineRunner({ ...pipelineInit, method: "GET" }, drainWithContext),
+        POST: createRawPipelineRunner({ ...pipelineInit, method: "POST" }, drainWithContext),
+    };
+    const drainPendingOutbox = async (req) => {
+        const server = await resolveServerSource(options.server);
+        const runner = pipelineRunners[req.method.toUpperCase() === "GET" ? "GET" : "POST"];
+        const pipelined = runner(server);
+        if (pipelined)
+            return pipelined(req);
+        // Minimal servers without rawRoute(...) — usually test fakes — keep the
+        // original flow: authorize before touching context, then drain inline.
+        const headers = resolveHeaders(options.headers, req);
+        const secret = options.secret;
+        if (!secret) {
+            return cronRouteJson({
+                ok: false,
+                error: "CRON_SECRET is not configured.",
+            }, 500, headers);
+        }
+        if (!(await isAuthorizedCronRequest(req, secret))) {
+            return cronRouteJson({ ok: false, error: "Unauthorized" }, 401, headers);
+        }
+        let ctx;
+        try {
+            ctx = await server.createRequestContext(toRequestLike(req));
+        }
+        catch (error) {
+            console.error("Outbox drain context failed", { error });
+            return cronRouteJson({
+                ok: false,
+                error: "Outbox drain failed.",
+            }, 500, headers);
+        }
+        return drainWithContext({ req: toRequestLike(req), ctx });
+    };
     return {
         GET: drainPendingOutbox,
         POST: drainPendingOutbox,
@@ -563,10 +638,117 @@ export function createOutboxDrainRoute(options) {
  * payload schema, and delegates fulfillment to app code.
  */
 export function createWebhookRoute(options) {
+    const handleWebhookRequest = async ({ req, ctx, }) => {
+        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 webhookRouteJson({
+                ok: false,
+                error: "Webhook body read failed.",
+            }, 400, headers);
+        }
+        let event;
+        try {
+            const input = {
+                rawBody,
+                headers: requestHeaders,
+                receivedAt: new Date(),
+            };
+            const routeVerifier = options.verify;
+            const verifier = routeVerifier
+                ? {
+                    async verify() {
+                        return routeVerifier({
+                            req: nativeReq,
+                            ctx,
+                            rawBody,
+                            headers: requestHeaders,
+                            input,
+                        });
+                    },
+                }
+                : undefined;
+            event = (await verifyWebhook(options.webhook, input, {
+                verifier,
+                allowUnknownEvents: options.allowUnknownEvents,
+            }));
+        }
+        catch (error) {
+            ctx.ports.logger?.error("Webhook verification failed", {
+                error,
+                webhookName: options.webhook.name,
+                provider: options.webhook.provider,
+                requestId: ctx.requestId,
+                traceId: ctx.traceId,
+            });
+            return webhookRouteJson({
+                ok: false,
+                error: "Webhook verification failed.",
+            }, 400, headers);
+        }
+        try {
+            const result = await options.handle?.({
+                req: nativeReq,
+                ctx,
+                rawBody,
+                event,
+            });
+            if (result instanceof Response)
+                return result;
+            if (result) {
+                return toWebResponse({
+                    status: result.status ?? 200,
+                    headers: toHttpResponseHeaders(result.headers ?? headers),
+                    body: result.body,
+                });
+            }
+            return toWebResponse({
+                status: 200,
+                headers: toHttpResponseHeaders(headers),
+                body: {
+                    ok: true,
+                    webhookName: options.webhook.name,
+                    eventId: event.id,
+                    eventType: event.type,
+                },
+            });
+        }
+        catch (error) {
+            ctx.ports.logger?.error("Webhook handler failed", {
+                error,
+                webhookName: options.webhook.name,
+                provider: options.webhook.provider,
+                requestId: ctx.requestId,
+                traceId: ctx.traceId,
+                eventId: event.id,
+                eventType: event.type,
+            });
+            return webhookRouteJson({
+                ok: false,
+                error: "Webhook handler failed.",
+            }, 500, headers);
+        }
+    };
+    const runPipeline = createRawPipelineRunner({
+        name: options.pipeline?.name ?? `webhook.${options.webhook.name}`,
+        method: "POST",
+        path: options.pipeline?.path ?? `/webhooks/${options.webhook.name}`,
+        metadata: options.pipeline?.metadata,
+    }, 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);
-            const requestHeaders = headersToRecord(req.headers);
             let rawBody;
             try {
                 rawBody = await req.text();
@@ -577,10 +759,10 @@ export function createWebhookRoute(options) {
                     error: "Webhook body read failed.",
                 }, 400, headers);
             }
+            const contextRequest = toContextRequest(req, rawBody);
             let ctx;
             try {
-                const server = await resolveServerSource(options.server);
-                ctx = await server.createRequestContext(toContextRequest(req, rawBody));
+                ctx = await server.createRequestContext(contextRequest);
             }
             catch {
                 return webhookRouteJson({
@@ -588,87 +770,7 @@ export function createWebhookRoute(options) {
                     error: "Webhook context failed.",
                 }, 500, headers);
             }
-            let event;
-            try {
-                const input = {
-                    rawBody,
-                    headers: requestHeaders,
-                    receivedAt: new Date(),
-                };
-                const routeVerifier = options.verify;
-                const verifier = routeVerifier
-                    ? {
-                        async verify() {
-                            return routeVerifier({
-                                req,
-                                ctx,
-                                rawBody,
-                                headers: requestHeaders,
-                                input,
-                            });
-                        },
-                    }
-                    : undefined;
-                event = (await verifyWebhook(options.webhook, input, {
-                    verifier,
-                    allowUnknownEvents: options.allowUnknownEvents,
-                }));
-            }
-            catch (error) {
-                ctx.ports.logger?.error("Webhook verification failed", {
-                    error,
-                    webhookName: options.webhook.name,
-                    provider: options.webhook.provider,
-                    requestId: ctx.requestId,
-                    traceId: ctx.traceId,
-                });
-                return webhookRouteJson({
-                    ok: false,
-                    error: "Webhook verification failed.",
-                }, 400, headers);
-            }
-            try {
-                const result = await options.handle?.({
-                    req,
-                    ctx,
-                    rawBody,
-                    event,
-                });
-                if (result instanceof Response)
-                    return result;
-                if (result) {
-                    return toWebResponse({
-                        status: result.status ?? 200,
-                        headers: toHttpResponseHeaders(result.headers ?? headers),
-                        body: result.body,
-                    });
-                }
-                return toWebResponse({
-                    status: 200,
-                    headers: toHttpResponseHeaders(headers),
-                    body: {
-                        ok: true,
-                        webhookName: options.webhook.name,
-                        eventId: event.id,
-                        eventType: event.type,
-                    },
-                });
-            }
-            catch (error) {
-                ctx.ports.logger?.error("Webhook handler failed", {
-                    error,
-                    webhookName: options.webhook.name,
-                    provider: options.webhook.provider,
-                    requestId: ctx.requestId,
-                    traceId: ctx.traceId,
-                    eventId: event.id,
-                    eventType: event.type,
-                });
-                return webhookRouteJson({
-                    ok: false,
-                    error: "Webhook handler failed.",
-                }, 500, headers);
-            }
+            return handleWebhookRequest({ req: toContextRequest(req, rawBody), ctx });
         },
     };
 }
@@ -684,11 +786,102 @@ export function createWebhookRoute(options) {
  */
 export function createPaymentWebhookRoute(options) {
     const signatureHeader = options.signatureHeader ?? "stripe-signature";
+    const handlePaymentWebhook = async ({ req, ctx, }) => {
+        const nativeReq = nativeRequestOf(req);
+        const headers = resolveHeaders(options.headers, nativeReq);
+        const signature = new Headers(req.headers).get(signatureHeader);
+        if (!signature) {
+            return paymentWebhookJson({
+                ok: false,
+                error: `Missing ${signatureHeader} header.`,
+            }, 400, headers);
+        }
+        let rawBody;
+        try {
+            rawBody = await req.text();
+        }
+        catch {
+            return paymentWebhookJson({
+                ok: false,
+                error: "Payment webhook body read failed.",
+            }, 400, headers);
+        }
+        let event;
+        try {
+            event = await ctx.ports.payments.verifyWebhook({
+                rawBody,
+                signature,
+            });
+        }
+        catch (error) {
+            ctx.ports.logger?.error("Payment webhook verification failed", {
+                error,
+                requestId: ctx.requestId,
+                traceId: ctx.traceId,
+            });
+            return paymentWebhookJson({
+                ok: false,
+                error: "Payment webhook verification failed.",
+            }, 400, headers);
+        }
+        try {
+            const result = await options.handle?.({
+                req: nativeReq,
+                ctx,
+                rawBody,
+                signature,
+                event,
+            });
+            if (result instanceof Response)
+                return result;
+            if (result) {
+                return toWebResponse({
+                    status: result.status ?? 200,
+                    headers: toHttpResponseHeaders(result.headers ?? headers),
+                    body: result.body,
+                });
+            }
+            return toWebResponse({
+                status: 200,
+                headers: toHttpResponseHeaders(headers),
+                body: {
+                    ok: true,
+                    eventId: event.id,
+                    eventType: event.type,
+                },
+            });
+        }
+        catch (error) {
+            ctx.ports.logger?.error("Payment webhook handler failed", {
+                error,
+                requestId: ctx.requestId,
+                traceId: ctx.traceId,
+                eventId: event.id,
+                eventType: event.type,
+            });
+            return paymentWebhookJson({
+                ok: false,
+                error: "Payment webhook handler failed.",
+            }, 500, headers);
+        }
+    };
+    const runPipeline = createRawPipelineRunner({
+        name: options.pipeline?.name ?? "webhook.payments",
+        method: "POST",
+        path: options.pipeline?.path ?? "/webhooks/payments",
+        metadata: options.pipeline?.metadata,
+    }, 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);
-            const signature = req.headers.get(signatureHeader);
-            if (!signature) {
+            if (!req.headers.get(signatureHeader)) {
                 return paymentWebhookJson({
                     ok: false,
                     error: `Missing ${signatureHeader} header.`,
@@ -706,7 +899,6 @@ export function createPaymentWebhookRoute(options) {
             }
             let ctx;
             try {
-                const server = await resolveServerSource(options.server);
                 ctx = await server.createRequestContext(toContextRequest(req, rawBody));
             }
             catch {
@@ -715,64 +907,7 @@ export function createPaymentWebhookRoute(options) {
                     error: "Payment webhook context failed.",
                 }, 500, headers);
             }
-            let event;
-            try {
-                event = await ctx.ports.payments.verifyWebhook({
-                    rawBody,
-                    signature,
-                });
-            }
-            catch (error) {
-                ctx.ports.logger?.error("Payment webhook verification failed", {
-                    error,
-                    requestId: ctx.requestId,
-                    traceId: ctx.traceId,
-                });
-                return paymentWebhookJson({
-                    ok: false,
-                    error: "Payment webhook verification failed.",
-                }, 400, headers);
-            }
-            try {
-                const result = await options.handle?.({
-                    req,
-                    ctx,
-                    rawBody,
-                    signature,
-                    event,
-                });
-                if (result instanceof Response)
-                    return result;
-                if (result) {
-                    return toWebResponse({
-                        status: result.status ?? 200,
-                        headers: toHttpResponseHeaders(result.headers ?? headers),
-                        body: result.body,
-                    });
-                }
-                return toWebResponse({
-                    status: 200,
-                    headers: toHttpResponseHeaders(headers),
-                    body: {
-                        ok: true,
-                        eventId: event.id,
-                        eventType: event.type,
-                    },
-                });
-            }
-            catch (error) {
-                ctx.ports.logger?.error("Payment webhook handler failed", {
-                    error,
-                    requestId: ctx.requestId,
-                    traceId: ctx.traceId,
-                    eventId: event.id,
-                    eventType: event.type,
-                });
-                return paymentWebhookJson({
-                    ok: false,
-                    error: "Payment webhook handler failed.",
-                }, 500, headers);
-            }
+            return handlePaymentWebhook({ req: toContextRequest(req, rawBody), ctx });
         },
     };
 }
@@ -796,8 +931,9 @@ export function createScheduleRoute(options) {
             ? `Unknown schedule "${options.schedule}". Available schedules: ${available.join(", ")}.`
             : `Unknown schedule "${options.schedule}". No schedules were passed to createScheduleRoute(...).`);
     }
-    const runScheduleFromRequest = async (req) => {
-        const headers = resolveHeaders(options.headers, req);
+    const runSchedule = async ({ req, ctx, }) => {
+        const nativeReq = nativeRequestOf(req);
+        const headers = resolveHeaders(options.headers, nativeReq);
         const secret = options.secret;
         if (!secret) {
             return cronRouteJson({
@@ -806,12 +942,10 @@ export function createScheduleRoute(options) {
                 scheduleName: schedule.name,
             }, 500, headers);
         }
-        if (!(await isAuthorizedCronRequest(req, secret))) {
+        if (!(await isAuthorizedCronRequest(nativeReq, secret))) {
             return cronRouteJson({ ok: false, error: "Unauthorized" }, 401, headers);
         }
         try {
-            const server = await resolveServerSource(options.server);
-            const ctx = await server.createRequestContext(toRequestLike(req));
             const runner = createInlineScheduleRunner({
                 ctx,
                 instrumentation: resolveProviderInstrumentationPort(ctx.ports),
@@ -842,6 +976,48 @@ export function createScheduleRoute(options) {
             }, 500, headers);
         }
     };
+    const pipelineInit = {
+        name: options.pipeline?.name ?? `schedule.${schedule.name}`,
+        path: options.pipeline?.path ?? `/schedules/${schedule.name}`,
+        metadata: options.pipeline?.metadata,
+    };
+    const pipelineRunners = {
+        GET: createRawPipelineRunner({ ...pipelineInit, method: "GET" }, runSchedule),
+        POST: createRawPipelineRunner({ ...pipelineInit, method: "POST" }, runSchedule),
+    };
+    const runScheduleFromRequest = async (req) => {
+        const server = await resolveServerSource(options.server);
+        const runner = pipelineRunners[req.method.toUpperCase() === "GET" ? "GET" : "POST"];
+        const pipelined = runner(server);
+        if (pipelined)
+            return pipelined(req);
+        // Minimal servers without rawRoute(...) — usually test fakes — keep the
+        // original flow: authorize before touching context, then run inline.
+        const headers = resolveHeaders(options.headers, req);
+        const secret = options.secret;
+        if (!secret) {
+            return cronRouteJson({
+                ok: false,
+                error: "CRON_SECRET is not configured.",
+                scheduleName: schedule.name,
+            }, 500, headers);
+        }
+        if (!(await isAuthorizedCronRequest(req, secret))) {
+            return cronRouteJson({ ok: false, error: "Unauthorized" }, 401, headers);
+        }
+        let ctx;
+        try {
+            ctx = await server.createRequestContext(toRequestLike(req));
+        }
+        catch {
+            return cronRouteJson({
+                ok: false,
+                error: "Schedule failed.",
+                scheduleName: schedule.name,
+            }, 500, headers);
+        }
+        return runSchedule({ req: toRequestLike(req), ctx });
+    };
     return {
         GET: runScheduleFromRequest,
         POST: runScheduleFromRequest,
@@ -861,6 +1037,9 @@ export async function createNextServer(options) {
         route: (contract) => ({
             handle: (fn) => createFetchHandler(runtime.route(contract).handle(fn)),
         }),
+        rawRoute: (init) => ({
+            handle: (fn) => createFetchHandler(runtime.rawRoute(init).handle(fn)),
+        }),
         createContextFromNext: async () => {
             // "next" ships no package exports map, so Node-style ESM resolution
             // (NodeNext) needs the explicit .js subpath. Bundlers resolve it the same.