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/edge-adapter.ts

@@ -11,12 +11,13 @@ import {
   convertBodyToReadableStream,
   convertToQueryString,
 } from "../core/routing/util";
+import type { OpenNextHandlerOptions } from "types/overrides";
 
 globalThis.__openNextAls = new AsyncLocalStorage();
 
 const defaultHandler = async (
   internalEvent: InternalEvent,
-  options?: { waitUntil?: WaitUntil },
+  options?: OpenNextHandlerOptions,
 ): Promise<InternalResult> => {
   globalThis.isEdgeRuntime = true;
 

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

@@ -22,10 +22,10 @@ import type {
   InternalEvent,
   InternalResult,
   StreamCreator,
-  WaitUntil,
 } from "types/open-next.js";
 import { emptyReadableStream, toReadableStream } from "utils/stream.js";
 
+import type { OpenNextHandlerOptions } from "types/overrides.js";
 import { createGenericHandler } from "../core/createGenericHandler.js";
 import { resolveImageLoader } from "../core/resolve.js";
 import { debug, error } from "./logger.js";
@@ -59,7 +59,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,10 +2,10 @@ import type {
   InternalEvent,
   InternalResult,
   MiddlewareResult,
-  WaitUntil,
 } from "types/open-next";
 import { runWithOpenNextRequestContext } from "utils/promise";
 
+import type { OpenNextHandlerOptions } from "types/overrides";
 import { debug, error } from "../adapters/logger";
 import { createGenericHandler } from "../core/createGenericHandler";
 import {
@@ -25,7 +25,7 @@ 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

@@ -7,11 +7,10 @@ import type {
   InternalResult,
   ResolvedRoute,
   RoutingResult,
-  StreamCreator,
-  WaitUntil,
 } from "types/open-next";
 import { runWithOpenNextRequestContext } from "utils/promise";
 
+import type { OpenNextHandlerOptions } from "types/overrides";
 import { debug, error, warn } from "../adapters/logger";
 import { patchAsyncStorage } from "./patchAsyncStorage";
 import { convertRes, createServerResponse } from "./routing/util";
@@ -30,10 +29,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,11 +1,12 @@
-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 },
-  ) => {
+  return async (event: InternalEvent, options?: OpenNextHandlerOptions) => {
     return await handler(event, options);
   };
 };

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

@@ -123,13 +123,17 @@ 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 },
-) => Promise<R>;
+> = (event: E, options?: OpenNextHandlerOptions) => Promise<R>;
 
 export type Converter<
   E extends BaseEventOrResult = InternalEvent,

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

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