@opennextjs/aws 3.3.0 → 3.4.0

package/dist/core/routing/util.js

@@ -5,6 +5,7 @@ import { OpenNextNodeResponse } from "../../http/openNextResponse.js";
 import { parseHeaders } from "../../http/util.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";
     }
@@ -350,13 +352,30 @@ export function fixISRHeaders(headers) {
  * @returns
  * @__PURE__
  */
-export function createServerResponse(internalEvent, headers, responseStream) {
+export function createServerResponse(routingResult, headers, responseStream) {
+    const internalEvent = routingResult.internalEvent;
     return new OpenNextNodeResponse((_headers) => {
-        fixCacheHeaderForHtmlPages(internalEvent.rawPath, _headers);
+        fixCacheHeaderForHtmlPages(internalEvent, _headers);
         fixSWRCacheHeader(_headers);
         addOpenNextHeader(_headers);
         fixISRHeaders(_headers);
     }, async (_headers) => {
         await revalidateIfRequired(internalEvent.headers.host, internalEvent.rawPath, _headers);
+        await invalidateCDNOnRequest(routingResult, _headers);
     }, responseStream, headers);
 }
+// This function is used only for `res.revalidate()`
+export async function invalidateCDNOnRequest(params, headers) {
+    const { internalEvent, initialPath, resolvedRoutes } = params;
+    const isIsrRevalidation = internalEvent.headers["x-isr"] === "1";
+    if (!isIsrRevalidation &&
+        headers[CommonHeaders.NEXT_CACHE] === "REVALIDATED") {
+        await globalThis.cdnInvalidationHandler.invalidatePaths([
+            {
+                initialPath,
+                rawPath: internalEvent.rawPath,
+                resolvedRoutes,
+            },
+        ]);
+    }
+}

package/dist/core/routingHandler.d.ts

@@ -1,4 +1,7 @@
 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 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) {
@@ -75,9 +69,9 @@ export default async function routingHandler(event) {
         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/overrides/cdnInvalidation/cloudfront.d.ts

@@ -0,0 +1,9 @@
+declare const _default: {
+    name: string;
+    invalidatePaths: (paths: {
+        initialPath: string;
+        rawPath: string;
+        resolvedRoutes: import("../../types/open-next").ResolvedRoute[];
+    }[]) => Promise<void>;
+};
+export default _default;

package/dist/overrides/cdnInvalidation/cloudfront.js

@@ -0,0 +1,26 @@
+import { CloudFrontClient, CreateInvalidationCommand, } from "@aws-sdk/client-cloudfront";
+const cloudfront = new CloudFrontClient({});
+export default {
+    name: "cloudfront",
+    invalidatePaths: async (paths) => {
+        const constructedPaths = paths.flatMap(({ initialPath, resolvedRoutes }) => {
+            const isAppRouter = resolvedRoutes.some((route) => route.type === "app");
+            // revalidateTag doesn't have any leading slash, remove it just to be sure
+            const path = initialPath.replace(/^\//, "");
+            return isAppRouter
+                ? [`/${path}`, `/${path}?_rsc=*`]
+                : [
+                    `/${path}`,
+                    `/_next/data/${process.env.NEXT_BUILD_ID}${path === "/" ? "/index" : `/${path}`}.json*`,
+                ];
+        });
+        await cloudfront.send(new CreateInvalidationCommand({
+            DistributionId: process.env.CLOUDFRONT_DISTRIBUTION_ID,
+            InvalidationBatch: {
+                // Do we need to limit the number of paths? Or batch them into multiple commands?
+                Paths: { Quantity: constructedPaths.length, Items: constructedPaths },
+                CallerReference: `${Date.now()}`,
+            },
+        }));
+    },
+};

package/dist/overrides/cdnInvalidation/dummy.d.ts

@@ -0,0 +1,9 @@
+declare const _default: {
+    name: string;
+    invalidatePaths: (_: {
+        initialPath: string;
+        rawPath: string;
+        resolvedRoutes: import("../../types/open-next").ResolvedRoute[];
+    }[]) => Promise<void>;
+};
+export default _default;

package/dist/overrides/cdnInvalidation/dummy.js

@@ -0,0 +1,6 @@
+export default {
+    name: "dummy",
+    invalidatePaths: (_) => {
+        return Promise.resolve();
+    },
+};

package/dist/overrides/imageLoader/fs-dev.d.ts

@@ -0,0 +1,10 @@
+import fs from "node:fs";
+declare const _default: {
+    name: string;
+    load: (url: string) => Promise<{
+        body: fs.ReadStream;
+        contentType: string;
+        cacheControl: string;
+    }>;
+};
+export default _default;

package/dist/overrides/imageLoader/fs-dev.js

@@ -0,0 +1,14 @@
+import fs from "node:fs";
+export default {
+    name: "fs-dev",
+    load: async (url) => {
+        const basePath = "../../assets";
+        const body = fs.createReadStream(`${basePath}/${url}`);
+        const contentType = url.endsWith(".png") ? "image/png" : "image/jpeg";
+        return {
+            body,
+            contentType,
+            cacheControl: "public, max-age=31536000, immutable",
+        };
+    },
+};

package/dist/overrides/incrementalCache/fs-dev.d.ts

@@ -0,0 +1,3 @@
+import type { IncrementalCache } from "../../types/overrides.js";
+declare const cache: IncrementalCache;
+export default cache;

package/dist/overrides/incrementalCache/fs-dev.js

@@ -0,0 +1,30 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+const buildId = process.env.NEXT_BUILD_ID;
+const basePath = path.resolve(process.cwd(), `../../cache/${buildId}`);
+const getCacheKey = (key) => {
+    return path.join(basePath, `${key}.cache`);
+};
+const cache = {
+    name: "fs-dev",
+    get: async (key) => {
+        const fileData = await fs.readFile(getCacheKey(key), "utf-8");
+        const data = JSON.parse(fileData);
+        const { mtime } = await fs.stat(getCacheKey(key));
+        return {
+            value: data,
+            lastModified: mtime.getTime(),
+        };
+    },
+    set: async (key, value, isFetch) => {
+        const data = JSON.stringify(value);
+        const cacheKey = getCacheKey(key);
+        // We need to create the directory before writing the file
+        await fs.mkdir(path.dirname(cacheKey), { recursive: true });
+        await fs.writeFile(cacheKey, data);
+    },
+    delete: async (key) => {
+        await fs.rm(getCacheKey(key));
+    },
+};
+export default cache;

package/dist/overrides/incrementalCache/multi-tier-ddb-s3.d.ts

@@ -0,0 +1,10 @@
+import type { IncrementalCache } from "../../types/overrides";
+/**
+ * This cache implementation uses a multi-tier cache with a local cache, a DynamoDB metadata cache and an S3 cache.
+ * It uses the same DynamoDB table as the default tag cache and the same S3 bucket as the default incremental cache.
+ * It will first check the local cache.
+ * If the local cache is expired, it will check the DynamoDB metadata cache to see if the local cache is still valid.
+ * Lastly it will check the S3 cache.
+ */
+declare const multiTierCache: IncrementalCache;
+export default multiTierCache;

package/dist/overrides/incrementalCache/multi-tier-ddb-s3.js

@@ -0,0 +1,120 @@
+import { customFetchClient } from "../../utils/fetch";
+import { LRUCache } from "../../utils/lru";
+import { debug } from "../../adapters/logger";
+import S3Cache, { getAwsClient } from "./s3-lite";
+// TTL for the local cache in milliseconds
+const localCacheTTL = process.env.OPEN_NEXT_LOCAL_CACHE_TTL_MS
+    ? Number.parseInt(process.env.OPEN_NEXT_LOCAL_CACHE_TTL_MS, 10)
+    : 0;
+// Maximum size of the local cache in nb of entries
+const maxCacheSize = process.env.OPEN_NEXT_LOCAL_CACHE_SIZE
+    ? Number.parseInt(process.env.OPEN_NEXT_LOCAL_CACHE_SIZE, 10)
+    : 1000;
+const localCache = new LRUCache(maxCacheSize);
+const awsFetch = (body, type = "get") => {
+    const { CACHE_BUCKET_REGION } = process.env;
+    const client = getAwsClient();
+    return customFetchClient(client)(`https://dynamodb.${CACHE_BUCKET_REGION}.amazonaws.com`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/x-amz-json-1.0",
+            "X-Amz-Target": `DynamoDB_20120810.${type === "get" ? "GetItem" : "PutItem"}`,
+        },
+        body,
+    });
+};
+const buildDynamoKey = (key) => {
+    const { NEXT_BUILD_ID } = process.env;
+    return `__meta_${NEXT_BUILD_ID}_${key}`;
+};
+/**
+ * This cache implementation uses a multi-tier cache with a local cache, a DynamoDB metadata cache and an S3 cache.
+ * It uses the same DynamoDB table as the default tag cache and the same S3 bucket as the default incremental cache.
+ * It will first check the local cache.
+ * If the local cache is expired, it will check the DynamoDB metadata cache to see if the local cache is still valid.
+ * Lastly it will check the S3 cache.
+ */
+const multiTierCache = {
+    name: "multi-tier-ddb-s3",
+    async get(key, isFetch) {
+        // First we check the local cache
+        const localCacheEntry = localCache.get(key);
+        if (localCacheEntry) {
+            if (Date.now() - localCacheEntry.lastModified < localCacheTTL) {
+                debug("Using local cache without checking ddb");
+                return localCacheEntry;
+            }
+            try {
+                // Here we'll check ddb metadata to see if the local cache is still valid
+                const { CACHE_DYNAMO_TABLE } = process.env;
+                const result = await awsFetch(JSON.stringify({
+                    TableName: CACHE_DYNAMO_TABLE,
+                    Key: {
+                        path: { S: buildDynamoKey(key) },
+                        tag: { S: buildDynamoKey(key) },
+                    },
+                }));
+                if (result.status === 200) {
+                    const data = await result.json();
+                    const hasBeenDeleted = data.Item?.deleted?.BOOL;
+                    if (hasBeenDeleted) {
+                        localCache.delete(key);
+                        return { value: undefined, lastModified: 0 };
+                    }
+                    // If the metadata is older than the local cache, we can use the local cache
+                    // If it's not found we assume that no write has been done yet and we can use the local cache
+                    const lastModified = data.Item?.revalidatedAt?.N
+                        ? Number.parseInt(data.Item.revalidatedAt.N, 10)
+                        : 0;
+                    if (lastModified <= localCacheEntry.lastModified) {
+                        debug("Using local cache after checking ddb");
+                        return localCacheEntry;
+                    }
+                }
+            }
+            catch (e) {
+                debug("Failed to get metadata from ddb", e);
+            }
+        }
+        const result = await S3Cache.get(key, isFetch);
+        if (result.value) {
+            localCache.set(key, {
+                value: result.value,
+                lastModified: result.lastModified ?? Date.now(),
+            });
+        }
+        return result;
+    },
+    // Both for set and delete we choose to do the write to S3 first and then to DynamoDB
+    // Which means that if it fails in DynamoDB, instance that don't have local cache will work as expected.
+    // But instance that have local cache will have a stale cache until the next working set or delete.
+    async set(key, value, isFetch) {
+        const revalidatedAt = Date.now();
+        await S3Cache.set(key, value, isFetch);
+        await awsFetch(JSON.stringify({
+            TableName: process.env.CACHE_DYNAMO_TABLE,
+            Item: {
+                tag: { S: buildDynamoKey(key) },
+                path: { S: buildDynamoKey(key) },
+                revalidatedAt: { N: String(revalidatedAt) },
+            },
+        }), "set");
+        localCache.set(key, {
+            value,
+            lastModified: revalidatedAt,
+        });
+    },
+    async delete(key) {
+        await S3Cache.delete(key);
+        await awsFetch(JSON.stringify({
+            TableName: process.env.CACHE_DYNAMO_TABLE,
+            Item: {
+                tag: { S: buildDynamoKey(key) },
+                path: { S: buildDynamoKey(key) },
+                deleted: { BOOL: true },
+            },
+        }), "set");
+        localCache.delete(key);
+    },
+};
+export default multiTierCache;

package/dist/overrides/incrementalCache/s3-lite.d.ts

@@ -1,3 +1,5 @@
+import { AwsClient } from "aws4fetch";
 import type { IncrementalCache } from "../../types/overrides";
+export declare const getAwsClient: () => AwsClient;
 declare const incrementalCache: IncrementalCache;
 export default incrementalCache;

package/dist/overrides/incrementalCache/s3-lite.js

@@ -5,7 +5,7 @@ import { IgnorableError, RecoverableError } from "../../utils/error";
 import { customFetchClient } from "../../utils/fetch";
 import { parseNumberFromEnv } from "../../adapters/util";
 let awsClient = null;
-const getAwsClient = () => {
+export const getAwsClient = () => {
     const { CACHE_BUCKET_REGION } = process.env;
     if (awsClient) {
         return awsClient;

package/dist/overrides/proxyExternalRequest/node.js

@@ -36,16 +36,17 @@ const nodeProxy = {
                 method,
                 rejectUnauthorized: false,
             }, (_res) => {
-                const nodeReadableStream = _res.headers["content-encoding"] === "br"
+                const resHeaders = _res.headers;
+                const nodeReadableStream = resHeaders["content-encoding"] === "br"
                     ? _res.pipe(require("node:zlib").createBrotliDecompress())
-                    : _res.headers["content-encoding"] === "gzip"
+                    : resHeaders["content-encoding"] === "gzip"
                         ? _res.pipe(require("node:zlib").createGunzip())
                         : _res;
-                const isBase64Encoded = isBinaryContentType(headers["content-type"]) ||
-                    !!headers["content-encoding"];
+                const isBase64Encoded = isBinaryContentType(resHeaders["content-type"]) ||
+                    !!resHeaders["content-encoding"];
                 const result = {
                     type: "core",
-                    headers: filterHeadersForProxy(_res.headers),
+                    headers: filterHeadersForProxy(resHeaders),
                     statusCode: _res.statusCode ?? 200,
                     // TODO: check base64 encoding
                     isBase64Encoded,

package/dist/overrides/queue/direct.d.ts

@@ -0,0 +1,3 @@
+import type { Queue } from "../../types/overrides.js";
+declare const queue: Queue;
+export default queue;

package/dist/overrides/queue/direct.js

@@ -0,0 +1,18 @@
+const queue = {
+    name: "dev-queue",
+    send: async (message) => {
+        const prerenderManifest = (await import("../../adapters/config/index.js"))
+            .PrerenderManifest;
+        const { host, url } = message.MessageBody;
+        const protocol = host.includes("localhost") ? "http" : "https";
+        const revalidateId = prerenderManifest.preview.previewModeId;
+        await globalThis.internalFetch(`${protocol}://${host}${url}`, {
+            method: "HEAD",
+            headers: {
+                "x-prerender-revalidate": revalidateId,
+                "x-isr": "1",
+            },
+        });
+    },
+};
+export default queue;

package/dist/overrides/tagCache/fs-dev.d.ts

@@ -0,0 +1,3 @@
+import type { TagCache } from "../../types/overrides";
+declare const tagCache: TagCache;
+export default tagCache;

package/dist/overrides/tagCache/fs-dev.js

@@ -0,0 +1,32 @@
+import fs from "node:fs";
+const tagFile = "../../dynamodb-provider/dynamodb-cache.json";
+const tagContent = fs.readFileSync(tagFile, "utf-8");
+let tags = JSON.parse(tagContent);
+const tagCache = {
+    name: "fs-dev",
+    getByPath: async (path) => {
+        return tags
+            .filter((tagPathMapping) => tagPathMapping.path.S === path)
+            .map((tag) => tag.tag.S);
+    },
+    getByTag: async (tag) => {
+        return tags
+            .filter((tagPathMapping) => tagPathMapping.tag.S === tag)
+            .map((tag) => tag.path.S);
+    },
+    getLastModified: async (path, lastModified) => {
+        const revalidatedTags = tags.filter((tagPathMapping) => tagPathMapping.path.S === path &&
+            Number.parseInt(tagPathMapping.revalidatedAt.N) > (lastModified ?? 0));
+        return revalidatedTags.length > 0 ? -1 : (lastModified ?? Date.now());
+    },
+    writeTags: async (newTags) => {
+        const newTagsSet = new Set(newTags.map(({ tag, path }) => `${tag}-${path}`));
+        const unchangedTags = tags.filter(({ tag, path }) => !newTagsSet.has(`${tag.S}-${path.S}`));
+        tags = unchangedTags.concat(newTags.map((tag) => ({
+            tag: { S: tag.tag },
+            path: { S: tag.path },
+            revalidatedAt: { N: String(tag.revalidatedAt) },
+        })));
+    },
+};
+export default tagCache;

package/dist/overrides/wrappers/cloudflare-edge.js

@@ -1,5 +1,7 @@
-const cfPropNameToHeaderName = {
-    city: "x-open-next-city",
+const cfPropNameMapping = {
+    // The city name is percent-encoded.
+    // See https://github.com/vercel/vercel/blob/4cb6143/packages/functions/src/headers.ts#L94C19-L94C37
+    city: [encodeURIComponent, "x-open-next-city"],
     country: "x-open-next-country",
     regionCode: "x-open-next-region",
     latitude: "x-open-next-latitude",
@@ -20,10 +22,15 @@ const handler = async (handler, converter) => async (request, env, ctx) => {
     // See https://developers.cloudflare.com/workers/runtime-apis/request
     // Note: This code could be moved to a cloudflare specific converter when one is created.
     const cfProperties = request.cf;
-    for (const [propName, headerName] of Object.entries(cfPropNameToHeaderName)) {
+    for (const [propName, mapping] of Object.entries(cfPropNameMapping)) {
         const propValue = cfProperties?.[propName];
         if (propValue != null) {
-            internalEvent.headers[headerName] = propValue;
+            const [encode, headerName] = Array.isArray(mapping)
+                ? mapping
+                : [null, mapping];
+            internalEvent.headers[headerName] = encode
+                ? encode(propValue)
+                : propValue;
         }
     }
     const response = await handler(internalEvent);

package/dist/overrides/wrappers/cloudflare-node.js

@@ -1,4 +1,6 @@
 import { Writable } from "node:stream";
+// Response with null body status (101, 204, 205, or 304) cannot have a body.
+const NULL_BODY_STATUSES = new Set([101, 204, 205, 304]);
 const handler = async (handler, converter) => async (request, env, ctx) => {
     globalThis.process = process;
     globalThis.openNextWaitUntil = ctx.waitUntil.bind(ctx);
@@ -29,7 +31,8 @@ const handler = async (handler, converter) => async (request, env, ctx) => {
                     controller.enqueue(Uint8Array.from(chunk.chunk ?? chunk));
                 },
             });
-            const response = new Response(readable, {
+            const body = NULL_BODY_STATUSES.has(statusCode) ? null : readable;
+            const response = new Response(body, {
                 status: statusCode,
                 headers: responseHeaders,
             });

package/dist/overrides/wrappers/dummy.d.ts

@@ -2,6 +2,6 @@ import type { WrapperHandler } from "../../types/overrides";
 declare const _default: {
     name: string;
     wrapper: WrapperHandler;
-    supportStreaming: false;
+    supportStreaming: true;
 };
 export default _default;

package/dist/overrides/wrappers/dummy.js

@@ -1,6 +1,10 @@
-const dummyWrapper = async () => async () => undefined;
+const dummyWrapper = async (handler, converter) => {
+    return async (event, responseStream) => {
+        return await handler(event, responseStream);
+    };
+};
 export default {
     name: "dummy",
     wrapper: dummyWrapper,
-    supportStreaming: false,
+    supportStreaming: true,
 };

package/dist/overrides/wrappers/express-dev.d.ts

@@ -0,0 +1,7 @@
+import type { WrapperHandler } from "../../types/overrides.js";
+declare const _default: {
+    wrapper: WrapperHandler;
+    name: string;
+    supportStreaming: boolean;
+};
+export default _default;