@opennextjs/aws 3.4.2 → 3.5.1

package/dist/build/createServerBundle.js

@@ -100,7 +100,13 @@ async function generateBundle(name, options, fnOptions) {
     // Copy env files
     buildHelper.copyEnvFile(appBuildOutputPath, packagePath, outputPath);
     // Copy all necessary traced files
-    await copyTracedFiles(appBuildOutputPath, packagePath, outputPath, fnOptions.routes ?? ["app/page.tsx"], isBundled);
+    await copyTracedFiles({
+        buildOutputPath: appBuildOutputPath,
+        packagePath,
+        outputDir: outputPath,
+        routes: fnOptions.routes ?? ["app/page.tsx"],
+        bundledNextServer: isBundled,
+    });
     // Build Lambda code
     // note: bundle in OpenNext package b/c the adapter relies on the
     //       "serverless-http" package which is not a dependency in user's

package/dist/build/edge/createEdgeBundle.js

@@ -2,8 +2,10 @@ import { mkdirSync } from "node:fs";
 import fs from "node:fs";
 import path from "node:path";
 import { build } from "esbuild";
+import { loadMiddlewareManifest } from "../../adapters/config/util.js";
 import logger from "../../logger.js";
 import { openNextEdgePlugins } from "../../plugins/edge.js";
+import { openNextExternalMiddlewarePlugin } from "../../plugins/externalMiddleware.js";
 import { openNextReplacementPlugin } from "../../plugins/replacement.js";
 import { openNextResolvePlugin } from "../../plugins/resolve.js";
 import { getCrossPlatformPathRegex } from "../../utils/regex.js";
@@ -45,10 +47,10 @@ export async function buildEdgeBundle({ middlewareInfo, entrypoint, outfile, opt
                 target: getCrossPlatformPathRegex("adapters/middleware.js"),
                 deletes: includeCache ? [] : ["includeCacheInMiddleware"],
             }),
+            openNextExternalMiddlewarePlugin(path.join(options.openNextDistDir, "core/edgeFunctionHandler.js")),
             openNextEdgePlugins({
                 middlewareInfo,
                 nextDir: path.join(options.appBuildOutputPath, ".next"),
-                edgeFunctionHandlerPath: path.join(options.openNextDistDir, "core", "edgeFunctionHandler.js"),
                 isInCloudfare,
             }),
         ],
