@opennextjs/aws 3.2.1 → 3.2.2

package/dist/overrides/proxyExternalRequest/node.js

@@ -0,0 +1,67 @@
+import { debug, error } from "node:console";
+import { request } from "node:https";
+import { Readable } from "node:stream";
+import { isBinaryContentType } from "../../adapters/binary";
+function filterHeadersForProxy(headers) {
+    const filteredHeaders = {};
+    const disallowedHeaders = [
+        "host",
+        "connection",
+        "via",
+        "x-cache",
+        "transfer-encoding",
+        "content-encoding",
+        "content-length",
+    ];
+    Object.entries(headers)
+        .filter(([key, _]) => {
+        const lowerKey = key.toLowerCase();
+        return !(disallowedHeaders.includes(lowerKey) || lowerKey.startsWith("x-amz"));
+    })
+        .forEach(([key, value]) => {
+        filteredHeaders[key] = value?.toString() ?? "";
+    });
+    return filteredHeaders;
+}
+const nodeProxy = {
+    name: "node-proxy",
+    proxy: (internalEvent) => {
+        const { url, headers, method, body } = internalEvent;
+        debug("proxyRequest", url);
+        return new Promise((resolve, reject) => {
+            const filteredHeaders = filterHeadersForProxy(headers);
+            debug("filteredHeaders", filteredHeaders);
+            const req = request(url, {
+                headers: filteredHeaders,
+                method,
+                rejectUnauthorized: false,
+            }, (_res) => {
+                const nodeReadableStream = _res.headers["content-encoding"] === "br"
+                    ? _res.pipe(require("node:zlib").createBrotliDecompress())
+                    : _res.headers["content-encoding"] === "gzip"
+                        ? _res.pipe(require("node:zlib").createGunzip())
+                        : _res;
+                const isBase64Encoded = isBinaryContentType(headers["content-type"]) ||
+                    !!headers["content-encoding"];
+                const result = {
+                    type: "core",
+                    headers: filterHeadersForProxy(_res.headers),
+                    statusCode: _res.statusCode ?? 200,
+                    // TODO: check base64 encoding
+                    isBase64Encoded,
+                    body: Readable.toWeb(nodeReadableStream),
+                };
+                resolve(result);
+                _res.on("error", (e) => {
+                    error("proxyRequest error", e);
+                    reject(e);
+                });
+            });
+            if (body && method !== "GET" && method !== "HEAD") {
+                req.write(body);
+            }
+            req.end();
+        });
+    },
+};
+export default nodeProxy;

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

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

package/dist/overrides/queue/sqs-lite.d.ts

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

package/dist/overrides/queue/sqs-lite.js

@@ -7,15 +7,13 @@ const getAwsClient = () => {
     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: process.env.REVALIDATION_QUEUE_REGION,
-        });
-        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: process.env.REVALIDATION_QUEUE_REGION,
+    });
+    return awsClient;
 };
 const awsFetch = (body) => {
     const { REVALIDATION_QUEUE_REGION } = process.env;

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

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

package/dist/overrides/queue/sqs.js

@@ -1,4 +1,4 @@
-import { SendMessageCommand, SQSClient } from "@aws-sdk/client-sqs";
+import { SQSClient, SendMessageCommand } from "@aws-sdk/client-sqs";
 import { awsLogger } from "../../adapters/logger";
 // Expected environment variables
 const { REVALIDATION_QUEUE_REGION, REVALIDATION_QUEUE_URL } = process.env;

package/dist/overrides/tagCache/constants.js

@@ -7,10 +7,10 @@ const DEFAULT_DYNAMO_BATCH_WRITE_COMMAND_CONCURRENCY = 4;
 export const getDynamoBatchWriteCommandConcurrency = () => {
     const dynamoBatchWriteCommandConcurrencyFromEnv = process.env.DYNAMO_BATCH_WRITE_COMMAND_CONCURRENCY;
     const parsedDynamoBatchWriteCommandConcurrencyFromEnv = dynamoBatchWriteCommandConcurrencyFromEnv
-        ? parseInt(dynamoBatchWriteCommandConcurrencyFromEnv)
+        ? Number.parseInt(dynamoBatchWriteCommandConcurrencyFromEnv)
         : undefined;
     if (parsedDynamoBatchWriteCommandConcurrencyFromEnv &&
-        !isNaN(parsedDynamoBatchWriteCommandConcurrencyFromEnv)) {
+        !Number.isNaN(parsedDynamoBatchWriteCommandConcurrencyFromEnv)) {
         return parsedDynamoBatchWriteCommandConcurrencyFromEnv;
     }
     return DEFAULT_DYNAMO_BATCH_WRITE_COMMAND_CONCURRENCY;

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

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

package/dist/overrides/tagCache/dynamodb-lite.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-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,5 +1,13 @@
-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
     // Cloudflare suggests to not override the process.env object but instead apply the values to it
     for (const [key, value] of Object.entries(env)) {
@@ -7,7 +15,17 @@ const handler = async (handler, converter) => async (event, env) => {
             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.js

@@ -1,6 +1,8 @@
 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
@@ -23,6 +25,7 @@ export function openNextEdgePlugins({ nextDir, edgeFunctionHandlerPath, middlewa
     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 }, () => {
@@ -60,7 +63,7 @@ globalThis.self = globalThis;
 globalThis._ROUTES = ${JSON.stringify(routes)};
 
 ${isInCloudfare
-                    ? ``
+                    ? ""
                     : `
 import {readFileSync} from "node:fs";
 import path from "node:path";
@@ -124,13 +127,11 @@ ${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");

package/dist/plugins/replacement.js

@@ -46,7 +46,7 @@ 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 (filename) => {
@@ -59,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 ${filename}`);
+                            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 {};