[dynamicIO] Avoid memory leak warning for hanging promises (#77480)

Node.js tries to help you avoid memory leaks by detecting when a lot of
event listeners are set for a single AbortSignal. Next.js uses abort
signal listeners to do cleanup on hanging promises and so this usage is
not a memory leak however to avoid creating concern amongst users we
need to work around the listener count limit. This is unfortunate b/c it
is otherwise useless code to add but our alternative is to turn off this
leak detection or raise the limit significantly, neither of which are
great options since there may be other uses where this protection is
useful to our users.

In this change I implement the abort listening by a delegated event
listener

Author: gnoff

packages/next/src/server/dynamic-rendering-utils.ts

@@ -20,6 +20,9 @@ class HangingPromiseRejectionError extends Error {
   }
 }
 
+type AbortListeners = Array<(err: unknown) => void>
+const abortListenersBySignal = new WeakMap<AbortSignal, AbortListeners>()
+
 /**
  * This function constructs a promise that will never resolve. This is primarily
  * useful for dynamicIO where we use promise resolution timing to determine which
@@ -31,20 +34,37 @@ export function makeHangingPromise<T>(
   signal: AbortSignal,
   expression: string
 ): Promise<T> {
-  const hangingPromise = new Promise<T>((_, reject) => {
-    signal.addEventListener(
-      'abort',
-      () => {
-        reject(new HangingPromiseRejectionError(expression))
-      },
-      { once: true }
-    )
-  })
-  // We are fine if no one actually awaits this promise. We shouldn't consider this an unhandled rejection so
-  // we attach a noop catch handler here to suppress this warning. If you actually await somewhere or construct
-  // your own promise out of it you'll need to ensure you handle the error when it rejects.
-  hangingPromise.catch(ignoreReject)
-  return hangingPromise
+  if (signal.aborted) {
+    return Promise.reject(new HangingPromiseRejectionError(expression))
+  } else {
+    const hangingPromise = new Promise<T>((_, reject) => {
+      const boundRejection = reject.bind(
+        null,
+        new HangingPromiseRejectionError(expression)
+      )
+      let currentListeners = abortListenersBySignal.get(signal)
+      if (currentListeners) {
+        currentListeners.push(boundRejection)
+      } else {
+        const listeners = [boundRejection]
+        abortListenersBySignal.set(signal, listeners)
+        signal.addEventListener(
+          'abort',
+          () => {
+            for (let i = 0; i < listeners.length; i++) {
+              listeners[i]()
+            }
+          },
+          { once: true }
+        )
+      }
+    })
+    // We are fine if no one actually awaits this promise. We shouldn't consider this an unhandled rejection so
+    // we attach a noop catch handler here to suppress this warning. If you actually await somewhere or construct
+    // your own promise out of it you'll need to ensure you handle the error when it rejects.
+    hangingPromise.catch(ignoreReject)
+    return hangingPromise
+  }
 }
 
 function ignoreReject() {}