@opennextjs/aws 3.2.2 → 3.3.1

package/dist/build/validateConfig.js

@@ -8,6 +8,8 @@ const compatibilityMatrix = {
     ],
     "aws-lambda-streaming": ["aws-apigw-v2"],
     cloudflare: ["edge"],
+    "cloudflare-edge": ["edge"],
+    "cloudflare-node": ["edge"],
     node: ["node"],
     dummy: [],
 };
@@ -63,7 +65,7 @@ export function validateConfig(config) {
         logger.warn("You've disabled incremental cache. This means that ISR and SSG will not work.");
     }
     if (config.dangerous?.disableTagCache) {
-        logger.warn(`You've disabled tag cache. 
+        logger.warn(`You've disabled tag cache.
        This means that revalidatePath and revalidateTag from next/cache will not work.
        It is safe to disable if you only use page router`);
     }

package/dist/core/requestHandler.d.ts

@@ -1,3 +1,2 @@
-import type { StreamCreator } from "../http/index.js";
-import type { InternalEvent, InternalResult } from "../types/open-next";
+import type { InternalEvent, InternalResult, StreamCreator } from "../types/open-next";
 export declare function openNextHandler(internalEvent: InternalEvent, responseStreaming?: StreamCreator): Promise<InternalResult>;

package/dist/core/requestHandler.js

@@ -4,35 +4,44 @@ import { runWithOpenNextRequestContext } from "../utils/promise";
 import { debug, error, warn } from "../adapters/logger";
 import { patchAsyncStorage } from "./patchAsyncStorage";
 import { convertRes, createServerResponse } from "./routing/util";
-import routingHandler, { MIDDLEWARE_HEADER_PREFIX, MIDDLEWARE_HEADER_PREFIX_LEN, } from "./routingHandler";
+import routingHandler, { INTERNAL_HEADER_INITIAL_PATH, INTERNAL_HEADER_RESOLVED_ROUTES, MIDDLEWARE_HEADER_PREFIX, MIDDLEWARE_HEADER_PREFIX_LEN, } from "./routingHandler";
 import { requestHandler, setNextjsPrebundledReact } from "./util";
 // This is used to identify requests in the cache
 globalThis.__openNextAls = new AsyncLocalStorage();
 patchAsyncStorage();
 export async function openNextHandler(internalEvent, responseStreaming) {
+    const initialHeaders = internalEvent.headers;
     // We run everything in the async local storage context so that it is available in the middleware as well as in NextServer
-    return runWithOpenNextRequestContext({ isISRRevalidation: internalEvent.headers["x-isr"] === "1" }, async () => {
-        if (internalEvent.headers["x-forwarded-host"]) {
-            internalEvent.headers.host = internalEvent.headers["x-forwarded-host"];
+    return runWithOpenNextRequestContext({ isISRRevalidation: initialHeaders["x-isr"] === "1" }, async () => {
+        if (initialHeaders["x-forwarded-host"]) {
+            initialHeaders.host = initialHeaders["x-forwarded-host"];
         }
         debug("internalEvent", internalEvent);
-        let preprocessResult = {
-            internalEvent: internalEvent,
+        // These 2 will get overwritten by the routing handler if not using an external middleware
+        const internalHeaders = {
+            initialPath: initialHeaders[INTERNAL_HEADER_INITIAL_PATH] ?? internalEvent.rawPath,
+            resolvedRoutes: initialHeaders[INTERNAL_HEADER_RESOLVED_ROUTES]
+                ? JSON.parse(initialHeaders[INTERNAL_HEADER_RESOLVED_ROUTES])
+                : [],
+        };
+        let routingResult = {
+            internalEvent,
             isExternalRewrite: false,
             origin: false,
             isISR: false,
+            ...internalHeaders,
         };
         //#override withRouting
         try {
-            preprocessResult = await routingHandler(internalEvent);
+            routingResult = await routingHandler(internalEvent);
         }
         catch (e) {
             warn("Routing failed.", e);
         }
         //#endOverride
-        const headers = "type" in preprocessResult
-            ? preprocessResult.headers
-            : preprocessResult.internalEvent.headers;
+        const headers = "type" in routingResult
+            ? routingResult.headers
+            : routingResult.internalEvent.headers;
         const overwrittenResponseHeaders = {};
         for (const [rawKey, value] of Object.entries(headers)) {
             if (!rawKey.startsWith(MIDDLEWARE_HEADER_PREFIX)) {
@@ -43,14 +52,14 @@ export async function openNextHandler(internalEvent, responseStreaming) {
             headers[key] = value;
             delete headers[rawKey];
         }
-        if ("isExternalRewrite" in preprocessResult &&
-            preprocessResult.isExternalRewrite === true) {
+        if ("isExternalRewrite" in routingResult &&
+            routingResult.isExternalRewrite === true) {
             try {
-                preprocessResult = await globalThis.proxyExternalRequest.proxy(preprocessResult.internalEvent);
+                routingResult = await globalThis.proxyExternalRequest.proxy(routingResult.internalEvent);
             }
             catch (e) {
                 error("External request failed.", e);
-                preprocessResult = {
+                routingResult = {
                     internalEvent: {
                         type: "core",
                         rawPath: "/500",
@@ -65,25 +74,27 @@ export async function openNextHandler(internalEvent, responseStreaming) {
                     isExternalRewrite: false,
                     isISR: false,
                     origin: false,
+                    initialPath: internalEvent.rawPath,
+                    resolvedRoutes: [{ route: "/500", type: "page" }],
                 };
             }
         }
-        if ("type" in preprocessResult) {
+        if ("type" in routingResult) {
             // response is used only in the streaming case
             if (responseStreaming) {
                 const response = createServerResponse(internalEvent, headers, responseStreaming);
-                response.statusCode = preprocessResult.statusCode;
+                response.statusCode = routingResult.statusCode;
                 response.flushHeaders();
-                const [bodyToConsume, bodyToReturn] = preprocessResult.body.tee();
+                const [bodyToConsume, bodyToReturn] = routingResult.body.tee();
                 for await (const chunk of bodyToConsume) {
                     response.write(chunk);
                 }
                 response.end();
-                preprocessResult.body = bodyToReturn;
+                routingResult.body = bodyToReturn;
             }
-            return preprocessResult;
+            return routingResult;
         }
-        const preprocessedEvent = preprocessResult.internalEvent;
+        const preprocessedEvent = routingResult.internalEvent;
         debug("preprocessedEvent", preprocessedEvent);
         const reqProps = {
             method: preprocessedEvent.method,

package/dist/core/routing/matcher.js

@@ -227,7 +227,7 @@ export function handleRedirects(event, redirects) {
 }
 export function fixDataPage(internalEvent, buildId) {
     const { rawPath, query } = internalEvent;
-    const dataPattern = `/_next/data/${buildId}`;
+    const dataPattern = `${NextConfig.basePath ?? ""}/_next/data/${buildId}`;
     // Return 404 for data requests that don't match the buildId
     if (rawPath.startsWith("/_next/data") && !rawPath.startsWith(dataPattern)) {
         return {

package/dist/core/routing/middleware.d.ts

@@ -1,11 +1,11 @@
 import type { InternalEvent, InternalResult } from "../../types/open-next.js";
-type MiddlewareOutputEvent = InternalEvent & {
+type MiddlewareEvent = InternalEvent & {
     responseHeaders?: Record<string, string | string[]>;
-    externalRewrite?: boolean;
+    isExternalRewrite?: boolean;
 };
 type Middleware = (request: Request) => Response | Promise<Response>;
 type MiddlewareLoader = () => Promise<{
     default: Middleware;
 }>;
-export declare function handleMiddleware(internalEvent: InternalEvent, middlewareLoader?: MiddlewareLoader): Promise<MiddlewareOutputEvent | InternalResult>;
+export declare function handleMiddleware(internalEvent: InternalEvent, middlewareLoader?: MiddlewareLoader): Promise<MiddlewareEvent | InternalResult>;
 export {};

package/dist/core/routing/middleware.js

@@ -114,7 +114,7 @@ export async function handleMiddleware(internalEvent, middlewareLoader = default
     // NOTE: the header was added to `req` from above
     const rewriteUrl = responseHeaders.get("x-middleware-rewrite");
     let rewritten = false;
-    let externalRewrite = false;
+    let isExternalRewrite = false;
     let middlewareQueryString = internalEvent.query;
     let newUrl = internalEvent.url;
     if (rewriteUrl) {
@@ -122,7 +122,7 @@ export async function handleMiddleware(internalEvent, middlewareLoader = default
         if (isExternal(rewriteUrl, internalEvent.headers.host)) {
             newUrl = rewriteUrl;
             rewritten = true;
-            externalRewrite = true;
+            isExternalRewrite = true;
         }
         else {
             const rewriteUrlObject = new URL(rewriteUrl);
@@ -147,7 +147,6 @@ export async function handleMiddleware(internalEvent, middlewareLoader = default
     if (result.body) {
         // transfer response body to res
         const body = result.body;
-        // await pipeReadable(result.response.body, res);
         return {
             type: internalEvent.type,
             statusCode: statusCode,
@@ -169,6 +168,6 @@ export async function handleMiddleware(internalEvent, middlewareLoader = default
         query: middlewareQueryString,
         cookies: internalEvent.cookies,
         remoteAddress: internalEvent.remoteAddress,
-        externalRewrite,
+        isExternalRewrite,
     };
 }

package/dist/core/routing/routeMatcher.d.ts

@@ -0,0 +1,10 @@
+import type { RouteType } from "../../types/open-next";
+export declare const apiPrefix: string;
+export declare const staticRouteMatcher: (path: string) => {
+    route: string;
+    type: RouteType;
+}[];
+export declare const dynamicRouteMatcher: (path: string) => {
+    route: string;
+    type: RouteType;
+}[];

package/dist/core/routing/routeMatcher.js

@@ -0,0 +1,45 @@
+import { AppPathRoutesManifest, RoutesManifest } from "../../adapters/config/index";
+// Add the locale prefix to the regex so we correctly match the rawPath
+const optionalLocalePrefixRegex = `^/(?:${RoutesManifest.locales.map((locale) => `${locale}/?`).join("|")})?`;
+// Add the basepath prefix to the regex so we correctly match the rawPath
+const optionalBasepathPrefixRegex = RoutesManifest.basePath
+    ? `^${RoutesManifest.basePath}/?`
+    : "^/";
+// Add the basePath prefix to the api routes
+export const apiPrefix = `${RoutesManifest.basePath ?? ""}/api`;
+const optionalPrefix = optionalLocalePrefixRegex.replace("^/", optionalBasepathPrefixRegex);
+function routeMatcher(routeDefinitions) {
+    const regexp = routeDefinitions.map((route) => ({
+        page: route.page,
+        regexp: new RegExp(route.regex.replace("^/", optionalPrefix)),
+    }));
+    const appPathsSet = new Set();
+    const routePathsSet = new Set();
+    // We need to use AppPathRoutesManifest here
+    for (const [k, v] of Object.entries(AppPathRoutesManifest)) {
+        if (k.endsWith("page")) {
+            appPathsSet.add(v);
+        }
+        else if (k.endsWith("route")) {
+            routePathsSet.add(v);
+        }
+    }
+    return function matchRoute(path) {
+        const foundRoutes = regexp.filter((route) => route.regexp.test(path));
+        return foundRoutes.map((foundRoute) => {
+            let routeType = "page";
+            if (appPathsSet.has(foundRoute.page)) {
+                routeType = "app";
+            }
+            else if (routePathsSet.has(foundRoute.page)) {
+                routeType = "route";
+            }
+            return {
+                route: foundRoute.page,
+                type: routeType,
+            };
+        });
+    };
+}
+export const staticRouteMatcher = routeMatcher(RoutesManifest.routes.static);
+export const dynamicRouteMatcher = routeMatcher(RoutesManifest.routes.dynamic);

package/dist/core/routing/util.d.ts

@@ -1,8 +1,8 @@
 import type { OutgoingHttpHeaders } from "node:http";
-import type { IncomingMessage, StreamCreator } from "../../http/index.js";
+import type { IncomingMessage } from "../../http/index.js";
 import { OpenNextNodeResponse } from "../../http/openNextResponse.js";
 import type { MiddlewareManifest } from "../../types/next-types";
-import type { InternalEvent, InternalResult } from "../../types/open-next.js";
+import type { InternalEvent, InternalResult, StreamCreator } from "../../types/open-next.js";
 /**
  *
  * @__PURE__
@@ -60,7 +60,7 @@ export declare function convertBodyToReadableStream(method: string, body?: strin
  *
  * @__PURE__
  */
-export declare function fixCacheHeaderForHtmlPages(rawPath: string, headers: OutgoingHttpHeaders): void;
+export declare function fixCacheHeaderForHtmlPages(internalEvent: InternalEvent, headers: OutgoingHttpHeaders): void;
 /**
  *
  * @__PURE__

package/dist/core/routing/util.js

@@ -3,8 +3,9 @@ import { Readable } from "node:stream";
 import { BuildId, HtmlPages, NextConfig } from "../../adapters/config/index.js";
 import { OpenNextNodeResponse } from "../../http/openNextResponse.js";
 import { parseHeaders } from "../../http/util.js";
-import { isBinaryContentType } from "../../adapters/binary.js";
 import { debug, error } from "../../adapters/logger.js";
+import { isBinaryContentType } from "../../utils/binary.js";
+import { localizePath } from "./i18n/index.js";
 /**
  *
  * @__PURE__
@@ -169,9 +170,9 @@ var CommonHeaders;
  *
  * @__PURE__
  */
-export function fixCacheHeaderForHtmlPages(rawPath, headers) {
+export function fixCacheHeaderForHtmlPages(internalEvent, headers) {
     // We don't want to cache error pages
-    if (rawPath === "/404" || rawPath === "/500") {
+    if (internalEvent.rawPath === "/404" || internalEvent.rawPath === "/500") {
         if (process.env.OPEN_NEXT_DANGEROUSLY_SET_ERROR_HEADERS === "true") {
             return;
         }
@@ -179,9 +180,10 @@ export function fixCacheHeaderForHtmlPages(rawPath, headers) {
             "private, no-cache, no-store, max-age=0, must-revalidate";
         return;
     }
+    const localizedPath = localizePath(internalEvent);
     // WORKAROUND: `NextServer` does not set cache headers for HTML pages
     // https://opennext.js.org/aws/v2/advanced/workaround#workaround-nextserver-does-not-set-cache-headers-for-html-pages
-    if (HtmlPages.includes(rawPath)) {
+    if (HtmlPages.includes(localizedPath)) {
         headers[CommonHeaders.CACHE_CONTROL] =
             "public, max-age=0, s-maxage=31536000, must-revalidate";
     }
@@ -352,7 +354,7 @@ export function fixISRHeaders(headers) {
  */
 export function createServerResponse(internalEvent, headers, responseStream) {
     return new OpenNextNodeResponse((_headers) => {
-        fixCacheHeaderForHtmlPages(internalEvent.rawPath, _headers);
+        fixCacheHeaderForHtmlPages(internalEvent, _headers);
         fixSWRCacheHeader(_headers);
         addOpenNextHeader(_headers);
         fixISRHeaders(_headers);

package/dist/core/routingHandler.d.ts

@@ -1,10 +1,7 @@
-import type { InternalEvent, InternalResult, Origin } from "../types/open-next";
+import type { InternalEvent, InternalResult, RoutingResult } from "../types/open-next";
 export declare const MIDDLEWARE_HEADER_PREFIX = "x-middleware-response-";
 export declare const MIDDLEWARE_HEADER_PREFIX_LEN: number;
-export interface MiddlewareOutputEvent {
-    internalEvent: InternalEvent;
-    isExternalRewrite: boolean;
-    origin: Origin | false;
-    isISR: boolean;
-}
-export default function routingHandler(event: InternalEvent): Promise<InternalResult | MiddlewareOutputEvent>;
+export declare const INTERNAL_HEADER_PREFIX = "x-opennext-";
+export declare const INTERNAL_HEADER_INITIAL_PATH = "x-opennext-initial-path";
+export declare const INTERNAL_HEADER_RESOLVED_ROUTES = "x-opennext-resolved-routes";
+export default function routingHandler(event: InternalEvent): Promise<InternalResult | RoutingResult>;

package/dist/core/routingHandler.js

@@ -3,26 +3,12 @@ import { debug } from "../adapters/logger";
 import { cacheInterceptor } from "./routing/cacheInterceptor";
 import { fixDataPage, getNextConfigHeaders, handleFallbackFalse, handleRedirects, handleRewrites, } from "./routing/matcher";
 import { handleMiddleware } from "./routing/middleware";
+import { apiPrefix, dynamicRouteMatcher, staticRouteMatcher, } from "./routing/routeMatcher";
 export const MIDDLEWARE_HEADER_PREFIX = "x-middleware-response-";
 export const MIDDLEWARE_HEADER_PREFIX_LEN = MIDDLEWARE_HEADER_PREFIX.length;
-// Add the locale prefix to the regex so we correctly match the rawPath
-const optionalLocalePrefixRegex = RoutesManifest.locales.length
-    ? `^/(?:${RoutesManifest.locales.map((locale) => `${locale}/?`).join("|")})?`
-    : "^/";
-// Add the basepath prefix to the regex so we correctly match the rawPath
-const optionalBasepathPrefixRegex = RoutesManifest.basePath
-    ? `^${RoutesManifest.basePath}/?`
-    : "^/";
-// Add the basePath prefix to the api routes
-const apiPrefix = RoutesManifest.basePath
-    ? `${RoutesManifest.basePath}/api`
-    : "/api";
-const staticRegexp = RoutesManifest.routes.static.map((route) => new RegExp(route.regex
-    .replace("^/", optionalLocalePrefixRegex)
-    .replace("^/", optionalBasepathPrefixRegex)));
-const dynamicRegexp = RoutesManifest.routes.dynamic.map((route) => new RegExp(route.regex
-    .replace("^/", optionalLocalePrefixRegex)
-    .replace("^/", optionalBasepathPrefixRegex)));
+export const INTERNAL_HEADER_PREFIX = "x-opennext-";
+export const INTERNAL_HEADER_INITIAL_PATH = `${INTERNAL_HEADER_PREFIX}initial-path`;
+export const INTERNAL_HEADER_RESOLVED_ROUTES = `${INTERNAL_HEADER_PREFIX}resolved-routes`;
 // Geolocation headers starting from Nextjs 15
 // See https://github.com/vercel/vercel/blob/7714b1c/packages/functions/src/headers.ts
 const geoHeaderToNextHeader = {
@@ -50,6 +36,14 @@ export default async function routingHandler(event) {
             event.headers[nextGeoName] = value;
         }
     }
+    // First we remove internal headers
+    // We don't want to allow users to set these headers
+    for (const key of Object.keys(event.headers)) {
+        if (key.startsWith(INTERNAL_HEADER_PREFIX) ||
+            key.startsWith(MIDDLEWARE_HEADER_PREFIX)) {
+            delete event.headers[key];
+        }
+    }
     const nextHeaders = getNextConfigHeaders(event, ConfigHeaders);
     let internalEvent = fixDataPage(event, BuildId);
     if ("statusCode" in internalEvent) {
@@ -60,24 +54,24 @@ export default async function routingHandler(event) {
         debug("redirect", redirect);
         return redirect;
     }
-    const middleware = await handleMiddleware(internalEvent);
-    let middlewareResponseHeaders = {};
-    if ("statusCode" in middleware) {
-        return middleware;
+    const eventOrResult = await handleMiddleware(internalEvent);
+    const isResult = "statusCode" in eventOrResult;
+    if (isResult) {
+        return eventOrResult;
     }
-    middlewareResponseHeaders = middleware.responseHeaders || {};
-    internalEvent = middleware;
-    // At this point internalEvent is an InternalEvent or a MiddlewareOutputEvent
-    let isExternalRewrite = middleware.externalRewrite ?? false;
+    const middlewareResponseHeaders = eventOrResult.responseHeaders;
+    let isExternalRewrite = eventOrResult.isExternalRewrite ?? false;
+    // internalEvent is `InternalEvent | MiddlewareEvent`
+    internalEvent = eventOrResult;
     if (!isExternalRewrite) {
         // First rewrite to be applied
         const beforeRewrites = handleRewrites(internalEvent, RoutesManifest.rewrites.beforeFiles);
         internalEvent = beforeRewrites.internalEvent;
         isExternalRewrite = beforeRewrites.isExternalRewrite;
     }
-    const isStaticRoute = !isExternalRewrite &&
-        staticRegexp.some((route) => route.test(internalEvent.rawPath));
-    if (!isStaticRoute && !isExternalRewrite) {
+    const foundStaticRoute = staticRouteMatcher(internalEvent.rawPath);
+    const isStaticRoute = !isExternalRewrite && foundStaticRoute.length > 0;
+    if (!(isStaticRoute || isExternalRewrite)) {
         // Second rewrite to be applied
         const afterRewrites = handleRewrites(internalEvent, RoutesManifest.rewrites.afterFiles);
         internalEvent = afterRewrites.internalEvent;
@@ -86,9 +80,9 @@ export default async function routingHandler(event) {
     // We want to run this just before the dynamic route check
     const { event: fallbackEvent, isISR } = handleFallbackFalse(internalEvent, PrerenderManifest);
     internalEvent = fallbackEvent;
-    const isDynamicRoute = !isExternalRewrite &&
-        dynamicRegexp.some((route) => route.test(internalEvent.rawPath));
-    if (!isDynamicRoute && !isStaticRoute && !isExternalRewrite) {
+    const foundDynamicRoute = dynamicRouteMatcher(internalEvent.rawPath);
+    const isDynamicRoute = !isExternalRewrite && foundDynamicRoute.length > 0;
+    if (!(isDynamicRoute || isStaticRoute || isExternalRewrite)) {
         // Fallback rewrite to be applied
         const fallbackRewrites = handleRewrites(internalEvent, RoutesManifest.rewrites.fallback);
         internalEvent = fallbackRewrites.internalEvent;
@@ -103,12 +97,12 @@ export default async function routingHandler(event) {
     const isRouteFoundBeforeAllRewrites = isStaticRoute || isDynamicRoute || isExternalRewrite;
     // If we still haven't found a route, we show the 404 page
     // We need to ensure that rewrites are applied before showing the 404 page
-    if (!isRouteFoundBeforeAllRewrites &&
-        !isApiRoute &&
-        !isNextImageRoute &&
+    if (!(isRouteFoundBeforeAllRewrites ||
+        isApiRoute ||
+        isNextImageRoute ||
         // We need to check again once all rewrites have been applied
-        !staticRegexp.some((route) => route.test(internalEvent.rawPath)) &&
-        !dynamicRegexp.some((route) => route.test(internalEvent.rawPath))) {
+        staticRouteMatcher(internalEvent.rawPath).length > 0 ||
+        dynamicRouteMatcher(internalEvent.rawPath).length > 0)) {
         internalEvent = {
             ...internalEvent,
             rawPath: "/404",
@@ -136,10 +130,17 @@ export default async function routingHandler(event) {
         ...middlewareResponseHeaders,
         ...nextHeaders,
     });
+    const resolvedRoutes = [
+        ...foundStaticRoute,
+        ...foundDynamicRoute,
+    ];
+    debug("resolvedRoutes", resolvedRoutes);
     return {
         internalEvent,
         isExternalRewrite,
         origin: false,
         isISR,
+        initialPath: event.rawPath,
+        resolvedRoutes,
     };
 }

package/dist/helpers/withCloudflare.d.ts

@@ -57,7 +57,7 @@ export declare function withCloudflare<Fn extends Record<string, CloudflareCompa
         external: true;
         originResolver: "pattern-env";
         override: {
-            wrapper: "cloudflare";
+            wrapper: "cloudflare-edge";
             converter: "edge";
         };
     };

package/dist/helpers/withCloudflare.js

@@ -36,7 +36,7 @@ export function withCloudflare(config) {
                     routes: [fn.routes],
                     patterns: [fn.patterns],
                     override: {
-                        wrapper: "cloudflare",
+                        wrapper: "cloudflare-edge",
                         converter: "edge",
                     },
                 }
@@ -50,7 +50,7 @@ export function withCloudflare(config) {
             external: true,
             originResolver: "pattern-env",
             override: {
-                wrapper: "cloudflare",
+                wrapper: "cloudflare-edge",
                 converter: "edge",
             },
         },

package/dist/http/openNextResponse.d.ts

@@ -1,16 +1,8 @@
 import type { IncomingMessage, OutgoingHttpHeader, OutgoingHttpHeaders, ServerResponse } from "node:http";
 import type { Socket } from "node:net";
-import type { TransformCallback, Writable } from "node:stream";
+import type { TransformCallback } from "node:stream";
 import { Transform } from "node:stream";
-export interface StreamCreator {
-    writeHeaders(prelude: {
-        statusCode: number;
-        cookies: string[];
-        headers: Record<string, string>;
-    }): Writable;
-    onWrite?: () => void;
-    onFinish: (length: number) => void;
-}
+import type { StreamCreator } from "../types/open-next";
 export declare class OpenNextNodeResponse extends Transform implements ServerResponse {
     private fixHeaders;
     private onEnd;

package/dist/http/openNextResponse.js

@@ -64,7 +64,9 @@ export class OpenNextNodeResponse extends Transform {
         return this;
     }
     get finished() {
-        return Boolean(this.writableFinished && this.responseStream?.writableFinished);
+        return this.responseStream
+            ? this.responseStream?.writableFinished
+            : this.writableFinished;
     }
     setHeader(name, value) {
         const key = name.toLowerCase();
@@ -125,7 +127,7 @@ export class OpenNextNodeResponse extends Transform {
                         ...this.initialHeaders,
                         ...this.headers,
                     };
-            const initialCookies = parseCookies(this.initialHeaders[SET_COOKIE_HEADER]);
+            const initialCookies = parseCookies(this.initialHeaders[SET_COOKIE_HEADER]?.toString());
             this._cookies =
                 mergeHeadersPriority === "middleware"
                     ? [...this._cookies, ...initialCookies]
@@ -226,7 +228,7 @@ export class OpenNextNodeResponse extends Transform {
             ?.getStore()
             ?.pendingPromiseRunner.add(this.onEnd(this.headers));
         const bodyLength = this.getBody().length;
-        this.streamCreator?.onFinish(bodyLength);
+        this.streamCreator?.onFinish?.(bodyLength);
         //This is only here because of aws broken streaming implementation.
         //Hopefully one day they will be able to give us a working streaming implementation in lambda for everyone
         //If you're lucky you have a working streaming implementation in your aws account and don't need this

package/dist/overrides/converters/aws-apigw-v2.js

@@ -3,7 +3,8 @@ import { fromReadableStream } from "../../utils/stream";
 import { debug } from "../../adapters/logger";
 import { convertToQuery } from "../../core/routing/util";
 import { removeUndefinedFromQuery } from "./utils";
-// Not sure which one is reallly needed as this is not documented anywhere but server actions redirect are not working without this, it causes a 500 error from cloudfront itself with a 'x-amzErrortype: InternalFailure' header
+// Not sure which one is really needed as this is not documented anywhere but server actions redirect are not working without this,
+// it causes a 500 error from cloudfront itself with a 'x-amzErrortype: InternalFailure' header
 const CloudFrontBlacklistedHeaders = [
     "connection",
     "expect",

package/dist/overrides/converters/aws-cloudfront.js

@@ -1,7 +1,7 @@
 import { parseCookies } from "../../http/util";
 import { fromReadableStream } from "../../utils/stream";
 import { debug } from "../../adapters/logger";
-import { convertToQuery, convertToQueryString, } from "../../core/routing/util";
+import { convertToQuery, convertToQueryString } from "../../core/routing/util";
 const cloudfrontBlacklistedHeaders = [
     // Disallowed headers, see: https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/edge-function-restrictions-all.html#function-restrictions-disallowed-headers
     "connection",

package/dist/overrides/converters/edge.d.ts

@@ -1,10 +1,7 @@
-import type { InternalEvent, InternalResult } from "../../types/open-next";
+import type { InternalEvent, InternalResult, MiddlewareResult } from "../../types/open-next";
 import type { Converter } from "../../types/overrides";
-import type { MiddlewareOutputEvent } from "../../core/routingHandler";
 declare global {
     var __dangerous_ON_edge_converter_returns_request: boolean | undefined;
 }
-declare const converter: Converter<InternalEvent, InternalResult | ({
-    type: "middleware";
-} & MiddlewareOutputEvent)>;
+declare const converter: Converter<InternalEvent, InternalResult | MiddlewareResult>;
 export default converter;

package/dist/overrides/converters/edge.js

@@ -2,7 +2,8 @@ import { Buffer } from "node:buffer";
 import { parseCookies } from "../../http/util";
 const converter = {
     convertFrom: async (event) => {
-        const searchParams = new URL(event.url).searchParams;
+        const url = new URL(event.url);
+        const searchParams = url.searchParams;
         const query = {};
         for (const [key, value] of searchParams.entries()) {
             if (key in query) {
@@ -17,13 +18,13 @@ const converter = {
                 query[key] = value;
             }
         }
-        //Transform body into Buffer
+        // Transform body into Buffer
         const body = await event.arrayBuffer();
         const headers = {};
         event.headers.forEach((value, key) => {
             headers[key] = value;
         });
-        const rawPath = new URL(event.url).pathname;
+        const rawPath = url.pathname;
         const method = event.method;
         const shouldHaveBody = method !== "GET" && method !== "HEAD";
         const cookies = Object.fromEntries(parseCookies(event.headers.get("cookie")).map((cookie) => cookie.split("=")));
@@ -79,7 +80,7 @@ const converter = {
         }
         return new Response(result.body, {
             status: result.statusCode,
-            headers: headers,
+            headers,
         });
     },
     name: "edge",

package/dist/overrides/incrementalCache/dummy.js

@@ -1,13 +1,14 @@
+import { IgnorableError } from "../../utils/error";
 const dummyIncrementalCache = {
     name: "dummy",
     get: async () => {
-        throw new Error("Dummy cache is not implemented");
+        throw new IgnorableError('"Dummy" cache does not cache anything');
     },
     set: async () => {
-        throw new Error("Dummy cache is not implemented");
+        throw new IgnorableError('"Dummy" cache does not cache anything');
     },
     delete: async () => {
-        throw new Error("Dummy cache is not implemented");
+        throw new IgnorableError('"Dummy" cache does not cache anything');
     },
 };
 export default dummyIncrementalCache;

package/dist/overrides/proxyExternalRequest/dummy.js

@@ -1,7 +1,8 @@
+import { FatalError } from "../../utils/error";
 const DummyProxyExternalRequest = {
     name: "dummy",
     proxy: async (_event) => {
-        throw new Error("This is a dummy implementation");
+        throw new FatalError("This is a dummy implementation");
     },
 };
 export default DummyProxyExternalRequest;