@opennextjs/aws 3.4.2 → 3.5.0

package/dist/overrides/tagCache/dynamodb-nextMode.d.ts

@@ -0,0 +1,7 @@
+declare const _default: {
+    name: string;
+    mode: "nextMode";
+    hasBeenRevalidated: (tags: string[], lastModified?: number) => Promise<boolean>;
+    writeTags: (tags: string[]) => Promise<void>;
+};
+export default _default;

package/dist/overrides/tagCache/dynamodb-nextMode.js

@@ -0,0 +1,119 @@
+import { AwsClient } from "aws4fetch";
+import { RecoverableError } from "../../utils/error";
+import { customFetchClient } from "../../utils/fetch";
+import path from "node:path";
+import { debug, error } from "../../adapters/logger";
+import { chunk, parseNumberFromEnv } from "../../adapters/util";
+import { MAX_DYNAMO_BATCH_WRITE_ITEM_COUNT, getDynamoBatchWriteCommandConcurrency, } from "./constants";
+let awsClient = null;
+const getAwsClient = () => {
+    const { CACHE_BUCKET_REGION } = process.env;
+    if (awsClient) {
+        return awsClient;
+    }
+    awsClient = new AwsClient({
+        accessKeyId: process.env.AWS_ACCESS_KEY_ID,
+        secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
+        sessionToken: process.env.AWS_SESSION_TOKEN,
+        region: CACHE_BUCKET_REGION,
+        retries: parseNumberFromEnv(process.env.AWS_SDK_S3_MAX_ATTEMPTS),
+    });
+    return awsClient;
+};
+const awsFetch = (body, type = "query") => {
+    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 === "query" ? "BatchGetItem" : "BatchWriteItem"}`,
+        },
+        body,
+    });
+};
+function buildDynamoKey(key) {
+    const { NEXT_BUILD_ID } = process.env;
+    // FIXME: We should probably use something else than path.join here
+    // this could transform some fetch cache key into a valid path
+    return path.posix.join(NEXT_BUILD_ID ?? "", "_tag", key);
+}
+// We use the same key for both path and tag
+// That's mostly for compatibility reason so that it's easier to use this with existing infra
+// FIXME: Allow a simpler object without an unnecessary path key
+function buildDynamoObject(tag, revalidatedAt) {
+    return {
+        path: { S: buildDynamoKey(tag) },
+        tag: { S: buildDynamoKey(tag) },
+        revalidatedAt: { N: `${revalidatedAt ?? Date.now()}` },
+    };
+}
+// This implementation does not support automatic invalidation of paths by the cdn
+export default {
+    name: "ddb-nextMode",
+    mode: "nextMode",
+    hasBeenRevalidated: async (tags, lastModified) => {
+        if (globalThis.openNextConfig.dangerous?.disableTagCache) {
+            return false;
+        }
+        if (tags.length > 100) {
+            throw new RecoverableError("Cannot query more than 100 tags at once. You should not be using this tagCache implementation for this amount of tags");
+        }
+        const { CACHE_DYNAMO_TABLE } = process.env;
+        // It's unlikely that we will have more than 100 items to query
+        // If that's the case, you should not use this tagCache implementation
+        const response = await awsFetch(JSON.stringify({
+            RequestItems: {
+                [CACHE_DYNAMO_TABLE ?? ""]: {
+                    Keys: tags.map((tag) => ({
+                        path: { S: buildDynamoKey(tag) },
+                        tag: { S: buildDynamoKey(tag) },
+                    })),
+                },
+            },
+        }), "query");
+        if (response.status !== 200) {
+            throw new RecoverableError(`Failed to query dynamo item: ${response.status}`);
+        }
+        // Now we need to check for every item if lastModified is greater than the revalidatedAt
+        const { Responses } = await response.json();
+        if (!Responses) {
+            return false;
+        }
+        const revalidatedTags = Responses[CACHE_DYNAMO_TABLE ?? ""].filter((item) => Number.parseInt(item.revalidatedAt.N) > (lastModified ?? 0));
+        debug("retrieved tags", revalidatedTags);
+        return revalidatedTags.length > 0;
+    },
+    writeTags: async (tags) => {
+        try {
+            const { CACHE_DYNAMO_TABLE } = process.env;
+            if (globalThis.openNextConfig.dangerous?.disableTagCache) {
+                return;
+            }
+            const dataChunks = chunk(tags, MAX_DYNAMO_BATCH_WRITE_ITEM_COUNT).map((Items) => ({
+                RequestItems: {
+                    [CACHE_DYNAMO_TABLE ?? ""]: Items.map((tag) => ({
+                        PutRequest: {
+                            Item: {
+                                ...buildDynamoObject(tag),
+                            },
+                        },
+                    })),
+                },
+            }));
+            const toInsert = chunk(dataChunks, getDynamoBatchWriteCommandConcurrency());
+            for (const paramsChunk of toInsert) {
+                await Promise.all(paramsChunk.map(async (params) => {
+                    const response = await awsFetch(JSON.stringify(params), "batchWrite");
+                    if (response.status !== 200) {
+                        throw new RecoverableError(`Failed to batch write dynamo item: ${response.status}`);
+                    }
+                    return response;
+                }));
+            }
+        }
+        catch (e) {
+            error("Failed to batch write dynamo item", e);
+        }
+    },
+};

package/dist/overrides/tagCache/dynamodb.js

@@ -25,6 +25,7 @@ function buildDynamoObject(path, tags, revalidatedAt) {
     };
 }
 const tagCache = {
+    mode: "original",
     async getByPath(path) {
         try {
             if (globalThis.openNextConfig.dangerous?.disableTagCache) {

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

@@ -4,6 +4,7 @@ const tagContent = fs.readFileSync(tagFile, "utf-8");
 let tags = JSON.parse(tagContent);
 const tagCache = {
     name: "fs-dev",
+    mode: "original",
     getByPath: async (path) => {
         return tags
             .filter((tagPathMapping) => tagPathMapping.path.S === path)

package/dist/overrides/wrappers/aws-lambda-streaming.js

@@ -63,7 +63,7 @@ const handler = async (handler, converter) => awslambda.streamifyResponse(async
             return compressedStream ?? responseStream;
         },
     };
-    const response = await handler(internalEvent, streamCreator);
+    const response = await handler(internalEvent, { streamCreator });
     const isUsingEdge = globalThis.isEdgeRuntime ?? false;
     if (isUsingEdge) {
         debug("Headers has not been set, we must be in the edge runtime");

package/dist/overrides/wrappers/aws-lambda.js

@@ -26,7 +26,9 @@ const handler = async (handler, converter) => async (event) => {
             });
         },
     };
-    const response = await handler(internalEvent, fakeStream);
+    const response = await handler(internalEvent, {
+        streamCreator: fakeStream,
+    });
     return converter.convertTo(response, event);
 };
 export default {

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

@@ -9,7 +9,6 @@ const cfPropNameMapping = {
 };
 const handler = async (handler, converter) => async (request, env, ctx) => {
     globalThis.process = process;
-    globalThis.openNextWaitUntil = ctx.waitUntil.bind(ctx);
     // Set the environment variables
     // Cloudflare suggests to not override the process.env object but instead apply the values to it
     for (const [key, value] of Object.entries(env)) {
@@ -33,7 +32,9 @@ const handler = async (handler, converter) => async (request, env, ctx) => {
                 : propValue;
         }
     }
-    const response = await handler(internalEvent);
+    const response = await handler(internalEvent, {
+        waitUntil: ctx.waitUntil.bind(ctx),
+    });
     const result = await converter.convertTo(response);
     return result;
 };

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

@@ -3,7 +3,6 @@ import { Writable } from "node:stream";
 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);
     // Set the environment variables
     // Cloudflare suggests to not override the process.env object but instead apply the values to it
     for (const [key, value] of Object.entries(env)) {
@@ -12,12 +11,7 @@ const handler = async (handler, converter) => async (request, env, ctx) => {
         }
     }
     const internalEvent = await converter.convertFrom(request);
-    // TODO:
-    // The edge converter populate event.url with the url including the origin.
-    // This is required for middleware to keep track of the protocol (i.e. http with wrangler dev).
-    // However the server expects that the origin is not included.
-    const url = new URL(internalEvent.url);
-    internalEvent.url = url.href.slice(url.origin.length);
+    const url = new URL(request.url);
     const { promise: promiseResponse, resolve: resolveResponse } = Promise.withResolvers();
     const streamCreator = {
         writeHeaders(prelude) {
@@ -45,7 +39,10 @@ const handler = async (handler, converter) => async (request, env, ctx) => {
             return Writable.fromWeb(writable);
         },
     };
-    ctx.waitUntil(handler(internalEvent, streamCreator));
+    ctx.waitUntil(handler(internalEvent, {
+        streamCreator,
+        waitUntil: ctx.waitUntil.bind(ctx),
+    }));
     return promiseResponse;
 };
 export default {

package/dist/overrides/wrappers/dummy.js

@@ -1,6 +1,6 @@
 const dummyWrapper = async (handler, converter) => {
-    return async (event, responseStream) => {
-        return await handler(event, responseStream);
+    return async (event, options) => {
+        return await handler(event, options);
     };
 };
 export default {

package/dist/overrides/wrappers/express-dev.js

@@ -7,24 +7,24 @@ const wrapper = async (handler, converter) => {
     const imageHandler = await import(imageHandlerPath).then((m) => m.handler);
     app.all("/_next/image", async (req, res) => {
         const internalEvent = await converter.convertFrom(req);
-        const _res = {
+        const streamCreator = {
             writeHeaders: (prelude) => {
                 res.writeHead(prelude.statusCode, prelude.headers);
                 return res;
             },
         };
-        await imageHandler(internalEvent, _res);
+        await imageHandler(internalEvent, { streamCreator });
     });
     app.all("*paths", async (req, res) => {
         const internalEvent = await converter.convertFrom(req);
-        const _res = {
+        const streamCreator = {
             writeHeaders: (prelude) => {
                 res.writeHead(prelude.statusCode, prelude.headers);
                 return res;
             },
             onFinish: () => { },
         };
-        await handler(internalEvent, _res);
+        await handler(internalEvent, { streamCreator });
     });
     const server = app.listen(Number.parseInt(process.env.PORT ?? "3000", 10), () => {
         console.log(`Server running on port ${process.env.PORT ?? 3000}`);

package/dist/overrides/wrappers/node.js

@@ -3,7 +3,7 @@ import { debug, error } from "../../adapters/logger";
 const wrapper = async (handler, converter) => {
     const server = createServer(async (req, res) => {
         const internalEvent = await converter.convertFrom(req);
-        const _res = {
+        const streamCreator = {
             writeHeaders: (prelude) => {
                 res.setHeader("Set-Cookie", prelude.cookies);
                 res.writeHead(prelude.statusCode, prelude.headers);
@@ -19,7 +19,7 @@ const wrapper = async (handler, converter) => {
             res.end("OK");
         }
         else {
-            await handler(internalEvent, _res);
+            await handler(internalEvent, { streamCreator });
         }
     });
     await new Promise((resolve) => {

package/dist/plugins/edge.d.ts

@@ -2,15 +2,13 @@ import type { Plugin } from "esbuild";
 import type { MiddlewareInfo } from "../types/next-types.js";
 export interface IPluginSettings {
     nextDir: string;
-    edgeFunctionHandlerPath?: string;
     middlewareInfo?: MiddlewareInfo;
     isInCloudfare?: boolean;
 }
 /**
  * @param opts.nextDir - The path to the .next directory
- * @param opts.edgeFunctionHandlerPath - The path to the edgeFunctionHandler.js file that we'll use to bundle the routing
  * @param opts.middlewareInfo - Information about the middleware
  * @param opts.isInCloudfare - Whether the code runs on the cloudflare runtime
  * @returns
  */
-export declare function openNextEdgePlugins({ nextDir, edgeFunctionHandlerPath, middlewareInfo, isInCloudfare, }: IPluginSettings): Plugin;
+export declare function openNextEdgePlugins({ nextDir, middlewareInfo, isInCloudfare, }: IPluginSettings): Plugin;

package/dist/plugins/edge.js

@@ -1,17 +1,16 @@
 import { readFileSync } from "node:fs";
 import path from "node:path";
 import chalk from "chalk";
-import { loadAppPathRoutesManifest, loadAppPathsManifest, loadAppPathsManifestKeys, loadBuildId, loadConfig, loadConfigHeaders, loadHtmlPages, loadMiddlewareManifest, loadPrerenderManifest, loadRoutesManifest, } from "../adapters/config/util.js";
+import { loadAppPathRoutesManifest, loadAppPathsManifest, loadAppPathsManifestKeys, loadBuildId, loadConfig, loadConfigHeaders, loadFunctionsConfigManifest, loadHtmlPages, loadMiddlewareManifest, loadPrerenderManifest, loadRoutesManifest, } from "../adapters/config/util.js";
 import logger from "../logger.js";
 import { getCrossPlatformPathRegex } from "../utils/regex.js";
 /**
  * @param opts.nextDir - The path to the .next directory
- * @param opts.edgeFunctionHandlerPath - The path to the edgeFunctionHandler.js file that we'll use to bundle the routing
  * @param opts.middlewareInfo - Information about the middleware
  * @param opts.isInCloudfare - Whether the code runs on the cloudflare runtime
  * @returns
  */
-export function openNextEdgePlugins({ nextDir, edgeFunctionHandlerPath, middlewareInfo, isInCloudfare, }) {
+export function openNextEdgePlugins({ nextDir, middlewareInfo, isInCloudfare, }) {
     const entryFiles = middlewareInfo?.files.map((file) => path.join(nextDir, file)) ?? [];
     const routes = middlewareInfo
         ? [
@@ -27,14 +26,6 @@ export function openNextEdgePlugins({ nextDir, edgeFunctionHandlerPath, middlewa
         name: "opennext-edge",
         setup(build) {
             logger.debug(chalk.blue("OpenNext Edge plugin"));
-            if (edgeFunctionHandlerPath) {
-                // If we bundle the routing, we need to resolve the middleware
-                build.onResolve({ filter: getCrossPlatformPathRegex("./middleware.mjs") }, () => {
-                    return {
-                        path: edgeFunctionHandlerPath,
-                    };
-                });
-            }
             build.onResolve({ filter: /\.(mjs|wasm)$/g }, () => {
                 return {
                     external: true,
@@ -129,6 +120,7 @@ ${contents}
                 const MiddlewareManifest = loadMiddlewareManifest(nextDir);
                 const AppPathsManifest = loadAppPathsManifest(nextDir);
                 const AppPathRoutesManifest = loadAppPathRoutesManifest(nextDir);
+                const FunctionsConfigManifest = loadFunctionsConfigManifest(nextDir);
                 const contents = `
   import path from "node:path";
 
