@opennextjs/aws 3.3.0 → 3.4.0

package/dist/adapters/cache.d.ts

@@ -58,8 +58,7 @@ interface CacheHandlerValue {
     cacheState?: string;
     value: IncrementalCacheValue | null;
 }
-export declare function hasCacheExtension(key: string): boolean;
-export default class S3Cache {
+export default class Cache {
     get(key: string, options?: boolean | {
         fetchCache?: boolean;
         kindHint?: "app" | "pages" | "fetch";

package/dist/adapters/cache.js

@@ -1,10 +1,5 @@
 import { isBinaryContentType } from "../utils/binary";
 import { debug, error, warn } from "./logger";
-/** Beginning single backslash is intentional, to look for the dot + the extension. Do not escape it again. */
-const CACHE_EXTENSION_REGEX = /\.(cache|fetch)$/;
-export function hasCacheExtension(key) {
-    return CACHE_EXTENSION_REGEX.test(key);
-}
 function isFetchCache(options) {
     if (typeof options === "boolean") {
         return options;
@@ -17,7 +12,7 @@ function isFetchCache(options) {
     return false;
 }
 // We need to use globalThis client here as this class can be defined at load time in next 12 but client is not available at load time
-export default class S3Cache {
+export default class Cache {
     async get(key, 
     // fetchCache is for next 13.5 and above, kindHint is for next 14 and above and boolean is for earlier versions
     options) {
@@ -34,7 +29,6 @@ export default class S3Cache {
         debug("get fetch cache", { key, softTags, tags });
         try {
             const { value, lastModified } = await globalThis.incrementalCache.get(key, true);
-            // const { Body, LastModified } = await this.getS3Object(key, "fetch");
             const _lastModified = await globalThis.tagCache.getLastModified(key, lastModified);
             if (_lastModified === -1) {
                 // If some tags are stale we need to force revalidation
@@ -71,10 +65,6 @@ export default class S3Cache {
     async getIncrementalCache(key) {
         try {
             const { value: cacheData, lastModified } = await globalThis.incrementalCache.get(key, false);
-            // const { Body, LastModified } = await this.getS3Object(key, "cache");
-            // const cacheData = JSON.parse(
-            //   (await Body?.transformToString()) ?? "{}",
-            // ) as S3CachedFile;
             const meta = cacheData?.meta;
             const _lastModified = await globalThis.tagCache.getLastModified(key, lastModified);
             if (_lastModified === -1) {
@@ -285,6 +275,25 @@ export default class S3Cache {
                 }
                 // Update all keys with the given tag with revalidatedAt set to now
                 await globalThis.tagCache.writeTags(toInsert);
+                // We can now invalidate all paths in the CDN
+                // This only applies to `revalidateTag`, not to `res.revalidate()`
+                const uniquePaths = Array.from(new Set(toInsert
+                    // We need to filter fetch cache key as they are not in the CDN
+                    .filter((t) => t.tag.startsWith("_N_T_/"))
+                    .map((t) => `/${t.path}`)));
+                if (uniquePaths.length > 0) {
+                    await globalThis.cdnInvalidationHandler.invalidatePaths(uniquePaths.map((path) => ({
+                        initialPath: path,
+                        rawPath: path,
+                        resolvedRoutes: [
+                            {
+                                route: path,
+                                // TODO: ideally here we should check if it's an app router page or route
+                                type: "app",
+                            },
+                        ],
+                    })));
+                }
             }
         }
         catch (e) {

package/dist/adapters/config/index.d.ts

@@ -25,3 +25,5 @@ export declare const ConfigHeaders: import("../../types/next-types").Header[] |
 export declare const PrerenderManifest: import("../../types/next-types").PrerenderManifest;
 export declare const AppPathsManifestKeys: string[];
 export declare const MiddlewareManifest: import("../../types/next-types").MiddlewareManifest;
+export declare const AppPathsManifest: Record<string, string>;
+export declare const AppPathRoutesManifest: Record<string, string>;

package/dist/adapters/config/index.js

@@ -1,8 +1,6 @@
 import path from "node:path";
 import { debug } from "../logger";
-import { loadAppPathsManifestKeys, loadBuildId, loadConfig, loadConfigHeaders, loadHtmlPages, loadMiddlewareManifest, loadPrerenderManifest, 
-// loadPublicAssets,
-loadRoutesManifest, } from "./util.js";
+import { loadAppPathRoutesManifest, loadAppPathsManifest, loadAppPathsManifestKeys, loadBuildId, loadConfig, loadConfigHeaders, loadHtmlPages, loadMiddlewareManifest, loadPrerenderManifest, loadRoutesManifest, } from "./util.js";
 export const NEXT_DIR = path.join(__dirname, ".next");
 export const OPEN_NEXT_DIR = path.join(__dirname, ".open-next");
 debug({ NEXT_DIR, OPEN_NEXT_DIR });
@@ -19,3 +17,6 @@ export const AppPathsManifestKeys =
 /* @__PURE__ */ loadAppPathsManifestKeys(NEXT_DIR);
 export const MiddlewareManifest = 
 /* @__PURE__ */ loadMiddlewareManifest(NEXT_DIR);
+export const AppPathsManifest = /* @__PURE__ */ loadAppPathsManifest(NEXT_DIR);
+export const AppPathRoutesManifest = 
+/* @__PURE__ */ loadAppPathRoutesManifest(NEXT_DIR);

package/dist/adapters/config/util.d.ts

@@ -24,5 +24,7 @@ export declare function loadRoutesManifest(nextDir: string): {
 };
 export declare function loadConfigHeaders(nextDir: string): import("../../types/next-types").Header[] | undefined;
 export declare function loadPrerenderManifest(nextDir: string): PrerenderManifest;
+export declare function loadAppPathsManifest(nextDir: string): Record<string, string>;
+export declare function loadAppPathRoutesManifest(nextDir: string): Record<string, string>;
 export declare function loadAppPathsManifestKeys(nextDir: string): string[];
 export declare function loadMiddlewareManifest(nextDir: string): MiddlewareManifest;

package/dist/adapters/config/util.js

@@ -60,12 +60,22 @@ export function loadPrerenderManifest(nextDir) {
     const json = fs.readFileSync(filePath, "utf-8");
     return JSON.parse(json);
 }
-export function loadAppPathsManifestKeys(nextDir) {
+export function loadAppPathsManifest(nextDir) {
     const appPathsManifestPath = path.join(nextDir, "server", "app-paths-manifest.json");
     const appPathsManifestJson = fs.existsSync(appPathsManifestPath)
         ? fs.readFileSync(appPathsManifestPath, "utf-8")
         : "{}";
-    const appPathsManifest = JSON.parse(appPathsManifestJson);
+    return JSON.parse(appPathsManifestJson);
+}
+export function loadAppPathRoutesManifest(nextDir) {
+    const appPathRoutesManifestPath = path.join(nextDir, "app-path-routes-manifest.json");
+    if (fs.existsSync(appPathRoutesManifestPath)) {
+        return JSON.parse(fs.readFileSync(appPathRoutesManifestPath, "utf-8"));
+    }
+    return {};
+}
+export function loadAppPathsManifestKeys(nextDir) {
+    const appPathsManifest = loadAppPathsManifest(nextDir);
     return Object.keys(appPathsManifest).map((key) => {
         // Remove parallel route
         let cleanedKey = key.replace(/\/@[^\/]+/g, "");

package/dist/adapters/middleware.js

@@ -2,7 +2,7 @@ import { runWithOpenNextRequestContext } from "../utils/promise";
 import { debug, error } from "../adapters/logger";
 import { createGenericHandler } from "../core/createGenericHandler";
 import { resolveIncrementalCache, resolveOriginResolver, resolveProxyRequest, resolveQueue, resolveTagCache, } from "../core/resolve";
-import routingHandler from "../core/routingHandler";
+import routingHandler, { INTERNAL_HEADER_INITIAL_PATH, INTERNAL_HEADER_RESOLVED_ROUTES, } from "../core/routingHandler";
 globalThis.internalFetch = fetch;
 globalThis.__openNextAls = new AsyncLocalStorage();
 const defaultHandler = async (internalEvent) => {
@@ -22,10 +22,19 @@ const defaultHandler = async (internalEvent) => {
                 const origin = await originResolver.resolve(result.internalEvent.rawPath);
                 return {
                     type: "middleware",
-                    internalEvent: result.internalEvent,
+                    internalEvent: {
+                        ...result.internalEvent,
+                        headers: {
+                            ...result.internalEvent.headers,
+                            [INTERNAL_HEADER_INITIAL_PATH]: internalEvent.rawPath,
+                            [INTERNAL_HEADER_RESOLVED_ROUTES]: JSON.stringify(result.resolvedRoutes) ?? "[]",
+                        },
+                    },
                     isExternalRewrite: result.isExternalRewrite,
                     origin,
                     isISR: result.isISR,
+                    initialPath: result.initialPath,
+                    resolvedRoutes: result.resolvedRoutes,
                 };
             }
             try {
@@ -45,6 +54,8 @@ const defaultHandler = async (internalEvent) => {
                     isExternalRewrite: false,
                     origin: false,
                     isISR: result.isISR,
+                    initialPath: result.internalEvent.rawPath,
+                    resolvedRoutes: [{ route: "/500", type: "page" }],
                 };
             }
         }

package/dist/adapters/util.js

@@ -1,6 +1,10 @@
 //TODO: We should probably move all the utils to a separate location
 export function setNodeEnv() {
-    process.env.NODE_ENV = process.env.NODE_ENV ?? "production";
+    // Note: we create a `processEnv` variable instead of just using `process.env` directly
+    //       because build tools can substitute `process.env.NODE_ENV` on build making
+    //       assignments such as `process.env.NODE_ENV = ...` problematic
+    const processEnv = process.env;
+    processEnv.NODE_ENV = process.env.NODE_ENV ?? "production";
 }
 export function generateUniqueId() {
     return Math.random().toString(36).slice(2, 8);

package/dist/build/createAssets.js

@@ -109,10 +109,29 @@ export function createCacheAssets(options) {
         };
         fs.writeFileSync(cacheFilePath, JSON.stringify(cacheFileContent));
     });
+    // We need to traverse the cache to find every .meta file
+    const metaFiles = [];
+    // Copy fetch-cache to cache folder
+    const fetchCachePath = path.join(appBuildOutputPath, ".next/cache/fetch-cache");
+    if (fs.existsSync(fetchCachePath)) {
+        const fetchOutputPath = path.join(outputDir, "cache", "__fetch", buildId);
+        fs.mkdirSync(fetchOutputPath, { recursive: true });
+        fs.cpSync(fetchCachePath, fetchOutputPath, { recursive: true });
+        buildHelper.traverseFiles(fetchCachePath, () => true, ({ absolutePath, relativePath }) => {
+            const fileContent = fs.readFileSync(absolutePath, "utf8");
+            const fileData = JSON.parse(fileContent);
+            fileData?.tags?.forEach((tag) => {
+                metaFiles.push({
+                    tag: { S: path.posix.join(buildId, tag) },
+                    path: {
+                        S: path.posix.join(buildId, relativePath),
+                    },
+                    revalidatedAt: { N: "1" },
+                });
+            });
+        });
+    }
     if (!options.config.dangerous?.disableTagCache) {
-        // Generate dynamodb data
-        // We need to traverse the cache to find every .meta file
-        const metaFiles = [];
         // Compute dynamodb cache data
         // Traverse files inside cache to find all meta files and cache tags associated with them
         buildHelper.traverseFiles(outputPath, ({ absolutePath }) => absolutePath.endsWith(".meta"), ({ absolutePath, relativePath }) => {
@@ -134,26 +153,6 @@ export function createCacheAssets(options) {
                 });
             }
         });
-        // Copy fetch-cache to cache folder
-        const fetchCachePath = path.join(appBuildOutputPath, ".next/cache/fetch-cache");
-        if (fs.existsSync(fetchCachePath)) {
-            const fetchOutputPath = path.join(outputDir, "cache", "__fetch", buildId);
-            fs.mkdirSync(fetchOutputPath, { recursive: true });
-            fs.cpSync(fetchCachePath, fetchOutputPath, { recursive: true });
-            buildHelper.traverseFiles(fetchCachePath, () => true, ({ absolutePath, relativePath }) => {
-                const fileContent = fs.readFileSync(absolutePath, "utf8");
-                const fileData = JSON.parse(fileContent);
-                fileData?.tags?.forEach((tag) => {
-                    metaFiles.push({
-                        tag: { S: path.posix.join(buildId, tag) },
-                        path: {
-                            S: path.posix.join(buildId, relativePath),
-                        },
-                        revalidatedAt: { N: "1" },
-                    });
-                });
-            });
-        }
         if (metaFiles.length > 0) {
             useTagCache = true;
             const providerPath = path.join(outputDir, "dynamodb-provider");

package/dist/build/createImageOptimizationBundle.js

@@ -4,6 +4,7 @@ import path from "node:path";
 import logger from "../logger.js";
 import { openNextReplacementPlugin } from "../plugins/replacement.js";
 import { openNextResolvePlugin } from "../plugins/resolve.js";
+import { getCrossPlatformPathRegex } from "../utils/regex.js";
 import * as buildHelper from "./helper.js";
 import { installDependencies } from "./installDeps.js";
 const require = createRequire(import.meta.url);
@@ -28,7 +29,7 @@ export async function createImageOptimizationBundle(options) {
     if (buildHelper.compareSemver(options.nextVersion, "14.1.1") >= 0) {
         plugins.push(openNextReplacementPlugin({
             name: "opennext-14.1.1-image-optimization",
-            target: /plugins(\/|\\)image-optimization(\/|\\)image-optimization\.js/g,
+            target: getCrossPlatformPathRegex("plugins/image-optimization/image-optimization.js"),
             replacements: [
                 require.resolve("../adapters/plugins/image-optimization/image-optimization.replacement.js"),
             ],

package/dist/build/createServerBundle.js

@@ -4,6 +4,7 @@ import logger from "../logger.js";
 import { minifyAll } from "../minimize-js.js";
 import { openNextReplacementPlugin } from "../plugins/replacement.js";
 import { openNextResolvePlugin } from "../plugins/resolve.js";
+import { getCrossPlatformPathRegex } from "../utils/regex.js";
 import { bundleNextServer } from "./bundleNextServer.js";
 import { compileCache } from "./compileCache.js";
 import { copyTracedFiles } from "./copyTracedFiles.js";
@@ -114,7 +115,7 @@ async function generateBundle(name, options, fnOptions) {
     const plugins = [
         openNextReplacementPlugin({
             name: `requestHandlerOverride ${name}`,
-            target: /core(\/|\\)requestHandler\.js/g,
+            target: getCrossPlatformPathRegex("core/requestHandler.js"),
             deletes: [
                 ...(disableNextPrebundledReact ? ["applyNextjsPrebundledReact"] : []),
                 ...(disableRouting ? ["withRouting"] : []),
@@ -122,11 +123,10 @@ async function generateBundle(name, options, fnOptions) {
         }),
         openNextReplacementPlugin({
             name: `utilOverride ${name}`,
-            target: /core(\/|\\)util\.js/g,
+            target: getCrossPlatformPathRegex("core/util.js"),
             deletes: [
                 ...(disableNextPrebundledReact ? ["requireHooks"] : []),
-                ...(disableRouting ? ["trustHostHeader"] : []),
-                ...(!isBefore13413 ? ["requestHandlerHost"] : []),
+                ...(isBefore13413 ? ["trustHostHeader"] : ["requestHandlerHost"]),
                 ...(isAfter141
                     ? ["experimentalIncrementalCacheHandler"]
                     : ["stableIncrementalCache"]),

package/dist/build/edge/createEdgeBundle.d.ts

@@ -2,14 +2,15 @@ import type { MiddlewareInfo } from "../../types/next-types";
 import type { IncludedConverter, IncludedOriginResolver, LazyLoadedOverride, OverrideOptions, SplittedFunctionOptions } from "../../types/open-next";
 import type { OriginResolver } from "../../types/overrides.js";
 import { type BuildOptions } from "../helper.js";
+type Override = OverrideOptions & {
+    originResolver?: LazyLoadedOverride<OriginResolver> | IncludedOriginResolver;
+};
 interface BuildEdgeBundleOptions {
     middlewareInfo?: MiddlewareInfo;
     entrypoint: string;
     outfile: string;
     options: BuildOptions;
-    overrides?: OverrideOptions & {
-        originResolver?: LazyLoadedOverride<OriginResolver> | IncludedOriginResolver;
-    };
+    overrides?: Override;
     defaultConverter?: IncludedConverter;
     additionalInject?: string;
     includeCache?: boolean;

package/dist/build/edge/createEdgeBundle.js

@@ -6,10 +6,16 @@ import logger from "../../logger.js";
 import { openNextEdgePlugins } from "../../plugins/edge.js";
 import { openNextReplacementPlugin } from "../../plugins/replacement.js";
 import { openNextResolvePlugin } from "../../plugins/resolve.js";
+import { getCrossPlatformPathRegex } from "../../utils/regex.js";
 import { isEdgeRuntime } from "../helper.js";
 import { copyOpenNextConfig, esbuildAsync } from "../helper.js";
 export async function buildEdgeBundle({ middlewareInfo, entrypoint, outfile, options, defaultConverter, overrides, additionalInject, includeCache, additionalExternals, onlyBuildOnce, name, }) {
     const isInCloudfare = await isEdgeRuntime(overrides);
+    function override(target) {
+        return typeof overrides?.[target] === "string"
+            ? overrides[target]
+            : undefined;
+    }
     await esbuildAsync({
         entryPoints: [entrypoint],
         bundle: true,
@@ -20,37 +26,23 @@ export async function buildEdgeBundle({ middlewareInfo, entrypoint, outfile, opt
         plugins: [
             openNextResolvePlugin({
                 overrides: {
-                    wrapper: typeof overrides?.wrapper === "string"
-                        ? overrides.wrapper
-                        : "aws-lambda",
-                    converter: typeof overrides?.converter === "string"
-                        ? overrides.converter
-                        : defaultConverter,
+                    wrapper: override("wrapper") ?? "aws-lambda",
+                    converter: override("converter") ?? defaultConverter,
                     ...(includeCache
                         ? {
-                            tagCache: typeof overrides?.tagCache === "string"
-                                ? overrides.tagCache
-                                : "dynamodb-lite",
-                            incrementalCache: typeof overrides?.incrementalCache === "string"
-                                ? overrides.incrementalCache
-                                : "s3-lite",
-                            queue: typeof overrides?.queue === "string"
-                                ? overrides.queue
-                                : "sqs-lite",
+                            tagCache: override("tagCache") ?? "dynamodb-lite",
+                            incrementalCache: override("incrementalCache") ?? "s3-lite",
+                            queue: override("queue") ?? "sqs-lite",
                         }
                         : {}),
-                    originResolver: typeof overrides?.originResolver === "string"
-                        ? overrides.originResolver
-                        : "pattern-env",
-                    proxyExternalRequest: typeof overrides?.proxyExternalRequest === "string"
-                        ? overrides.proxyExternalRequest
-                        : "node",
+                    originResolver: override("originResolver") ?? "pattern-env",
+                    proxyExternalRequest: override("proxyExternalRequest") ?? "node",
                 },
                 fnName: name,
             }),
             openNextReplacementPlugin({
                 name: "externalMiddlewareOverrides",
-                target: /adapters(\/|\\)middleware\.js/g,
+                target: getCrossPlatformPathRegex("adapters/middleware.js"),
                 deletes: includeCache ? [] : ["includeCacheInMiddleware"],
             }),
             openNextEdgePlugins({

package/dist/build/validateConfig.js

@@ -11,7 +11,8 @@ const compatibilityMatrix = {
     "cloudflare-edge": ["edge"],
     "cloudflare-node": ["edge"],
     node: ["node"],
-    dummy: [],
+    "express-dev": ["node"],
+    dummy: ["dummy"],
 };
 function validateFunctionOptions(fnOptions) {
     if (fnOptions.runtime === "edge" && fnOptions.experimentalBundledNextServer) {

package/dist/core/createMainHandler.js

@@ -1,7 +1,7 @@
 import { debug } from "../adapters/logger";
 import { generateUniqueId } from "../adapters/util";
 import { openNextHandler } from "./requestHandler";
-import { resolveConverter, resolveIncrementalCache, resolveProxyRequest, resolveQueue, resolveTagCache, resolveWrapper, } from "./resolve";
+import { resolveCdnInvalidation, resolveConverter, resolveIncrementalCache, resolveProxyRequest, resolveQueue, resolveTagCache, resolveWrapper, } from "./resolve";
 export async function createMainHandler() {
     // @ts-expect-error `./open-next.config.mjs` exists only in the build output
     const config = await import("./open-next.config.mjs").then((m) => m.default);
@@ -15,6 +15,7 @@ export async function createMainHandler() {
     globalThis.incrementalCache = await resolveIncrementalCache(thisFunction.override?.incrementalCache);
     globalThis.tagCache = await resolveTagCache(thisFunction.override?.tagCache);
     globalThis.proxyExternalRequest = await resolveProxyRequest(thisFunction.override?.proxyExternalRequest);
+    globalThis.cdnInvalidationHandler = await resolveCdnInvalidation(thisFunction.override?.cdnInvalidation);
     globalThis.lastModified = {};
     // From the config, we create the converter
     const converter = await resolveConverter(thisFunction.override?.converter);

package/dist/core/requestHandler.js

@@ -4,23 +4,32 @@ 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);
+        // 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 {
@@ -65,13 +74,22 @@ export async function openNextHandler(internalEvent, responseStreaming) {
                     isExternalRewrite: false,
                     isISR: false,
                     origin: false,
+                    initialPath: internalEvent.rawPath,
+                    resolvedRoutes: [{ route: "/500", type: "page" }],
                 };
             }
         }
         if ("type" in routingResult) {
             // response is used only in the streaming case
             if (responseStreaming) {
-                const response = createServerResponse(internalEvent, headers, responseStreaming);
+                const response = createServerResponse({
+                    internalEvent,
+                    isExternalRewrite: false,
+                    isISR: false,
+                    resolvedRoutes: [],
+                    origin: false,
+                    initialPath: internalEvent.rawPath,
+                }, headers, responseStreaming);
                 response.statusCode = routingResult.statusCode;
                 response.flushHeaders();
                 const [bodyToConsume, bodyToReturn] = routingResult.body.tee();
@@ -106,7 +124,7 @@ export async function openNextHandler(internalEvent, responseStreaming) {
             store.mergeHeadersPriority = mergeHeadersPriority;
         }
         const req = new IncomingMessage(reqProps);
-        const res = createServerResponse(preprocessedEvent, overwrittenResponseHeaders, responseStreaming);
+        const res = createServerResponse(routingResult, overwrittenResponseHeaders, responseStreaming);
         await processRequest(req, res, preprocessedEvent);
         const { statusCode, headers: responseHeaders, isBase64Encoded, body, } = convertRes(res);
         const internalResult = {

package/dist/core/resolve.d.ts

@@ -43,4 +43,8 @@ export declare function resolveWarmerInvoke(warmer: RemoveUndefined<OpenNextConf
  * @__PURE__
  */
 export declare function resolveProxyRequest(proxyRequest: OverrideOptions["proxyExternalRequest"]): Promise<import("../types/overrides").ProxyExternalRequest>;
+/**
+ * @__PURE__
+ */
+export declare function resolveCdnInvalidation(cdnInvalidation: OverrideOptions["cdnInvalidation"]): Promise<import("../types/overrides").CDNInvalidationHandler>;
 export {};

package/dist/core/resolve.js

@@ -98,3 +98,13 @@ export async function resolveProxyRequest(proxyRequest) {
     const m_1 = await import("../overrides/proxyExternalRequest/node.js");
     return m_1.default;
 }
+/**
+ * @__PURE__
+ */
+export async function resolveCdnInvalidation(cdnInvalidation) {
+    if (typeof cdnInvalidation === "function") {
+        return cdnInvalidation();
+    }
+    const m_1 = await import("../overrides/cdnInvalidation/dummy.js");
+    return m_1.default;
+}

package/dist/core/routing/middleware.js

@@ -44,7 +44,9 @@ export async function handleMiddleware(internalEvent, middlewareLoader = default
     const result = await middleware.default({
         // `geo` is pre Next 15.
         geo: {
-            city: headers["x-open-next-city"],
+            // The city name is percent-encoded.
+            // See https://github.com/vercel/vercel/blob/4cb6143/packages/functions/src/headers.ts#L94C19-L94C37
+            city: decodeURIComponent(headers["x-open-next-city"]),
             country: headers["x-open-next-country"],
             region: headers["x-open-next-region"],
             latitude: headers["x-open-next-latitude"],

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

@@ -2,7 +2,7 @@ import type { OutgoingHttpHeaders } from "node:http";
 import type { IncomingMessage } from "../../http/index.js";
 import { OpenNextNodeResponse } from "../../http/openNextResponse.js";
 import type { MiddlewareManifest } from "../../types/next-types";
-import type { InternalEvent, InternalResult, StreamCreator } from "../../types/open-next.js";
+import type { InternalEvent, InternalResult, RoutingResult, 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__
@@ -90,4 +90,5 @@ export declare function fixISRHeaders(headers: OutgoingHttpHeaders): void;
  * @returns
  * @__PURE__
  */
-export declare function createServerResponse(internalEvent: InternalEvent, headers: Record<string, string | string[] | undefined>, responseStream?: StreamCreator): OpenNextNodeResponse;
+export declare function createServerResponse(routingResult: RoutingResult, headers: Record<string, string | string[] | undefined>, responseStream?: StreamCreator): OpenNextNodeResponse;
+export declare function invalidateCDNOnRequest(params: RoutingResult, headers: OutgoingHttpHeaders): Promise<void>;