@opennextjs/aws 3.2.0 → 3.2.2

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

@@ -1,27 +1,25 @@
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
+import path from "node:path";
 import { AwsClient } from "aws4fetch";
-import path from "path";
 import { RecoverableError } from "../../utils/error";
 import { customFetchClient } from "../../utils/fetch";
 import { debug, error } from "../../adapters/logger";
 import { chunk, parseNumberFromEnv } from "../../adapters/util";
-import { getDynamoBatchWriteCommandConcurrency, MAX_DYNAMO_BATCH_WRITE_ITEM_COUNT, } from "./constants";
+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;
     }
-    else {
-        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;
-    }
+    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;

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

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

package/dist/overrides/tagCache/dynamodb.js

@@ -1,8 +1,8 @@
+import path from "node:path";
 import { BatchWriteItemCommand, DynamoDBClient, QueryCommand, } from "@aws-sdk/client-dynamodb";
-import path from "path";
 import { awsLogger, debug, error } from "../../adapters/logger";
 import { chunk, parseNumberFromEnv } from "../../adapters/util";
-import { getDynamoBatchWriteCommandConcurrency, MAX_DYNAMO_BATCH_WRITE_ITEM_COUNT, } from "./constants";
+import { MAX_DYNAMO_BATCH_WRITE_ITEM_COUNT, getDynamoBatchWriteCommandConcurrency, } from "./constants";
 const { CACHE_BUCKET_REGION, CACHE_DYNAMO_TABLE, NEXT_BUILD_ID } = process.env;
 function parseDynamoClientConfigFromEnv() {
     return {

package/dist/overrides/warmer/aws-lambda.d.ts

@@ -1,3 +1,3 @@
-import type { Warmer } from "../../types/open-next";
+import type { Warmer } from "../../types/overrides";
 declare const lambdaWarmerInvoke: Warmer;
 export default lambdaWarmerInvoke;

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

@@ -1,3 +1,3 @@
-import type { Warmer } from "../../types/open-next";
+import type { Warmer } from "../../types/overrides";
 declare const dummyWarmer: Warmer;
 export default dummyWarmer;

package/dist/overrides/wrappers/aws-lambda-streaming.d.ts

@@ -1,6 +1,6 @@
-import type { WrapperHandler } from "../../types/open-next";
+import type { WrapperHandler } from "../../types/overrides";
 declare const _default: {
-    wrapper: WrapperHandler<import("../../types/open-next").InternalEvent, import("../../types/open-next").InternalResult>;
+    wrapper: WrapperHandler;
     name: string;
     supportStreaming: boolean;
 };

package/dist/overrides/wrappers/aws-lambda.d.ts

@@ -1,6 +1,6 @@
-import type { WrapperHandler } from "../../types/open-next";
+import type { WrapperHandler } from "../../types/overrides";
 declare const _default: {
-    wrapper: WrapperHandler<import("../../types/open-next").InternalEvent, import("../../types/open-next").InternalResult>;
+    wrapper: WrapperHandler;
     name: string;
     supportStreaming: boolean;
 };

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

@@ -1,4 +1,5 @@
-import type { InternalEvent, InternalResult, WrapperHandler } from "../../types/open-next";
+import type { InternalEvent, InternalResult } from "../../types/open-next";
+import type { WrapperHandler } from "../../types/overrides";
 import type { MiddlewareOutputEvent } from "../../core/routingHandler";
 declare const _default: {
     wrapper: WrapperHandler<InternalEvent, InternalResult | ({

package/dist/overrides/wrappers/cloudflare.js

@@ -1,13 +1,31 @@
-const handler = async (handler, converter) => async (event, env) => {
+const cfPropNameToHeaderName = {
+    city: "x-open-next-city",
+    country: "x-open-next-country",
+    regionCode: "x-open-next-region",
+    latitude: "x-open-next-latitude",
+    longitude: "x-open-next-longitude",
+};
+const handler = async (handler, converter) => async (request, env, ctx) => {
     globalThis.process = process;
+    globalThis.openNextWaitUntil = ctx.waitUntil.bind(ctx);
     // Set the environment variables
-    // Cloudlare suggests to not override the process.env object but instead apply the values to it
+    // Cloudflare suggests to not override the process.env object but instead apply the values to it
     for (const [key, value] of Object.entries(env)) {
         if (typeof value === "string") {
             process.env[key] = value;
         }
     }
-    const internalEvent = await converter.convertFrom(event);
+    const internalEvent = await converter.convertFrom(request);
+    // Retrieve geo information from the cloudflare request
+    // 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)) {
+        const propValue = cfProperties[propName];
+        if (propValue !== null) {
+            internalEvent.headers[headerName] = propValue;
+        }
+    }
     const response = await handler(internalEvent);
     const result = await converter.convertTo(response);
     return result;

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

@@ -1,7 +1,7 @@
-import type { WrapperHandler } from "../../types/open-next";
+import type { WrapperHandler } from "../../types/overrides";
 declare const _default: {
     name: string;
-    handler: WrapperHandler<import("../../types/open-next").InternalEvent, import("../../types/open-next").InternalResult>;
+    handler: WrapperHandler;
     supportStreaming: boolean;
 };
 export default _default;

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

@@ -1,6 +1,6 @@
-import type { WrapperHandler } from "../../types/open-next";
+import type { WrapperHandler } from "../../types/overrides";
 declare const _default: {
-    wrapper: WrapperHandler<import("../../types/open-next").InternalEvent, import("../../types/open-next").InternalResult>;
+    wrapper: WrapperHandler;
     name: string;
     supportStreaming: boolean;
 };

package/dist/overrides/wrappers/node.js

@@ -28,9 +28,9 @@ const wrapper = async (handler, converter) => {
     await new Promise((resolve) => {
         server.on("listening", () => {
             const cleanup = (code) => {
-                debug(`Closing server`);
+                debug("Closing server");
                 server.close(() => {
-                    debug(`Server closed`);
+                    debug("Server closed");
                     process.exit(code);
                 });
             };
@@ -41,7 +41,7 @@ const wrapper = async (handler, converter) => {
             process.on("SIGTERM", () => cleanup(0));
             resolve();
         });
-        server.listen(parseInt(process.env.PORT ?? "3000", 10));
+        server.listen(Number.parseInt(process.env.PORT ?? "3000", 10));
     });
     server.on("error", (err) => {
         error(err);

package/dist/plugins/edge.d.ts

@@ -3,13 +3,14 @@ import type { MiddlewareInfo } from "../types/next-types.js";
 export interface IPluginSettings {
     nextDir: string;
     edgeFunctionHandlerPath?: string;
-    middlewareInfo: MiddlewareInfo;
+    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.entryFiles - The entry files that we'll inject into the edgeFunctionHandler.js file
+ * @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;

package/dist/plugins/edge.js

@@ -1,25 +1,31 @@
 import { readFileSync } from "node:fs";
 import path from "node:path";
+import chalk from "chalk";
 import { loadAppPathsManifestKeys, loadBuildId, loadConfig, loadConfigHeaders, loadHtmlPages, loadMiddlewareManifest, loadPrerenderManifest, loadRoutesManifest, } from "../adapters/config/util.js";
+import logger from "../logger.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.entryFiles - The entry files that we'll inject into the edgeFunctionHandler.js file
+ * @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, }) {
-    const entryFiles = middlewareInfo.files.map((file) => path.join(nextDir, file));
-    const routes = [
-        {
-            name: middlewareInfo.name || "/",
-            page: middlewareInfo.page,
-            regex: middlewareInfo.matchers.map((m) => m.regexp),
-        },
-    ];
-    const wasmFiles = middlewareInfo.wasm ?? [];
+    const entryFiles = middlewareInfo?.files.map((file) => path.join(nextDir, file)) ?? [];
+    const routes = middlewareInfo
+        ? [
+            {
+                name: middlewareInfo.name || "/",
+                page: middlewareInfo.page,
+                regex: middlewareInfo.matchers.map((m) => m.regexp),
+            },
+        ]
+        : [];
+    const wasmFiles = middlewareInfo?.wasm ?? [];
     return {
         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: /\.\/middleware.mjs/g }, () => {
@@ -44,12 +50,10 @@ export function openNextEdgePlugins({ nextDir, edgeFunctionHandlerPath, middlewa
             });
             // we convert the imports we tagged with the node-built-in-modules namespace so that instead of `require("node:*")`
             // they import from `export * from "node:*";`
-            build.onLoad({ filter: /.*/, namespace: "node-built-in-modules" }, ({ path }) => {
-                return {
-                    contents: `export * from '${path}'`,
-                    loader: "js",
-                };
-            });
+            build.onLoad({ filter: /.*/, namespace: "node-built-in-modules" }, ({ path }) => ({
+                contents: `export * from '${path}'`,
+                loader: "js",
+            }));
             // We inject the entry files into the edgeFunctionHandler
             build.onLoad({ filter: /\/edgeFunctionHandler.js/g }, async (args) => {
                 let contents = readFileSync(args.path, "utf-8");
@@ -59,7 +63,7 @@ globalThis.self = globalThis;
 globalThis._ROUTES = ${JSON.stringify(routes)};
 
 ${isInCloudfare
-                    ? ``
+                    ? ""
                     : `
 import {readFileSync} from "node:fs";
 import path from "node:path";
@@ -97,7 +101,7 @@ if(!globalThis.Crypto) {
   globalThis.Crypto = webcrypto.Crypto
 }
 // We also need to polyfill URLPattern
-if (!globalThis.URLPattern) { 
+if (!globalThis.URLPattern) {
   await import("urlpattern-polyfill");
 }
 `}
@@ -106,8 +110,8 @@ ${wasmFiles
                     ? `import ${file.name} from './wasm/${file.name}.wasm';`
                     : `const ${file.name} = readFileSync(path.join(__dirname,'/wasm/${file.name}.wasm'));`)
                     .join("\n")}
-${entryFiles?.map((file) => `require("${file}");`).join("\n")}
-${contents}        
+${entryFiles.map((file) => `require("${file}");`).join("\n")}
+${contents}
         `;
                 return {
                     contents,
@@ -123,19 +127,17 @@ ${contents}
                 const AppPathsManifestKeys = loadAppPathsManifestKeys(nextDir);
                 const MiddlewareManifest = loadMiddlewareManifest(nextDir);
                 const contents = `
-  import path from "path";
-  
+  import path from "node:path";
+
   import { debug } from "../logger";
-  
-  if(!globalThis.__dirname) {
-    globalThis.__dirname = ""
-  }
-  
+
+  globalThis.__dirname ??= "";
+
   export const NEXT_DIR = path.join(__dirname, ".next");
   export const OPEN_NEXT_DIR = path.join(__dirname, ".open-next");
-  
+
   debug({ NEXT_DIR, OPEN_NEXT_DIR });
-  
+
   export const NextConfig = ${JSON.stringify(NextConfig)};
   export const BuildId = ${JSON.stringify(BuildId)};
   export const HtmlPages = ${JSON.stringify(HtmlPages)};
@@ -146,11 +148,8 @@ ${contents}
   export const MiddlewareManifest = ${JSON.stringify(MiddlewareManifest)};
 
   process.env.NEXT_BUILD_ID = BuildId;
-  
-          `;
-                return {
-                    contents,
-                };
+`;
+                return { contents };
             });
         },
     };

package/dist/plugins/replacement.d.ts

@@ -13,7 +13,7 @@ export interface IPluginSettings {
  *   deletes: ["id1"],
  * })
  *
- * To inject arbritary code by using (import at top of file):
+ * To inject arbitrary code by using (import at top of file):
  *
  * //#import
  *

package/dist/plugins/replacement.js

@@ -11,7 +11,7 @@ const importPattern = /\/\/#import([\s\S]*?)\n\/\/#endImport/gm;
  *   deletes: ["id1"],
  * })
  *
- * To inject arbritary code by using (import at top of file):
+ * To inject arbitrary code by using (import at top of file):
  *
  * //#import
  *
@@ -46,12 +46,11 @@ export function openNextReplacementPlugin({ target, replacements, deletes, name,
                 await Promise.all([
                     ...(deletes ?? []).map(async (id) => {
                         const pattern = new RegExp(`\/\/#override (${id})\n([\\s\\S]*?)\/\/#endOverride`);
-                        logger.debug(chalk.blue(`Open-next replacement plugin ${name}`), ` -- Deleting override for ${id}`);
+                        logger.debug(chalk.blue(`OpenNext Replacement plugin ${name}`), `Delete override ${id}`);
                         contents = contents.replace(pattern, "");
                     }),
-                    ...(replacements ?? []).map(async (fp) => {
-                        const p = fp;
-                        const replacementFile = await readFile(p, "utf-8");
+                    ...(replacements ?? []).map(async (filename) => {
+                        const replacementFile = await readFile(filename, "utf-8");
                         const matches = replacementFile.matchAll(overridePattern);
                         const importMatch = replacementFile.match(importPattern);
                         const addedImport = importMatch ? importMatch[0] : "";
@@ -60,7 +59,7 @@ export function openNextReplacementPlugin({ target, replacements, deletes, name,
                             const replacement = match[2];
                             const id = match[1];
                             const pattern = new RegExp(`\/\/#override (${id})\n([\\s\\S]*?)\/\/#endOverride`, "g");
-                            logger.debug(chalk.blue(`Open-next replacement plugin ${name}`), `-- Applying override for ${id} from ${fp}`);
+                            logger.debug(chalk.blue(`Open-next replacement plugin ${name}`), `Apply override ${id} from ${filename}`);
                             contents = contents.replace(pattern, replacement);
                         }
                     }),

package/dist/plugins/resolve.d.ts

@@ -1,5 +1,6 @@
 import type { Plugin } from "esbuild";
-import type { DefaultOverrideOptions, ImageLoader, IncludedImageLoader, IncludedOriginResolver, IncludedWarmer, LazyLoadedOverride, OriginResolver, OverrideOptions, Warmer } from "../types/open-next";
+import type { DefaultOverrideOptions, IncludedImageLoader, IncludedOriginResolver, IncludedWarmer, LazyLoadedOverride, OverrideOptions } from "../types/open-next";
+import type { ImageLoader, OriginResolver, Warmer } from "../types/overrides";
 export interface IPluginSettings {
     overrides?: {
         wrapper?: DefaultOverrideOptions<any, any>["wrapper"];
@@ -10,6 +11,7 @@ export interface IPluginSettings {
         imageLoader?: LazyLoadedOverride<ImageLoader> | IncludedImageLoader;
         originResolver?: LazyLoadedOverride<OriginResolver> | IncludedOriginResolver;
         warmer?: LazyLoadedOverride<Warmer> | IncludedWarmer;
+        proxyExternalRequest?: OverrideOptions["proxyExternalRequest"];
     };
     fnName?: string;
 }

package/dist/plugins/resolve.js

@@ -1,4 +1,5 @@
 import { readFileSync } from "node:fs";
+import chalk from "chalk";
 import logger from "../logger.js";
 function getOverrideOrDummy(override) {
     if (typeof override === "string") {
@@ -17,6 +18,7 @@ const nameToFolder = {
     imageLoader: "imageLoader",
     originResolver: "originResolver",
     warmer: "warmer",
+    proxyExternalRequest: "proxyExternalRequest",
 };
 const defaultOverrides = {
     wrapper: "aws-lambda",
@@ -27,6 +29,7 @@ const defaultOverrides = {
     imageLoader: "s3",
     originResolver: "pattern-env",
     warmer: "aws-lambda",
+    proxyExternalRequest: "node",
 };
 /**
  * @param opts.overrides - The name of the overrides to use
@@ -36,7 +39,7 @@ export function openNextResolvePlugin({ overrides, fnName, }) {
     return {
         name: "opennext-resolve",
         setup(build) {
-            logger.debug(`OpenNext Resolve plugin for ${fnName}`);
+            logger.debug(chalk.blue("OpenNext Resolve plugin"), fnName ? `for ${fnName}` : "");
             build.onLoad({ filter: /core(\/|\\)resolve\.js/g }, async (args) => {
                 let contents = readFileSync(args.path, "utf-8");
                 const overridesEntries = Object.entries(overrides ?? {});

package/dist/types/aws-lambda.d.ts

@@ -1,8 +1,5 @@
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
+import type { Writable } from "node:stream";
 import type { APIGatewayProxyEventV2, Context } from "aws-lambda";
-import type { Writable } from "stream";
 export interface ResponseStream extends Writable {
     getBufferedData(): Buffer;
     setContentType(contentType: string): void;
@@ -15,7 +12,7 @@ interface Metadata {
 declare global {
     namespace awslambda {
         function streamifyResponse(handler: Handler): Handler;
-        module HttpResponseStream {
+        namespace HttpResponseStream {
             function from(res: Writable, metadata: Metadata): ResponseStream;
         }
     }

package/dist/types/cache.d.ts

@@ -1,5 +1,3 @@
-/// <reference types="node" />
-/// <reference types="node" />
 interface CachedFetchValue {
     kind: "FETCH";
     data: {

package/dist/types/global.d.ts

@@ -0,0 +1,188 @@
+import type { AsyncLocalStorage } from "node:async_hooks";
+import type { OutgoingHttpHeaders } from "node:http";
+import type { IncrementalCache, ProxyExternalRequest, Queue, TagCache } from "./overrides";
+import type { DetachedPromiseRunner } from "../utils/promise";
+import type { OpenNextConfig } from "./open-next";
+export interface RequestData {
+    geo?: {
+        city?: string;
+        country?: string;
+        region?: string;
+        latitude?: string;
+        longitude?: string;
+    };
+    headers: OutgoingHttpHeaders;
+    ip?: string;
+    method: string;
+    nextConfig?: {
+        basePath?: string;
+        i18n?: any;
+        trailingSlash?: boolean;
+    };
+    page?: {
+        name?: string;
+        params?: {
+            [key: string]: string | string[];
+        };
+    };
+    url: string;
+    body?: ReadableStream<Uint8Array>;
+    signal: AbortSignal;
+}
+interface Entries {
+    [k: string]: {
+        default: (props: {
+            page: string;
+            request: RequestData;
+        }) => Promise<{
+            response: Response;
+            waitUntil: Promise<void>;
+        }>;
+    };
+}
+export interface EdgeRoute {
+    name: string;
+    page: string;
+    regex: string[];
+}
+interface OpenNextRequestContext {
+    requestId: string;
+    pendingPromiseRunner: DetachedPromiseRunner;
+    isISRRevalidation?: boolean;
+    mergeHeadersPriority?: "middleware" | "handler";
+}
+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`.
+     */
+    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`.
+     */
+    var tagCache: TagCache;
+    /**
+     * A boolean that indicates if the DynamoDB cache is disabled.
+     * TODO: Remove this, we already have access to the config file
+     * Defined in esbuild banner for the cache adapter.
+     */
+    var disableDynamoDBCache: boolean;
+    /**
+     * A boolean that indicates if the incremental cache is disabled.
+     * TODO: Remove this, we already have access to the config file
+     * 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.
+     * Defined in the esbuild banner for the cache adapter.
+     */
+    var isNextAfter15: boolean;
+    /**
+     * 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`.
+     */
+    var isEdgeRuntime: true;
+    /**
+     * A boolean that indicates if we are running in debug mode.
+     * Available in all functions.
+     * Defined in the esbuild banner.
+     */
+    var openNextDebug: boolean;
+    /**
+     * 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`.
+     */
+    var internalFetch: typeof fetch;
+    /**
+     * The Open Next configuration object.
+     * Available in all functions.
+     * Defined in the `createMainHandler` or 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`.
+     */
+    var fnName: string | undefined;
+    /**
+     * The unique identifier of the server.
+     * Only available in main functions.
+     * Defined in the `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`.
+     */
+    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.
+     * Defined in the esbuild edge plugin.
+     */
+    var _ENTRIES: Entries;
+    /**
+     * The routes object that contains the routes that are available in the function.
+     * Only available in edge runtime functions.
+     * Defined in the esbuild edge plugin.
+     */
+    var _ROUTES: EdgeRoute[];
+    /**
+     * A map that is used in the edge runtime.
+     * Only available in edge runtime functions.
+     */
+    var __storage__: Map<unknown, unknown>;
+    /**
+     * AsyncContext available globally in the edge runtime.
+     * Only available in edge runtime functions.
+     */
+    var AsyncContext: any;
+    /**
+     * AsyncLocalStorage available globally in the edge runtime.
+     * Only available in edge runtime functions.
+     * Defined in createEdgeBundle.
+     */
+    var AsyncLocalStorage: any;
+    /**
+     * The version of the Open Next runtime.
+     * Available everywhere.
+     * 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
+     * Defined in `createMainHandler`.
+     */
+    var proxyExternalRequest: ProxyExternalRequest;
+}
+export {};

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

@@ -151,7 +151,5 @@ export type Options = {
     buildId: string;
     isExternalRewrite?: boolean;
 };
-export interface PluginHandler {
-    (req: IncomingMessage, res: OpenNextNodeResponse, options: Options): Promise<OpenNextNodeResponse | undefined>;
-}
+export type PluginHandler = (req: IncomingMessage, res: OpenNextNodeResponse, options: Options) => Promise<OpenNextNodeResponse | undefined>;
 export {};