@@ -151,6 +143,7 @@ ${contents}
   export const MiddlewareManifest = ${JSON.stringify(MiddlewareManifest)};
   export const AppPathsManifest = ${JSON.stringify(AppPathsManifest)};
   export const AppPathRoutesManifest = ${JSON.stringify(AppPathRoutesManifest)};
+  export const FunctionsConfigManifest = ${JSON.stringify(FunctionsConfigManifest)};
 
 
   process.env.NEXT_BUILD_ID = BuildId;

package/dist/plugins/externalMiddleware.d.ts

@@ -0,0 +1,2 @@
+import type { Plugin } from "esbuild";
+export declare function openNextExternalMiddlewarePlugin(functionPath: string): Plugin;

package/dist/plugins/externalMiddleware.js

@@ -0,0 +1,10 @@
+import { getCrossPlatformPathRegex } from "../utils/regex.js";
+export function openNextExternalMiddlewarePlugin(functionPath) {
+    return {
+        name: "open-next-external-node-middleware",
+        setup(build) {
+            // If we bundle the routing, we need to resolve the middleware
+            build.onResolve({ filter: getCrossPlatformPathRegex("./middleware.mjs") }, () => ({ path: functionPath }));
+        },
+    };
+}

package/dist/plugins/resolve.js

@@ -1,4 +1,4 @@
-import { readFileSync } from "node:fs";
+import { readFile } from "node:fs/promises";
 import chalk from "chalk";
 import logger from "../logger.js";
 import { getCrossPlatformPathRegex } from "../utils/regex.js";
