fixup! +OpenNextHandlerOptions +changeset

Author: vicb

.changeset/pink-papayas-smoke.md

@@ -0,0 +1,25 @@
+---
+"@opennextjs/aws": minor
+---
+
+refactor: `waitUntil` passed around via ALS.
+
+BREAKING CHANGE: `waitUntil` is passed around via ALS to fix #713.
+
+`globalThis.openNextWaitUntil` is no more available, you can access `waitUntil`
+on the ALS context: `globalThis.__openNextAls.getStore()`
+
+The `OpenNextHandler` signature has changed: the second parameter was a `StreamCreator`.
+It was changed to be of type `OpenNextHandlerOptions` which has both a `streamCreator` key
+and a `waitUntil` key.
+
+If you use a custom wrapper, you need to update the call to the handler as follow:
+
+```ts
+// before
+globalThis.openNextWaitUntil = myWaitUntil;
+handler(internalEvent, myStreamCreator);
+
+// after
+handler(internalEvent, { streamCreator: myStreamCreator, waitUntil: myWaitUntil });
+```

packages/open-next/src/adapters/image-optimization-adapter.ts

@@ -31,6 +31,7 @@ import { resolveImageLoader } from "../core/resolve.js";
 import { debug, error } from "./logger.js";
 import { optimizeImage } from "./plugins/image-optimization/image-optimization.js";
 import { setNodeEnv } from "./util.js";
+import type { OpenNextHandlerOptions } from "types/overrides.js";
 
 setNodeEnv();
 const nextDir = path.join(__dirname, ".next");
@@ -59,7 +60,7 @@ export const handler = await createGenericHandler({
 
 export async function defaultHandler(
   event: InternalEvent,
-  options?: { streamCreator?: StreamCreator; waitUntil?: WaitUntil },
+  options?: OpenNextHandlerOptions,
 ): Promise<InternalResult> {
   // Images are handled via header and query param information.
   debug("handler event", event);

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

@@ -2,7 +2,6 @@ import type {
   InternalEvent,
   InternalResult,
   MiddlewareResult,
-  WaitUntil,
 } from "types/open-next";
 import { runWithOpenNextRequestContext } from "utils/promise";
 
@@ -19,13 +18,14 @@ import routingHandler, {
   INTERNAL_HEADER_INITIAL_PATH,
   INTERNAL_HEADER_RESOLVED_ROUTES,
 } from "../core/routingHandler";
+import type { OpenNextHandlerOptions } from "types/overrides";
 
 globalThis.internalFetch = fetch;
 globalThis.__openNextAls = new AsyncLocalStorage();
 
 const defaultHandler = async (
   internalEvent: InternalEvent,
-  options?: { waitUntil?: WaitUntil },
+  options?: OpenNextHandlerOptions,
 ): Promise<InternalResult | MiddlewareResult> => {
   const originResolver = await resolveOriginResolver(
     globalThis.openNextConfig.middleware?.originResolver,

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

@@ -22,6 +22,7 @@ import routingHandler, {
   MIDDLEWARE_HEADER_PREFIX_LEN,
 } from "./routingHandler";
 import { requestHandler, setNextjsPrebundledReact } from "./util";
+import type { OpenNextHandlerOptions } from "types/overrides";
 
 // This is used to identify requests in the cache
 globalThis.__openNextAls = new AsyncLocalStorage();
@@ -30,10 +31,7 @@ patchAsyncStorage();
 
 export async function openNextHandler(
   internalEvent: InternalEvent,
-  options?: {
-    streamCreator?: StreamCreator;
-    waitUntil?: WaitUntil;
-  },
+  options?: OpenNextHandlerOptions
 ): Promise<InternalResult> {
   const initialHeaders = internalEvent.headers;
   // We run everything in the async local storage context so that it is available in the middleware as well as in NextServer

packages/open-next/src/overrides/wrappers/dummy.ts

@@ -1,10 +1,10 @@
-import type { InternalEvent, StreamCreator, WaitUntil } from "types/open-next";
-import type { Wrapper, WrapperHandler } from "types/overrides";
+import type { InternalEvent } from "types/open-next";
+import type { OpenNextHandlerOptions, Wrapper, WrapperHandler } from "types/overrides";
 
 const dummyWrapper: WrapperHandler = async (handler, converter) => {
   return async (
     event: InternalEvent,
-    options?: { streamCreator?: StreamCreator; waitUntil?: WaitUntil },
+    options?: OpenNextHandlerOptions,
   ) => {
     return await handler(event, options);
   };

packages/open-next/src/types/overrides.ts

@@ -123,12 +123,19 @@ export type Wrapper<
   edgeRuntime?: boolean;
 };
 
+export type OpenNextHandlerOptions = {
+  // Create a `Writeable` for streaming responses.
+  streamCreator?: StreamCreator;
+  // Extends the liftetime of the runtime after the response is returned.
+  waitUntil?: WaitUntil;
+};
+
 export type OpenNextHandler<
   E extends BaseEventOrResult = InternalEvent,
   R extends BaseEventOrResult = InternalResult,
 > = (
   event: E,
-  options?: { streamCreator?: StreamCreator; waitUntil?: WaitUntil },
+  options?: OpenNextHandlerOptions,
 ) => Promise<R>;
 
 export type Converter<

packages/open-next/src/utils/promise.ts

@@ -102,11 +102,18 @@ function provideNextAfterProvider() {
   }
 }
 
+export type RunWithOpenNextContextOptions = {
+  // Whether we are in ISR revalidation
+  isISRRevalidation: boolean;
+  // Extends the liftetime of the runtime after the response is returned.
+  waitUntil?: WaitUntil;
+};
+
 export function runWithOpenNextRequestContext<T>(
   {
     isISRRevalidation,
     waitUntil,
-  }: { isISRRevalidation: boolean; waitUntil?: WaitUntil },
+  }: RunWithOpenNextContextOptions,
   fn: () => Promise<T>,
 ): Promise<T> {
   return globalThis.__openNextAls.run(