next/after support and better AsyncLocalStorage context in general (opennextjs#626)

* move globals

* edge, middleware and server all have access to __als

* add support for a global waitUntil

* next/after support

* refactor

* review change

* biome fix

* fix test and patchedAsyncStorage

* added some e2e test for next/after

* changeset

* fix lint

* review fix

* review

Author: conico974

.changeset/new-dolphins-sleep.md

@@ -0,0 +1,6 @@
+---
+"@opennextjs/aws": patch
+---
+
+add support for next/after
+It can also be used to emulate vercel request context (the waitUntil) for lib that may rely on it on serverless env. It needs this env variable EMULATE_VERCEL_REQUEST_CONTEXT to be set to be enabled

examples/app-router/app/api/after/revalidate/route.ts

@@ -0,0 +1,16 @@
+import { revalidateTag } from "next/cache";
+import { NextResponse, unstable_after as after } from "next/server";
+
+export function POST() {
+  after(
+    () =>
+      new Promise<void>((resolve) =>
+        setTimeout(() => {
+          revalidateTag("date");
+          resolve();
+        }, 5000),
+      ),
+  );
+
+  return NextResponse.json({ success: true });
+}

examples/app-router/app/api/after/ssg/route.ts

@@ -0,0 +1,12 @@
+import { unstable_cache } from "next/cache";
+import { NextResponse } from "next/server";
+
+export const dynamic = "force-static";
+
+export async function GET() {
+  const dateFn = unstable_cache(() => new Date().toISOString(), ["date"], {
+    tags: ["date"],
+  });
+  const date = await dateFn();
+  return NextResponse.json({ date });
+}

examples/app-router/next.config.ts

@@ -17,6 +17,9 @@ const nextConfig: NextConfig = {
       },
     ],
   },
+  experimental: {
+    after: true,
+  },
   redirects: async () => {
     return [
       {

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

@@ -1,5 +1,3 @@
-import type { IncrementalCache, TagCache } from "types/overrides";
-
 import { isBinaryContentType } from "./binary";
 import { debug, error, warn } from "./logger";
 
@@ -100,15 +98,6 @@ export function hasCacheExtension(key: string) {
   return CACHE_EXTENSION_REGEX.test(key);
 }
 
-declare global {
-  var incrementalCache: IncrementalCache;
-  var tagCache: TagCache;
-  var disableDynamoDBCache: boolean;
-  var disableIncrementalCache: boolean;
-  var lastModified: Record<string, number>;
-  var isNextAfter15: boolean;
-}
-
 function isFetchCache(
   options?:
     | boolean
@@ -227,7 +216,7 @@ export default class S3Cache {
         // If some tags are stale we need to force revalidation
         return null;
       }
-      const requestId = globalThis.__als.getStore()?.requestId ?? "";
+      const requestId = globalThis.__openNextAls.getStore()?.requestId ?? "";
       globalThis.lastModified[requestId] = _lastModified;
       if (cacheData?.type === "route") {
         return {
@@ -298,7 +287,7 @@ export default class S3Cache {
     }
     // This one might not even be necessary anymore
     // Better be safe than sorry
-    const detachedPromise = globalThis.__als
+    const detachedPromise = globalThis.__openNextAls
       .getStore()
       ?.pendingPromiseRunner.withResolvers<void>();
     try {

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

@@ -1,6 +1,7 @@
 import type { ReadableStream } from "node:stream/web";
 
 import type { InternalEvent, InternalResult } from "types/open-next";
+import { runWithOpenNextRequestContext } from "utils/promise";
 import { emptyReadableStream } from "utils/stream";
 
 // We import it like that so that the edge plugin can replace it
@@ -11,58 +12,65 @@ import {
   convertToQueryString,
 } from "../core/routing/util";
 
-declare global {
-  var isEdgeRuntime: true;
-}
+globalThis.__openNextAls = 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();
+  // We run everything in the async local storage context so that it is available in edge runtime functions
+  return runWithOpenNextRequestContext(
+    { isISRRevalidation: false },
+    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();
 
-  // @ts-expect-error - This is bundled
-  const handler = await import(`./middleware.mjs`);
+      // @ts-expect-error - This is bundled
+      const handler = await import(`./middleware.mjs`);
 
-  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;
-    }
-  });
+      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;
+        }
+      });
 
-  const body =
-    (response.body as ReadableStream<Uint8Array>) ?? emptyReadableStream();
+      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,
-  };
+      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/logger.ts

@@ -1,9 +1,5 @@
 import type { BaseOpenNextError } from "utils/error";
 
-declare global {
-  var openNextDebug: boolean;
-}
-
 export function debug(...args: any[]) {
   if (globalThis.openNextDebug) {
     console.log(...args);

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

@@ -1,4 +1,5 @@
 import type { InternalEvent, Origin } from "types/open-next";
+import { runWithOpenNextRequestContext } from "utils/promise";
 
 import { debug } from "../adapters/logger";
 import { createGenericHandler } from "../core/createGenericHandler";
@@ -11,6 +12,7 @@ import {
 import routingHandler from "../core/routingHandler";
 
 globalThis.internalFetch = fetch;
+globalThis.__openNextAls = new AsyncLocalStorage();
 
 const defaultHandler = async (internalEvent: InternalEvent) => {
   const originResolver = await resolveOriginResolver(
@@ -31,24 +33,30 @@ 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;
+  // We run everything in the async local storage context so that it is available in the external middleware
+  return runWithOpenNextRequestContext(
+    { isISRRevalidation: internalEvent.headers["x-isr"] === "1" },
+    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/server-adapter.ts

@@ -12,9 +12,6 @@ setBuildIdEnv();
 setNextjsServerWorkingDirectory();
 
 // Because next is messing with fetch, we have to make sure that we use an untouched version of fetch
-declare global {
-  var internalFetch: typeof fetch;
-}
 globalThis.internalFetch = fetch;
 
 /////////////

packages/open-next/src/build/patch/patchedAsyncStorage.ts

@@ -10,7 +10,7 @@ const staticGenerationAsyncStorage = {
     if (store) {
       store.isOnDemandRevalidate =
         store.isOnDemandRevalidate &&
-        !globalThis.__als.getStore().isISRRevalidation;
+        !globalThis.__openNextAls.getStore().isISRRevalidation;
     }
     return store;
   },