@@ -44,7 +44,7 @@ export function openNextResolvePlugin({ overrides, fnName, }) {
         setup(build) {
             logger.debug(chalk.blue("OpenNext Resolve plugin"), fnName ? `for ${fnName}` : "");
             build.onLoad({ filter: getCrossPlatformPathRegex("core/resolve.js") }, async (args) => {
-                let contents = readFileSync(args.path, "utf-8");
+                let contents = await readFile(args.path, "utf-8");
                 const overridesEntries = Object.entries(overrides ?? {});
                 for (let [overrideName, overrideValue] of overridesEntries) {
                     if (!overrideValue) {

package/dist/types/cache.d.ts

@@ -16,7 +16,7 @@ interface CachedRedirectValue {
     props: Object;
 }
 interface CachedRouteValue {
-    kind: "ROUTE";
+    kind: "ROUTE" | "APP_ROUTE";
     body: Buffer;
     status: number;
     headers: Record<string, undefined | string | string[]>;
@@ -30,13 +30,21 @@ interface CachedImageValue {
     isStale?: boolean;
 }
 interface IncrementalCachedPageValue {
-    kind: "PAGE";
+    kind: "PAGE" | "PAGES";
     html: string;
     pageData: Object;
     status?: number;
     headers?: Record<string, undefined | string>;
 }
-type IncrementalCacheValue = CachedRedirectValue | IncrementalCachedPageValue | CachedImageValue | CachedFetchValue | CachedRouteValue;
+interface IncrementalCachedAppPageValue {
+    kind: "APP_PAGE";
+    html: string;
+    rscData: Buffer;
+    headers?: Record<string, undefined | string | string[]>;
+    postponed?: string;
+    status?: number;
+}
+export type IncrementalCacheValue = CachedRedirectValue | IncrementalCachedPageValue | IncrementalCachedAppPageValue | CachedImageValue | CachedFetchValue | CachedRouteValue;
 export interface CacheHandlerContext {
     fs?: never;
     dev?: boolean;
@@ -54,9 +62,31 @@ export interface CacheHandlerValue {
     value: IncrementalCacheValue | null;
 }
 export type Extension = "cache" | "fetch";
+type MetaHeaders = {
+    "x-next-cache-tags"?: string;
+    [k: string]: string | string[] | undefined;
+};
 export interface Meta {
     status?: number;
-    headers?: Record<string, undefined | string | string[]>;
+    headers?: MetaHeaders;
     postponed?: string;
 }
+export type TagCacheMetaFile = {
+    tag: {
+        S: string;
+    };
+    path: {
+        S: string;
+    };
+    revalidatedAt: {
+        N: string;
+    };
+};
+export type IncrementalCacheContext = {
+    revalidate?: number | false | undefined;
+    fetchCache?: boolean | undefined;
+    fetchUrl?: string | undefined;
+    fetchIdx?: number | undefined;
+    tags?: string[] | undefined;
+};
 export {};

package/dist/types/global.d.ts

@@ -2,7 +2,7 @@ import type { AsyncLocalStorage } from "node:async_hooks";
 import type { OutgoingHttpHeaders } from "node:http";
 import type { CDNInvalidationHandler, IncrementalCache, ProxyExternalRequest, Queue, TagCache } from "./overrides";
 import type { DetachedPromiseRunner } from "../utils/promise";
-import type { OpenNextConfig } from "./open-next";
+import type { OpenNextConfig, WaitUntil } from "./open-next";
 export interface RequestData {
     geo?: {
         city?: string;
@@ -51,20 +51,28 @@ interface OpenNextRequestContext {
     pendingPromiseRunner: DetachedPromiseRunner;
     isISRRevalidation?: boolean;
     mergeHeadersPriority?: "middleware" | "handler";
+    lastModified?: number;
+    waitUntil?: WaitUntil;
 }
 declare global {
     /**
      * The cache adapter for incremental static regeneration.
-     * Only available in main functions or in the external middleware with `enableCacheInterception` set to `true`.
-     * Defined in `createMainHandler` or in `adapter/middleware.ts`.
+     * Only available in main functions and in the external middleware when `enableCacheInterception` is `true`.
+     * Defined in `createMainHandler` and in `adapters/middleware.ts`.
      */
     var incrementalCache: IncrementalCache;
     /**
      * The cache adapter for the tag cache.
-     * Only available in main functions, the initializationFunction or in the external middleware with `enableCacheInterception` set to `true`.
-     * Defined in `createMainHandler` or in `adapter/middleware.ts`.
+     * Only available in main functions and in the external middleware when `enableCacheInterception` is `true`.
+     * Defined in `createMainHandler` and in `adapters/middleware.ts`.
      */
     var tagCache: TagCache;
+    /**
+     * The queue that is used to handle ISR revalidation requests.
+     * Only available in main functions and in the external middleware when `enableCacheInterception` is `true`.
+     * Defined in `createMainHandler` and in `adapters/middleware.ts`.
+     */
+    var queue: Queue;
     /**
      * A boolean that indicates if the DynamoDB cache is disabled.
      * @deprecated This will be removed, use `globalThis.openNextConfig.dangerous?.disableTagCache` instead.
@@ -77,13 +85,6 @@ declare global {
      * Defined in esbuild banner for the cache adapter.
      */
     var disableIncrementalCache: boolean;
-    /**
-     * An object that contains the last modified time of the pages.
-     * Only available in main functions.
-     * TODO: Integrate this directly in the AsyncLocalStorage context
-     * Defined in `createMainHandler`.
-     */
-    var lastModified: Record<string, number>;
     /**
      * A boolean that indicates if Next is V15 or higher.
      * Only available in the cache adapter.
@@ -93,7 +94,7 @@ declare global {
     /**
      * A boolean that indicates if the runtime is Edge.
      * Only available in `edge` runtime functions (i.e. external middleware or function with edge runtime).
-     * Defined in the `edge-adapter.ts`.
+     * Defined in `adapters/edge-adapter.ts`.
      */
     var isEdgeRuntime: true;
     /**
@@ -105,40 +106,33 @@ declare global {
     /**
      * The fetch function that should be used to make requests during the execution of the function.
      * Used to bypass Next intercepting and caching the fetch calls. Only available in main functions.
-     * Defined in the `server-adapter.ts` and in `adapters/middleware.ts`.
+     * Defined in `adapters/server-adapter.ts` and in `adapters/middleware.ts`.
      */
     var internalFetch: typeof fetch;
     /**
      * The Open Next configuration object.
      * Available in all functions.
-     * Defined in the `createMainHandler` or in the `createGenericHandler`.
+     * Defined in `createMainHandler` and in the `createGenericHandler`.
      */
     var openNextConfig: Partial<OpenNextConfig>;
     /**
      * The name of the function that is currently being executed.
      * Only available in main functions.
-     * Defined in the `createMainHandler`.
+     * Defined in `createMainHandler`.
      */
     var fnName: string | undefined;
     /**
      * The unique identifier of the server.
      * Only available in main functions.
-     * Defined in the `createMainHandler`.
+     * Defined in `createMainHandler`.
      */
     var serverId: string;
     /**
      * The AsyncLocalStorage instance that is used to store the request context.
      * Only available in main, middleware and edge functions.
-     * TODO: should be available everywhere in the future.
-     * Defined in `requestHandler.ts`, `middleware.ts` and `edge-adapter.ts`.
+     * Defined in `requestHandler.ts`, `adapters/middleware.ts` and `adapters/edge-adapter.ts`.
      */
     var __openNextAls: AsyncLocalStorage<OpenNextRequestContext>;
-    /**
-     * The function that is used to run background tasks even after the response has been sent.
-     * This one is defined by the wrapper function as most of them don't need or support this feature.
-     * If not present, all the awaiting promises will be resolved before sending the response.
-     */
-    var openNextWaitUntil: ((promise: Promise<void>) => void) | undefined;
     /**
      * The entries object that contains the functions that are available in the function.
      * Only available in edge runtime functions.
@@ -173,12 +167,6 @@ declare global {
      * Defined in the esbuild banner.
      */
     var openNextVersion: string;
-    /**
-     * The queue that is used to handle ISR revalidation requests.
-     * Only available in main functions and in the external middleware with `enableCacheInterception` set to `true`.
-     * Defined in `createMainHandler` or in `adapter/middleware.ts`.
-     */
-    var queue: Queue;
     /**
      * The function that is used when resolving external rewrite requests.
      * Only available in main functions

package/dist/types/next-types.d.ts

@@ -152,4 +152,17 @@ export type Options = {
     isExternalRewrite?: boolean;
 };
 export type PluginHandler = (req: IncomingMessage, res: OpenNextNodeResponse, options: Options) => Promise<OpenNextNodeResponse | undefined>;
+export interface FunctionsConfigManifest {
+    version: number;
+    functions: Record<string, {
+        maxDuration?: number | undefined;
+        runtime?: "nodejs";
+        matchers?: Array<{
+            regexp: string;
+            originalSource: string;
+            has?: Rewrite["has"];
+            missing?: Rewrite["has"];
+        }>;
+    }>;
+}
 export {};

package/dist/types/open-next.d.ts

@@ -30,6 +30,7 @@ export interface StreamCreator {
     onWrite?: () => void;
     onFinish?: (length: number) => void;
 }
+export type WaitUntil = (promise: Promise<void>) => void;
 export interface DangerousOptions {
     /**
      * The tag cache is used for revalidateTags and revalidatePath.
@@ -59,7 +60,7 @@ export interface DangerousOptions {
 export type BaseOverride = {
     name: string;
 };
-export type LazyLoadedOverride<T extends BaseOverride> = () => Promise<T>;
+export type LazyLoadedOverride<T extends BaseOverride> = () => T | Promise<T>;
 export interface Origin {
     host: string;
     protocol: "http" | "https";
@@ -78,15 +79,16 @@ export interface RoutingResult {
     isExternalRewrite: boolean;
     origin: Origin | false;
     isISR: boolean;
-    initialPath: string;
+    initialURL: string;
+    locale?: string;
     resolvedRoutes: ResolvedRoute[];
 }
 export interface MiddlewareResult extends RoutingResult, BaseEventOrResult<"middleware"> {
 }
 export type IncludedQueue = "sqs" | "sqs-lite" | "direct" | "dummy";
 export type IncludedIncrementalCache = "s3" | "s3-lite" | "multi-tier-ddb-s3" | "fs-dev" | "dummy";
-export type IncludedTagCache = "dynamodb" | "dynamodb-lite" | "fs-dev" | "dummy";
-export type IncludedImageLoader = "s3" | "host" | "fs-dev" | "dummy";
+export type IncludedTagCache = "dynamodb" | "dynamodb-lite" | "dynamodb-nextMode" | "fs-dev" | "dummy";
+export type IncludedImageLoader = "s3" | "s3-lite" | "host" | "fs-dev" | "dummy";
 export type IncludedOriginResolver = "pattern-env" | "dummy";
 export type IncludedWarmer = "aws-lambda" | "dummy";
 export type IncludedProxyExternalRequest = "node" | "fetch" | "dummy";
@@ -241,6 +243,11 @@ export interface OpenNextConfig {
      */
     middleware?: DefaultFunctionOptions & {
         external: true;
+        /**
+         * The runtime used by next for the middleware.
+         * @default "edge"
+         */
+        runtime?: "node" | "edge";
         /**
          * The override options for the middleware.
          * By default the lite override are used (.i.e. s3-lite, dynamodb-lite, sqs-lite)
@@ -295,7 +302,7 @@ export interface OpenNextConfig {
      * Supports only node runtime
      */
     initializationFunction?: DefaultFunctionOptions & {
-        tagCache?: "dynamodb" | LazyLoadedOverride<TagCache>;
+        tagCache?: IncludedTagCache | LazyLoadedOverride<TagCache>;
     };
     /**
      * Dangerous options. This break some functionnality but can be useful in some cases.