@@ -116,15 +118,15 @@ Object.defineProperty = function(o, p, a) {
     }
 }
 export async function generateEdgeBundle(name, options, fnOptions) {
-    const { appBuildOutputPath, outputDir } = options;
     logger.info(`Generating edge bundle for: ${name}`);
+    const buildOutputDotNextDir = path.join(options.appBuildOutputPath, ".next");
     // Create output folder
-    const outputPath = path.join(outputDir, "server-functions", name);
-    fs.mkdirSync(outputPath, { recursive: true });
+    const outputDir = path.join(options.outputDir, "server-functions", name);
+    fs.mkdirSync(outputDir, { recursive: true });
     // Copy open-next.config.mjs
-    copyOpenNextConfig(options.buildDir, outputPath, true);
+    copyOpenNextConfig(options.buildDir, outputDir, true);
     // Load middleware manifest
-    const middlewareManifest = JSON.parse(fs.readFileSync(path.join(appBuildOutputPath, ".next/server/middleware-manifest.json"), "utf8"));
+    const middlewareManifest = loadMiddlewareManifest(buildOutputDotNextDir);
     // Find functions
     const functions = Object.values(middlewareManifest.functions).filter((fn) => fnOptions.routes.includes(fn.name));
     if (functions.length > 1) {
@@ -133,20 +135,20 @@ export async function generateEdgeBundle(name, options, fnOptions) {
     const middlewareInfo = functions[0];
     //Copy wasm files
     const wasmFiles = middlewareInfo.wasm;
-    mkdirSync(path.join(outputPath, "wasm"), { recursive: true });
+    mkdirSync(path.join(outputDir, "wasm"), { recursive: true });
     for (const wasmFile of wasmFiles) {
-        fs.copyFileSync(path.join(appBuildOutputPath, ".next", wasmFile.filePath), path.join(outputPath, `wasm/${wasmFile.name}.wasm`));
+        fs.copyFileSync(path.join(buildOutputDotNextDir, wasmFile.filePath), path.join(outputDir, `wasm/${wasmFile.name}.wasm`));
     }
     // Copy assets
     const assets = middlewareInfo.assets;
-    mkdirSync(path.join(outputPath, "assets"), { recursive: true });
+    mkdirSync(path.join(outputDir, "assets"), { recursive: true });
     for (const asset of assets) {
-        fs.copyFileSync(path.join(appBuildOutputPath, ".next", asset.filePath), path.join(outputPath, `assets/${asset.name}`));
+        fs.copyFileSync(path.join(buildOutputDotNextDir, asset.filePath), path.join(outputDir, `assets/${asset.name}`));
     }
     await buildEdgeBundle({
         middlewareInfo,
-        entrypoint: path.join(options.openNextDistDir, "adapters", "edge-adapter.js"),
-        outfile: path.join(outputPath, "index.mjs"),
+        entrypoint: path.join(options.openNextDistDir, "adapters/edge-adapter.js"),
+        outfile: path.join(outputDir, "index.mjs"),
         options,
         overrides: fnOptions.override,
         additionalExternals: options.config.edgeExternals,

package/dist/build/generateOutput.js

@@ -1,5 +1,6 @@
 import * as fs from "node:fs";
 import path from "node:path";
+import { loadConfig } from "../adapters/config/util.js";
 import { getBuildId } from "./helper.js";
 const indexHandler = "index.handler";
 async function canStream(opts) {
@@ -78,9 +79,8 @@ export async function generateOutput(options) {
         }
     });
     const defaultOriginCanstream = await canStream(config.default);
-    //Load required-server-files.json
-    const requiredServerFiles = JSON.parse(fs.readFileSync(path.join(appBuildOutputPath, ".next", "required-server-files.json"), "utf-8")).config;
-    const prefixer = prefixPattern(requiredServerFiles.basePath ?? "");
+    const nextConfig = loadConfig(path.join(appBuildOutputPath, ".next"));
+    const prefixer = prefixPattern(nextConfig.basePath ?? "");
     // First add s3 origins and image optimization
     const defaultOrigins = {
         s3: {
@@ -89,9 +89,7 @@ export async function generateOutput(options) {
             copy: [
                 {
                     from: ".open-next/assets",
-                    to: requiredServerFiles.basePath
-                        ? `_assets${requiredServerFiles.basePath}`
-                        : "_assets",
+                    to: nextConfig.basePath ? `_assets${nextConfig.basePath}` : "_assets",
                     cached: true,
                     versionedSubDir: prefixer("_next"),
                 },

package/dist/build/middleware/buildNodeMiddleware.d.ts

@@ -0,0 +1,3 @@
+import * as buildHelper from "../helper.js";
+export declare function buildExternalNodeMiddleware(options: buildHelper.BuildOptions): Promise<void>;
+export declare function buildBundledNodeMiddleware(options: buildHelper.BuildOptions): Promise<void>;

package/dist/build/middleware/buildNodeMiddleware.js

@@ -0,0 +1,97 @@
+import fs from "node:fs";
+import path from "node:path";
+import { getCrossPlatformPathRegex } from "../../utils/regex.js";
+import { openNextExternalMiddlewarePlugin } from "../../plugins/externalMiddleware.js";
+import { openNextReplacementPlugin } from "../../plugins/replacement.js";
+import { openNextResolvePlugin } from "../../plugins/resolve.js";
+import { copyTracedFiles } from "../copyTracedFiles.js";
+import * as buildHelper from "../helper.js";
+import { installDependencies } from "../installDeps.js";
+export async function buildExternalNodeMiddleware(options) {
+    const { appBuildOutputPath, config, outputDir } = options;
+    if (!config.middleware?.external) {
+        throw new Error("This function should only be called for external middleware");
+    }
+    const outputPath = path.join(outputDir, "middleware");
+    fs.mkdirSync(outputPath, { recursive: true });
+    // Copy open-next.config.mjs
+    buildHelper.copyOpenNextConfig(options.buildDir, outputPath, await buildHelper.isEdgeRuntime(config.middleware.override));
+    const overrides = {
+        ...config.middleware.override,
+        originResolver: config.middleware.originResolver,
+    };
+    const includeCache = config.dangerous?.enableCacheInterception;
+    const packagePath = buildHelper.getPackagePath(options);
+    // TODO: change this so that we don't copy unnecessary files
+    await copyTracedFiles({
+        buildOutputPath: appBuildOutputPath,
+        packagePath,
+        outputDir: outputPath,
+        routes: [],
+        bundledNextServer: false,
+        skipServerFiles: true,
+    });
+    function override(target) {
+        return typeof overrides?.[target] === "string"
+            ? overrides[target]
+            : undefined;
+    }
+    // Bundle middleware
+    await buildHelper.esbuildAsync({
+        entryPoints: [
+            path.join(options.openNextDistDir, "adapters", "middleware.js"),
+        ],
+        outfile: path.join(outputPath, "handler.mjs"),
+        external: ["./.next/*"],
+        platform: "node",
+        plugins: [
+            openNextResolvePlugin({
+                overrides: {
+                    wrapper: override("wrapper") ?? "aws-lambda",
+                    converter: override("converter") ?? "aws-cloudfront",
+                    ...(includeCache
+                        ? {
+                            tagCache: override("tagCache") ?? "dynamodb-lite",
+                            incrementalCache: override("incrementalCache") ?? "s3-lite",
+                            queue: override("queue") ?? "sqs-lite",
+                        }
+                        : {}),
+                    originResolver: override("originResolver") ?? "pattern-env",
+                    proxyExternalRequest: override("proxyExternalRequest") ?? "node",
+                },
+                fnName: "middleware",
+            }),
+            openNextReplacementPlugin({
+                name: "externalMiddlewareOverrides",
+                target: getCrossPlatformPathRegex("adapters/middleware.js"),
+                deletes: includeCache ? [] : ["includeCacheInMiddleware"],
+            }),
+            openNextExternalMiddlewarePlugin(path.join(options.openNextDistDir, "core", "nodeMiddlewareHandler.js")),
+        ],
+        banner: {
+            js: [
+                `globalThis.monorepoPackagePath = '${packagePath}';`,
+                "import process from 'node:process';",
+                "import { Buffer } from 'node:buffer';",
+                "import { AsyncLocalStorage } from 'node:async_hooks';",
+                "import { createRequire as topLevelCreateRequire } from 'module';",
+                "const require = topLevelCreateRequire(import.meta.url);",
+                "import bannerUrl from 'url';",
+                "const __dirname = bannerUrl.fileURLToPath(new URL('.', import.meta.url));",
+            ].join(""),
+        },
+    }, options);
+    // Do we need to copy or do something with env file here?
+    installDependencies(outputPath, config.middleware?.install);
+}
+export async function buildBundledNodeMiddleware(options) {
+    await buildHelper.esbuildAsync({
+        entryPoints: [
+            path.join(options.openNextDistDir, "core/nodeMiddlewareHandler.js"),
+        ],
+        external: ["./.next/*"],
+        outfile: path.join(options.buildDir, "middleware.mjs"),
+        bundle: true,
+        platform: "node",
+    }, options);
+}

package/dist/core/createMainHandler.js

@@ -16,7 +16,6 @@ export async function createMainHandler() {
     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);
     // Then we create the handler

package/dist/core/edgeFunctionHandler.js

@@ -16,7 +16,9 @@ export default async function edgeFunctionHandler(request) {
             },
         },
     });
-    await result.waitUntil;
+    globalThis.__openNextAls
+        .getStore()
+        ?.pendingPromiseRunner.add(result.waitUntil);
     const response = result.response;
     return response;
 }

package/dist/core/nodeMiddlewareHandler.d.ts

@@ -0,0 +1,4 @@
+import type { RequestData } from "../types/global";
+type EdgeRequest = Omit<RequestData, "page">;
+export default function middlewareHandler(request: EdgeRequest): Promise<Response>;
+export {};

package/dist/core/nodeMiddlewareHandler.js

@@ -0,0 +1,25 @@
+// Do we need Buffer here?
+import { Buffer } from "node:buffer";
+globalThis.Buffer = Buffer;
+// AsyncLocalStorage is needed to be defined globally
+import { AsyncLocalStorage } from "node:async_hooks";
+globalThis.AsyncLocalStorage = AsyncLocalStorage;
+let _module;
+export default async function middlewareHandler(request) {
+    if (!_module) {
+        // We use await import here so that we are sure that it is loaded after AsyncLocalStorage is defined on globalThis
+        // We need both await here, same way as in https://github.com/opennextjs/opennextjs-aws/pull/704
+        //@ts-expect-error - This file should be bundled with esbuild
+        _module = await (await import("./.next/server/middleware.js")).default;
+    }
+    const adapterFn = _module.default || _module;
+    const result = await adapterFn({
+        handler: _module.middleware || _module,
+        request: request,
+        page: "middleware",
+    });
+    globalThis.__openNextAls
+        .getStore()
+        ?.pendingPromiseRunner.add(result.waitUntil);
+    return result.response;
+}

package/dist/core/requestHandler.d.ts

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

package/dist/core/requestHandler.js

@@ -1,25 +1,29 @@
 import { AsyncLocalStorage } from "node:async_hooks";
 import { IncomingMessage } from "../http/index.js";
 import { runWithOpenNextRequestContext } from "../utils/promise";
+import { NextConfig } from "../adapters/config/index";
 import { debug, error, warn } from "../adapters/logger";
 import { patchAsyncStorage } from "./patchAsyncStorage";
-import { convertRes, createServerResponse } from "./routing/util";
-import routingHandler, { INTERNAL_HEADER_INITIAL_PATH, INTERNAL_HEADER_RESOLVED_ROUTES, MIDDLEWARE_HEADER_PREFIX, MIDDLEWARE_HEADER_PREFIX_LEN, } from "./routingHandler";
+import { constructNextUrl, convertRes, convertToQuery, createServerResponse, } from "./routing/util";
+import routingHandler, { INTERNAL_HEADER_INITIAL_URL, 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) {
+export async function openNextHandler(internalEvent, options) {
     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: initialHeaders["x-isr"] === "1" }, async () => {
+    return runWithOpenNextRequestContext({
+        isISRRevalidation: initialHeaders["x-isr"] === "1",
+        waitUntil: options?.waitUntil,
+    }, 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,
+            initialPath: initialHeaders[INTERNAL_HEADER_INITIAL_URL] ?? internalEvent.rawPath,
             resolvedRoutes: initialHeaders[INTERNAL_HEADER_RESOLVED_ROUTES]
                 ? JSON.parse(initialHeaders[INTERNAL_HEADER_RESOLVED_ROUTES])
                 : [],
@@ -29,6 +33,7 @@ export async function openNextHandler(internalEvent, responseStreaming) {
             isExternalRewrite: false,
             origin: false,
             isISR: false,
+            initialURL: internalEvent.url,
             ...internalHeaders,
         };
         //#override withRouting
@@ -65,7 +70,7 @@ export async function openNextHandler(internalEvent, responseStreaming) {
                         rawPath: "/500",
                         method: "GET",
                         headers: {},
-                        url: "/500",
+                        url: constructNextUrl(internalEvent.url, "/500"),
                         query: {},
                         cookies: {},
                         remoteAddress: "",
@@ -74,22 +79,22 @@ export async function openNextHandler(internalEvent, responseStreaming) {
                     isExternalRewrite: false,
                     isISR: false,
                     origin: false,
-                    initialPath: internalEvent.rawPath,
+                    initialURL: internalEvent.url,
                     resolvedRoutes: [{ route: "/500", type: "page" }],
                 };
             }
         }
         if ("type" in routingResult) {
             // response is used only in the streaming case
-            if (responseStreaming) {
+            if (options?.streamCreator) {
                 const response = createServerResponse({
                     internalEvent,
                     isExternalRewrite: false,
                     isISR: false,
                     resolvedRoutes: [],
                     origin: false,
-                    initialPath: internalEvent.rawPath,
-                }, headers, responseStreaming);
+                    initialURL: internalEvent.url,
+                }, headers, options.streamCreator);
                 response.statusCode = routingResult.statusCode;
                 response.flushHeaders();
                 const [bodyToConsume, bodyToReturn] = routingResult.body.tee();
@@ -103,12 +108,13 @@ export async function openNextHandler(internalEvent, responseStreaming) {
         }
         const preprocessedEvent = routingResult.internalEvent;
         debug("preprocessedEvent", preprocessedEvent);
+        const { search, pathname, hash } = new URL(preprocessedEvent.url);
         const reqProps = {
             method: preprocessedEvent.method,
-            url: preprocessedEvent.url,
+            url: `${pathname}${search}${hash}`,
             //WORKAROUND: We pass this header to the serverless function to mimic a prefetch request which will not trigger revalidation since we handle revalidation differently
             // There is 3 way we can handle revalidation:
-            // 1. We could just let the revalidation go as normal, but due to race condtions the revalidation will be unreliable
+            // 1. We could just let the revalidation go as normal, but due to race conditions the revalidation will be unreliable
             // 2. We could alter the lastModified time of our cache to make next believe that the cache is fresh, but this could cause issues with stale data since the cdn will cache the stale data as if it was fresh
             // 3. OUR CHOICE: We could pass a purpose prefetch header to the serverless function to make next believe that the request is a prefetch request and not trigger revalidation (This could potentially break in the future if next changes the behavior of prefetch requests)
             headers: { ...headers, purpose: "prefetch" },
@@ -124,8 +130,8 @@ export async function openNextHandler(internalEvent, responseStreaming) {
             store.mergeHeadersPriority = mergeHeadersPriority;
         }
         const req = new IncomingMessage(reqProps);
-        const res = createServerResponse(routingResult, overwrittenResponseHeaders, responseStreaming);
-        await processRequest(req, res, preprocessedEvent);
+        const res = createServerResponse(routingResult, overwrittenResponseHeaders, options?.streamCreator);
+        await processRequest(req, res, routingResult);
         const { statusCode, headers: responseHeaders, isBase64Encoded, body, } = convertRes(res);
         const internalResult = {
             type: internalEvent.type,
@@ -134,36 +140,56 @@ export async function openNextHandler(internalEvent, responseStreaming) {
             body,
             isBase64Encoded,
         };
-        const requestId = store?.requestId;
-        if (requestId) {
-            // reset lastModified. We need to do this to avoid memory leaks
-            delete globalThis.lastModified[requestId];
-        }
         return internalResult;
     });
 }
-async function processRequest(req, res, internalEvent) {
+async function processRequest(req, res, routingResult) {
     // @ts-ignore
     // Next.js doesn't parse body if the property exists
     // https://github.com/dougmoscrop/serverless-http/issues/227
     delete req.body;
     try {
         //#override applyNextjsPrebundledReact
-        setNextjsPrebundledReact(internalEvent.rawPath);
+        setNextjsPrebundledReact(routingResult.internalEvent.rawPath);
         //#endOverride
+        // Here we try to apply as much request metadata as possible
+        // We apply every metadata from `resolve-routes` https://github.com/vercel/next.js/blob/canary/packages/next/src/server/lib/router-utils/resolve-routes.ts
+        // and `router-server` https://github.com/vercel/next.js/blob/canary/packages/next/src/server/lib/router-server.ts
+        const initialURL = new URL(routingResult.initialURL);
+        let invokeStatus;
+        if (routingResult.internalEvent.rawPath === "/500") {
+            invokeStatus = 500;
+        }
+        else if (routingResult.internalEvent.rawPath === "/404") {
+            invokeStatus = 404;
+        }
+        const requestMetadata = {
+            isNextDataReq: routingResult.internalEvent.query.__nextDataReq === "1",
+            initURL: routingResult.initialURL,
+            initQuery: convertToQuery(initialURL.search),
+            initProtocol: initialURL.protocol,
+            defaultLocale: NextConfig.i18n?.defaultLocale,
+            locale: routingResult.locale,
+            middlewareInvoke: false,
+            // By setting invokePath and invokeQuery we can bypass some of the routing logic in Next.js
+            invokePath: routingResult.internalEvent.rawPath,
+            invokeQuery: routingResult.internalEvent.query,
+            // invokeStatus is only used for error pages
+            invokeStatus,
+        };
         // Next Server
-        await requestHandler(req, res);
+        await requestHandler(requestMetadata)(req, res);
     }
     catch (e) {
         // This might fail when using bundled next, importing won't do the trick either
         if (e.constructor.name === "NoFallbackError") {
             // Do we need to handle _not-found
             // Ideally this should never get triggered and be intercepted by the routing handler
-            await tryRenderError("404", res, internalEvent);
+            await tryRenderError("404", res, routingResult.internalEvent);
         }
         else {
             error("NextJS request failed.", e);
-            await tryRenderError("500", res, internalEvent);
+            await tryRenderError("500", res, routingResult.internalEvent);
         }
     }
 }
@@ -176,7 +202,14 @@ async function tryRenderError(type, res, internalEvent) {
             body: internalEvent.body,
             remoteAddress: internalEvent.remoteAddress,
         });
-        await requestHandler(_req, res);
+        // By setting this it will allow us to bypass and directly render the 404 or 500 page
+        const requestMetadata = {
+            // By setting invokePath and invokeQuery we can bypass some of the routing logic in Next.js
+            invokePath: type === "404" ? "/404" : "/500",
+            invokeStatus: type === "404" ? 404 : 500,
+            middlewareInvoke: false,
+        };
+        await requestHandler(requestMetadata)(_req, res);
     }
     catch (e) {
         error("NextJS request failed.", e);

package/dist/core/routing/cacheInterceptor.js

@@ -1,9 +1,10 @@
 import { createHash } from "node:crypto";
 import { NextConfig, PrerenderManifest } from "../../adapters/config/index";
 import { emptyReadableStream, toReadableStream } from "../../utils/stream";
+import { getTagsFromValue, hasBeenRevalidated } from "../../utils/cache";
 import { debug } from "../../adapters/logger";
 import { localizePath } from "./i18n";
-import { generateMessageGroupId } from "./util";
+import { generateMessageGroupId } from "./queue";
 const CACHE_ONE_YEAR = 60 * 60 * 24 * 365;
 const CACHE_ONE_MONTH = 60 * 60 * 24 * 30;
 async function computeCacheControl(path, body, host, revalidate, lastModified) {
@@ -123,11 +124,11 @@ export async function cacheInterceptor(event) {
             if (!cachedData?.value) {
                 return event;
             }
-            if (cachedData?.value?.type === "app") {
-                // We need to check the tag cache now
-                const _lastModified = await globalThis.tagCache.getLastModified(localizedPath, cachedData.lastModified);
-                if (_lastModified === -1) {
-                    // If some tags are stale we need to force revalidation
+            // We need to check the tag cache now
+            if (cachedData.value?.type === "app") {
+                const tags = getTagsFromValue(cachedData.value);
+                const _hasBeenRevalidated = await hasBeenRevalidated(localizedPath, tags, cachedData);
+                if (_hasBeenRevalidated) {
                     return event;
                 }
             }

package/dist/core/routing/i18n/index.d.ts

@@ -1,2 +1,30 @@
-import type { InternalEvent } from "../../../types/open-next";
+import type { DomainLocale, i18nConfig } from "../../../types/next-types";
+import type { InternalEvent, InternalResult } from "../../../types/open-next";
+/**
+ * @param arg an object containing the hostname and detectedLocale
+ * @returns The `DomainLocale` object if a domain is detected, `undefined` otherwise
+ */
+export declare function detectDomainLocale({ hostname, detectedLocale, }: {
+    hostname?: string;
+    detectedLocale?: string;
+}): DomainLocale | undefined;
+/**
+ *
+ * @param internalEvent
+ * @param i18n
+ * @returns The detected locale, if `localeDetection` is set to `false` it will return the default locale **or** the domain default locale if a domain is detected.
+ */
+export declare function detectLocale(internalEvent: InternalEvent, i18n: i18nConfig): string;
+/**
+ * This function is used for OpenNext internal routing to localize the path for next config rewrite/redirects/headers and the middleware
+ * @param internalEvent
+ * @returns The localized path
+ */
 export declare function localizePath(internalEvent: InternalEvent): string;
+/**
+ *
+ * @param internalEvent
+ * In this function, for domain locale redirect we need to rely on the host to be present and correct
+ * @returns `false` if no redirect is needed, `InternalResult` if a redirect is needed
+ */
+export declare function handleLocaleRedirect(internalEvent: InternalEvent): false | InternalResult;