edge, middleware and server all have access to __als

Author: conico974

packages/open-next/src/adapters/edge-adapter.ts

@@ -10,55 +10,70 @@ import {
   convertBodyToReadableStream,
   convertToQueryString,
 } from "../core/routing/util";
+import { generateOpenNextRequestContext } from "./util";
+
+globalThis.__als = new AsyncLocalStorage();
 
 const defaultHandler = async (
   internalEvent: InternalEvent,
 ): Promise<InternalResult> => {
   globalThis.isEdgeRuntime = true;
 
-  const host = internalEvent.headers.host
-    ? `https://${internalEvent.headers.host}`
-    : "http://localhost:3000";
-  const initialUrl = new URL(internalEvent.rawPath, host);
-  initialUrl.search = convertToQueryString(internalEvent.query);
-  const url = initialUrl.toString();
+  const { requestId, pendingPromiseRunner, isISRRevalidation } =
+    generateOpenNextRequestContext();
 
-  // @ts-expect-error - This is bundled
-  const handler = await import(`./middleware.mjs`);
+  // We run everything in the async local storage context so that it is available in edge runtime functions
+  return globalThis.__als.run(
+    { requestId, pendingPromiseRunner, isISRRevalidation },
+    async () => {
+      const host = internalEvent.headers.host
+        ? `https://${internalEvent.headers.host}`
+        : "http://localhost:3000";
+      const initialUrl = new URL(internalEvent.rawPath, host);
+      initialUrl.search = convertToQueryString(internalEvent.query);
+      const url = initialUrl.toString();
 
-  const response: Response = await handler.default({
-    headers: internalEvent.headers,
-    method: internalEvent.method || "GET",
-    nextConfig: {
-      basePath: NextConfig.basePath,
-      i18n: NextConfig.i18n,
-      trailingSlash: NextConfig.trailingSlash,
-    },
-    url,
-    body: convertBodyToReadableStream(internalEvent.method, internalEvent.body),
-  });
-  const responseHeaders: Record<string, string | string[]> = {};
-  response.headers.forEach((value, key) => {
-    if (key.toLowerCase() === "set-cookie") {
-      responseHeaders[key] = responseHeaders[key]
-        ? [...responseHeaders[key], value]
-        : [value];
-    } else {
-      responseHeaders[key] = value;
-    }
-  });
+      // @ts-expect-error - This is bundled
+      const handler = await import(`./middleware.mjs`);
 
-  const body =
-    (response.body as ReadableStream<Uint8Array>) ?? emptyReadableStream();
+      const response: Response = await handler.default({
+        headers: internalEvent.headers,
+        method: internalEvent.method || "GET",
+        nextConfig: {
+          basePath: NextConfig.basePath,
+          i18n: NextConfig.i18n,
+          trailingSlash: NextConfig.trailingSlash,
+        },
+        url,
+        body: convertBodyToReadableStream(
+          internalEvent.method,
+          internalEvent.body,
+        ),
+      });
+      const responseHeaders: Record<string, string | string[]> = {};
+      response.headers.forEach((value, key) => {
+        if (key.toLowerCase() === "set-cookie") {
+          responseHeaders[key] = responseHeaders[key]
+            ? [...responseHeaders[key], value]
+            : [value];
+        } else {
+          responseHeaders[key] = value;
+        }
+      });
 
-  return {
-    type: "core",
-    statusCode: response.status,
-    headers: responseHeaders,
-    body: body,
-    // Do we need to handle base64 encoded response?
-    isBase64Encoded: false,
-  };
+      const body =
+        (response.body as ReadableStream<Uint8Array>) ?? emptyReadableStream();
+
+      return {
+        type: "core",
+        statusCode: response.status,
+        headers: responseHeaders,
+        body: body,
+        // Do we need to handle base64 encoded response?
+        isBase64Encoded: false,
+      };
+    },
+  );
 };
 
 export const handler = await createGenericHandler({

packages/open-next/src/adapters/middleware.ts

@@ -9,8 +9,10 @@ import {
   resolveTagCache,
 } from "../core/resolve";
 import routingHandler from "../core/routingHandler";
+import { generateOpenNextRequestContext } from "./util";
 
 globalThis.internalFetch = fetch;
+globalThis.__als = new AsyncLocalStorage();
 
 const defaultHandler = async (internalEvent: InternalEvent) => {
   const originResolver = await resolveOriginResolver(
@@ -31,24 +33,37 @@ const defaultHandler = async (internalEvent: InternalEvent) => {
   );
   //#endOverride
 
-  const result = await routingHandler(internalEvent);
-  if ("internalEvent" in result) {
-    debug("Middleware intercepted event", internalEvent);
-    let origin: Origin | false = false;
-    if (!result.isExternalRewrite) {
-      origin = await originResolver.resolve(result.internalEvent.rawPath);
-    }
-    return {
-      type: "middleware",
-      internalEvent: result.internalEvent,
-      isExternalRewrite: result.isExternalRewrite,
-      origin,
-      isISR: result.isISR,
-    };
-  }
-
-  debug("Middleware response", result);
-  return result;
+  const { requestId, pendingPromiseRunner, isISRRevalidation } =
+    generateOpenNextRequestContext(internalEvent.headers["x-isr"] === "1");
+
+  // We run everything in the async local storage context so that it is available in the external middleware
+  return globalThis.__als.run(
+    {
+      requestId,
+      pendingPromiseRunner,
+      isISRRevalidation,
+    },
+    async () => {
+      const result = await routingHandler(internalEvent);
+      if ("internalEvent" in result) {
+        debug("Middleware intercepted event", internalEvent);
+        let origin: Origin | false = false;
+        if (!result.isExternalRewrite) {
+          origin = await originResolver.resolve(result.internalEvent.rawPath);
+        }
+        return {
+          type: "middleware",
+          internalEvent: result.internalEvent,
+          isExternalRewrite: result.isExternalRewrite,
+          origin,
+          isISR: result.isISR,
+        };
+      }
+
+      debug("Middleware response", result);
+      return result;
+    },
+  );
 };
 
 export const handler = await createGenericHandler({

packages/open-next/src/adapters/util.ts

@@ -1,5 +1,7 @@
 //TODO: We should probably move all the utils to a separate location
 
+import { DetachedPromiseRunner } from "utils/promise";
+
 export function setNodeEnv() {
   process.env.NODE_ENV = process.env.NODE_ENV ?? "production";
 }
@@ -8,6 +10,14 @@ export function generateUniqueId() {
   return Math.random().toString(36).slice(2, 8);
 }
 
+export function generateOpenNextRequestContext(isISRRevalidation = false) {
+  return {
+    requestId: Math.random().toString(36),
+    pendingPromiseRunner: new DetachedPromiseRunner(),
+    isISRRevalidation,
+  };
+}
+
 /**
  * Create an array of arrays of size `chunkSize` from `items`
  * @param items Array of T

packages/open-next/src/core/createMainHandler.ts

@@ -1,6 +1,4 @@
 import type { OpenNextConfig } from "types/open-next";
-import type { IncrementalCache, Queue } from "types/overrides";
-import type { DetachedPromiseRunner } from "utils/promise";
 
 import { debug } from "../adapters/logger";
 import { generateUniqueId } from "../adapters/util";