@jsenv/server 9.1.1 → 9.2.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/server",
-  "version": "9.1.1",
+  "version": "9.2.3",
   "description": "Write your Node.js server using pure functions",
   "license": "MIT",
   "author": {

package/src/abort/callback_race.js

@@ -0,0 +1,31 @@
+/*
+ * See callback_race.md
+ */
+
+export const raceCallbacks = (raceDescription, winnerCallback) => {
+  const cleanCallbacks = []
+
+  const cleanup = () => {
+    const cleanCallbacksCopy = cleanCallbacks.slice()
+    cleanCallbacks.length = 0
+    cleanCallbacksCopy.forEach((clean) => {
+      clean()
+    })
+  }
+
+  Object.keys(raceDescription).forEach((candidateName) => {
+    const register = raceDescription[candidateName]
+    const returnValue = register((data) => {
+      cleanup()
+      winnerCallback({
+        name: candidateName,
+        data,
+      })
+    })
+    if (typeof returnValue === "function") {
+      cleanCallbacks.push(returnValue)
+    }
+  })
+
+  return cleanup
+}

package/src/abort/callback_race.md

@@ -0,0 +1,38 @@
+Taking different code paths based on different inputs is messy and code oftens forget to clean things behind itself.
+
+"raceCallbacks" helps to do both properly with the following API
+
+```js
+import { raceCallbacks } from "somewhere"
+
+raceCallbacks(
+  {
+    timeout: (cb) => {
+      const timeout = setTimeout(cb, 1000)
+      return () => {
+        clearTimeout(timeout)
+      }
+    },
+    error: () => {
+      something.on("error", cb)
+      return () => {
+        return something.removeListener("error", cb)
+      }
+    },
+    end: () => {
+      something.on("end", cb)
+      return () => {
+        return something.removeListener("end", cb)
+      }
+    },
+  },
+  (winner) => {
+    const raceEffects = {
+      timeout: () => console.log("timeout after 1000ms"),
+      error: (e) => console.error("error", e),
+      end: (value) => console.log("end", value),
+    }
+    raceEffects[winner.name](winner.value)
+  },
+)
+```

package/src/abort/cleaner.js

@@ -0,0 +1,58 @@
+export const createCleaner = () => {
+  let callbacks = []
+
+  const addCallback = (callback) => {
+    if (typeof callback !== "function") {
+      throw new Error(`callback must be a function, got ${callback}`)
+    }
+
+    // don't register twice
+    const existingCallback = callbacks.find((callbackCandidate) => {
+      return callbackCandidate === callback
+    })
+    if (existingCallback) {
+      if (typeof process.emitWarning === "object") {
+        process.emitWarning(`Trying to register same callback twice`, {
+          CODE: "CALLBACK_DUPLICATION",
+          detail: `It's often the sign that code is executd more than once`,
+        })
+      } else {
+        console.warn(`Trying to add same callback twice`)
+      }
+    } else {
+      callbacks = [...callbacks, callback]
+    }
+
+    return () => {
+      callbacks = arrayWithout(callbacks, callback)
+    }
+  }
+
+  const clean = async (reason) => {
+    const callbacksCopy = callbacks.slice()
+    callbacks.length = 0
+
+    await Promise.all(
+      callbacksCopy.map(async (callback) => {
+        await callback(reason)
+      }),
+    )
+  }
+
+  return { addCallback, clean }
+}
+
+const arrayWithout = (array, item) => {
+  if (array.length === 0) return array
+  const arrayWithoutItem = []
+  let i = 0
+  while (i < array.length) {
+    const value = array[i]
+    i++
+    if (value === item) {
+      continue
+    }
+    arrayWithoutItem.push(value)
+  }
+  return arrayWithoutItem
+}

package/src/abort/main.js

@@ -27,4 +27,7 @@
  */
 
 export { Abort } from "./abort.js"
-export { Cleanup } from "./cleanup.js"
+export { createCleaner } from "./cleaner.js"
+
+// When these file will become a NPM package, this export should be Node.js only
+export { createOperation } from "./operation.js"

package/src/abort/operation.js

@@ -0,0 +1,38 @@
+import { Abort } from "./abort.js"
+import { raceCallbacks } from "./callback_race.js"
+import { createCleaner } from "./cleaner.js"
+
+export const createOperation = ({
+  abortSignal = Abort.dormantSignal(),
+  cleanOnAbort = false,
+} = {}) => {
+  const cleaner = createCleaner()
+  const operation = { abortSignal, cleaner }
+
+  if (cleanOnAbort) {
+    raceCallbacks(
+      {
+        aborted: (cb) => {
+          operation.abortSignal.addEventListener("abort", cb)
+          return () => {
+            operation.abortSignal.removeEventListener("abort", cb)
+          }
+        },
+        cleaned: (cb) => {
+          return cleaner.addCallback(cb)
+        },
+      },
+      (winner) => {
+        const raceEffects = {
+          aborted: () => {
+            cleaner.clean()
+          },
+          cleaned: () => {},
+        }
+        raceEffects[winner.name]()
+      },
+    )
+  }
+
+  return operation
+}

package/src/abort/process_teardown_abort.js

@@ -0,0 +1,26 @@
+import { Abort } from "./abort.js"
+import { raceProcessTeardownEvents } from "./process_teardown_events.js"
+
+export const abortOperationOnProcessTeardown = (
+  operation,
+  processTeardownEvents,
+) => {
+  const processSignalAbortController = new AbortController()
+  operation.abortSignal = Abort.composeTwoAbortSignals(
+    operation.abortSignal,
+    processSignalAbortController.signal,
+  )
+  const cancelProcessTeardownRace = raceProcessTeardownEvents(
+    processTeardownEvents,
+    () => {
+      processSignalAbortController.abort()
+    },
+  )
+  const removeCleanCallback = operation.cleaner.addCallback(() => {
+    cancelProcessTeardownRace()
+  })
+  return () => {
+    cancelProcessTeardownRace()
+    removeCleanCallback()
+  }
+}

package/src/abort/process_teardown_events.js

@@ -0,0 +1,59 @@
+import { raceCallbacks } from "./callback_race.js"
+
+export const raceProcessTeardownEvents = (processTeardownEvents, callback) => {
+  return raceCallbacks(
+    {
+      ...(processTeardownEvents.SIGHUP ? SIGHUP_CALLBACK : {}),
+      ...(processTeardownEvents.SIGTERM ? SIGTERM_CALLBACK : {}),
+      ...(processTeardownEvents.SIGINT ? SIGINT_CALLBACK : {}),
+      ...(processTeardownEvents.beforeExit ? BEFORE_EXIT_CALLBACK : {}),
+      ...(processTeardownEvents.exit ? EXIT_CALLBACK : {}),
+    },
+    callback,
+  )
+}
+
+const SIGHUP_CALLBACK = {
+  SIGHUP: (cb) => {
+    process.on("SIGHUP", cb)
+    return () => {
+      process.removeListener("SIGHUP", cb)
+    }
+  },
+}
+
+const SIGTERM_CALLBACK = {
+  SIGTERM: (cb) => {
+    process.on("SIGTERM", cb)
+    return () => {
+      process.removeListener("SIGTERM", cb)
+    }
+  },
+}
+
+const BEFORE_EXIT_CALLBACK = {
+  beforeExit: (cb) => {
+    process.on("beforeExit", cb)
+    return () => {
+      process.removeListener("beforeExit", cb)
+    }
+  },
+}
+
+const EXIT_CALLBACK = {
+  exit: (cb) => {
+    process.on("exit", cb)
+    return () => {
+      process.removeListener("exit", cb)
+    }
+  },
+}
+
+const SIGINT_CALLBACK = {
+  SIGINT: (cb) => {
+    process.on("SIGINT", cb)
+    return () => {
+      process.removeListener("SIGINT", cb)
+    }
+  },
+}

package/src/internal/nodeRequestToRequest.js

@@ -1,9 +1,10 @@
+import { raceCallbacks } from "../abort/callback_race.js"
 import { nodeStreamToObservable } from "./nodeStreamToObservable.js"
 import { headersFromObject } from "./headersFromObject.js"
 
 export const nodeRequestToRequest = (
   nodeRequest,
-  { serverCleanup, serverOrigin },
+  { serverOperation, serverOrigin },
 ) => {
   const { method } = nodeRequest
   const { url: ressource } = nodeRequest
@@ -24,7 +25,7 @@ export const nodeRequestToRequest = (
   }
 
   return Object.freeze({
-    abortSignal: createRequestAbortSignal({ nodeRequest, serverCleanup }),
+    abortSignal: createRequestAbortSignal({ nodeRequest, serverOperation }),
     origin: requestOrigin,
     http2: Boolean(nodeRequest.stream),
     ressource,
@@ -34,13 +35,49 @@ export const nodeRequestToRequest = (
   })
 }
 
-const createRequestAbortSignal = ({ nodeRequest, serverCleanup }) => {
+const createRequestAbortSignal = ({ nodeRequest, serverOperation }) => {
   const abortController = new AbortController()
-  nodeRequest.on("abort", () => {
-    abortController.abort()
-  })
-  serverCleanup.addCallback(() => {
-    abortController.abort()
-  })
+  raceCallbacks(
+    {
+      server_closing: (cb) => {
+        return serverOperation.cleaner.addCallback(cb)
+      },
+      request_close: (cb) => {
+        nodeRequest.on("close", cb)
+        return () => {
+          nodeRequest.removeListener("close", cb)
+        }
+      },
+      request_error: (cb) => {
+        nodeRequest.on("error", cb)
+        return () => {
+          nodeRequest.removeListener("error", cb)
+        }
+      },
+      request_finish: (cb) => {
+        nodeRequest.on("finish", cb)
+        return () => {
+          nodeRequest.removeListener("finish", cb)
+        }
+      },
+    },
+    (winner) => {
+      const raceEffects = {
+        server_closing: () => {
+          abortController.abort()
+        },
+        request_close: () => {
+          if (!nodeRequest.complete) {
+            // aborted while reading request body
+            abortController.abort()
+          }
+        },
+        // no special effects on thoose, just remove other callbacks
+        request_error: () => {},
+        request_finish: () => {},
+      }
+      raceEffects[winner.name]()
+    },
+  )
   return abortController.signal
 }

package/src/internal/nodeStreamToObservable.js

@@ -21,26 +21,19 @@ export const nodeStreamToObservable = (nodeStream) => {
   }
 
   return createObservable(({ next, error, complete }) => {
-    // should we do nodeStream.resume() in case the stream was paused ?
-    nodeStream.once("error", error)
-    nodeStream.on("data", next)
-    nodeStream.once("end", complete)
-
     const cleanup = () => {
       nodeStream.removeListener("data", next)
       nodeStream.removeListener("error", error)
       nodeStream.removeListener("end", complete)
-
-      if (typeof nodeStream.abort === "function") {
-        nodeStream.abort()
-      } else {
-        nodeStream.destroy()
-      }
+      nodeStream.removeListener("close", cleanup)
+      nodeStream.destroy()
     }
 
-    if (typeof nodeStream.once === "function") {
-      nodeStream.once("abort", cleanup)
-    }
+    // should we do nodeStream.resume() in case the stream was paused ?
+    nodeStream.once("error", error)
+    nodeStream.on("data", next)
+    nodeStream.once("close", cleanup)
+    nodeStream.once("end", complete)
 
     return cleanup
   })

package/src/internal/populateNodeResponse.js

@@ -1,6 +1,6 @@
 import { Http2ServerResponse } from "node:http2"
 
-import { raceCallbacks } from "./callback_race.js"
+import { raceCallbacks } from "@jsenv/server/src/abort/callback_race.js"
 import { normalizeResponseBodyMethods } from "./responseBody.js"
 
 export const populateNodeResponse = async (
@@ -41,92 +41,95 @@ export const populateNodeResponse = async (
     responseStream.setEncoding(bodyEncoding)
   }
 
-  const winnerPromise = raceCallbacks({
-    abort: (cb) => {
-      abortSignal.addEventListener("abort", cb)
-      return () => {
-        abortSignal.removeEventListener("abort", cb)
-      }
-    },
-    error: (cb) => {
-      responseStream.on("error", cb)
-      return () => {
-        responseStream.removeListener("error", cb)
-      }
-    },
-    close: (cb) => {
-      responseStream.on("close", cb)
-      return () => {
-        responseStream.removeListener("close", cb)
-      }
-    },
-    finish: (cb) => {
-      responseStream.on("finish", cb)
-      return () => {
-        responseStream.removeListener("finish", cb)
-      }
-    },
-  })
-
-  const observable = bodyMethods.asObservable()
-  const subscription = observable.subscribe({
-    next: (data) => {
-      try {
-        responseStream.write(data)
-      } catch (e) {
-        // Something inside Node.js sometimes puts stream
-        // in a state where .write() throw despites nodeResponse.destroyed
-        // being undefined and "close" event not being emitted.
-        // I have tested if we are the one calling destroy
-        // (I have commented every .destroy() call)
-        // but issue still occurs
-        // For the record it's "hard" to reproduce but can be by running
-        // a lot of tests against a browser in the context of @jsenv/core testing
-        if (e.code === "ERR_HTTP2_INVALID_STREAM") {
-          return
-        }
-        responseStream.emit("error", e)
-      }
-    },
-    error: (value) => {
-      responseStream.emit("error", value)
-    },
-    complete: () => {
-      responseStream.end()
-    },
-  })
-
-  const winner = await winnerPromise
   await new Promise((resolve) => {
-    const raceEffects = {
-      abort: () => {
-        subscription.unsubscribe()
-        responseStream.destroy()
-        onAbort()
-        resolve()
+    raceCallbacks(
+      {
+        abort: (cb) => {
+          abortSignal.addEventListener("abort", cb)
+          return () => {
+            abortSignal.removeEventListener("abort", cb)
+          }
+        },
+        error: (cb) => {
+          responseStream.on("error", cb)
+          return () => {
+            responseStream.removeListener("error", cb)
+          }
+        },
+        close: (cb) => {
+          responseStream.on("close", cb)
+          return () => {
+            responseStream.removeListener("close", cb)
+          }
+        },
+        finish: (cb) => {
+          responseStream.on("finish", cb)
+          return () => {
+            responseStream.removeListener("finish", cb)
+          }
+        },
       },
-      error: (error) => {
-        subscription.unsubscribe()
-        responseStream.destroy()
-        onError(error)
-        resolve()
+      (winner) => {
+        const raceEffects = {
+          abort: () => {
+            subscription.unsubscribe()
+            responseStream.destroy()
+            onAbort()
+            resolve()
+          },
+          error: (error) => {
+            subscription.unsubscribe()
+            responseStream.destroy()
+            onError(error)
+            resolve()
+          },
+          close: () => {
+            // close body in case nodeResponse is prematurely closed
+            // while body is writing
+            // it may happen in case of server sent event
+            // where body is kept open to write to client
+            // and the browser is reloaded or closed for instance
+            subscription.unsubscribe()
+            responseStream.destroy()
+            onAbort()
+            resolve()
+          },
+          finish: () => {
+            onEnd()
+            resolve()
+          },
+        }
+        raceEffects[winner.name](winner.data)
+      },
+    )
+
+    const observable = bodyMethods.asObservable()
+    const subscription = observable.subscribe({
+      next: (data) => {
+        try {
+          responseStream.write(data)
+        } catch (e) {
+          // Something inside Node.js sometimes puts stream
+          // in a state where .write() throw despites nodeResponse.destroyed
+          // being undefined and "close" event not being emitted.
+          // I have tested if we are the one calling destroy
+          // (I have commented every .destroy() call)
+          // but issue still occurs
+          // For the record it's "hard" to reproduce but can be by running
+          // a lot of tests against a browser in the context of @jsenv/core testing
+          if (e.code === "ERR_HTTP2_INVALID_STREAM") {
+            return
+          }
+          responseStream.emit("error", e)
+        }
       },
-      close: () => {
-        // close body in case nodeResponse is prematurely closed
-        // while body is writing
-        // it may happen in case of server sent event
-        // where body is kept open to write to client
-        // and the browser is reloaded or closed for instance
-        subscription.unsubscribe()
-        onEnd()
-        resolve()
+      error: (value) => {
+        responseStream.emit("error", value)
       },
-      finish: () => {
-        onEnd()
-        resolve()
+      complete: () => {
+        responseStream.end()
       },
-    }
-    raceEffects[winner.name](winner.data)
+    })
   })
 }
 

package/src/startServer.js

@@ -3,9 +3,9 @@ import cluster from "node:cluster"
 import { memoize } from "@jsenv/filesystem"
 import { createDetailedMessage, createLogger } from "@jsenv/logger"
 
-import { Abort, Cleanup } from "./abort/main.js"
+import { createOperation, Abort } from "./abort/main.js"
+import { abortOperationOnProcessTeardown } from "./abort/process_teardown_abort.js"
 
-import { raceCallbacks } from "./internal/callback_race.js"
 import { createPolyglotServer } from "./internal/server-polyglot.js"
 import { trackServerPendingConnections } from "./internal/trackServerPendingConnections.js"
 import { trackServerPendingRequests } from "./internal/trackServerPendingRequests.js"
@@ -27,9 +27,10 @@ import {
   STOP_REASON_PROCESS_EXIT,
   STOP_REASON_NOT_SPECIFIED,
 } from "./stopReasons.js"
+import { raceProcessTeardownEvents } from "./abort/process_teardown_events.js"
 
 export const startServer = async ({
-  abortSignal = Abort.dormantSignal(),
+  abortSignal,
   logLevel,
   serverName = "server",
 
@@ -59,8 +60,7 @@ export const startServer = async ({
   sendServerInternalErrorDetails = false,
   serverInternalErrorToResponse = jsenvServerInternalErrorToResponse,
 
-  startedCallback = () => {},
-  stoppedCallback = () => {},
+  onStop = () => {},
   nagle = true,
 } = {}) => {
   if (protocol !== "http" && protocol !== "https") {
@@ -78,9 +78,23 @@ export const startServer = async ({
     throw new Error(`http2 needs "https" but protocol is "${protocol}"`)
   }
 
+  const serverOperation = createOperation({
+    abortSignal,
+  })
+  const processTeardownEvents = {
+    SIGHUP: stopOnExit,
+    SIGTERM: stopOnExit,
+    SIGINT: stopOnSIGINT,
+    beforeExit: stopOnExit,
+    exit: stopOnExit,
+  }
+  const cancelAbortOnProcessTeardown = abortOperationOnProcessTeardown(
+    serverOperation,
+    processTeardownEvents,
+  )
   // we "must" listen abort signal only while server is starting
   // after this, it's stop() that must be used
-  Abort.throwIfAborted(abortSignal)
+  Abort.throwIfAborted(serverOperation.abortSignal)
 
   const logger = createLogger({ logLevel })
   if (
@@ -113,29 +127,6 @@ export const startServer = async ({
     throw error
   }
 
-  const serverCleanup = Cleanup.create()
-
-  if (stopOnExit || stopOnSIGINT) {
-    raceCallbacks({
-      ...(stopOnExit ? EXIT_CALLBACKS : {}),
-      ...(stopOnSIGINT ? SIGINT_CALLBACKS : {}),
-      // to ensure other events are cleaned up when stop is called for other reasons
-      other_stop_reasons: (cb) => {
-        return serverCleanup.addCallback(cb)
-      },
-    }).then((winner) => {
-      const effects = {
-        SIGHUP: () => stop(STOP_REASON_PROCESS_SIGHUP),
-        SIGTERM: () => stop(STOP_REASON_PROCESS_SIGTERM),
-        SIGINT: () => stop(STOP_REASON_PROCESS_SIGINT),
-        beforeExit: () => stop(STOP_REASON_PROCESS_BEFORE_EXIT),
-        exit: () => stop(STOP_REASON_PROCESS_EXIT),
-        other_stop_reasons: () => {},
-      }
-      effects[winner.name]()
-    })
-  }
-
   const nodeServer = await createNodeServer({
     protocol,
     redirectHttpToHttps,
@@ -145,7 +136,7 @@ export const startServer = async ({
     http2,
     http1Allowed,
   })
-  Abort.throwIfAborted(abortSignal)
+  Abort.throwIfAborted(serverOperation.abortSignal)
 
   // https://nodejs.org/api/net.html#net_server_unref
   if (!keepProcessAlive) {
@@ -160,16 +151,16 @@ export const startServer = async ({
   const stop = memoize(async (reason = STOP_REASON_NOT_SPECIFIED) => {
     status = "stopping"
     logger.info(`${serverName} stopping server because ${reason}`)
+    onStop({ reason })
 
-    await serverCleanup.cleanup(reason)
+    await serverOperation.cleaner.clean(reason)
     await stopListening(nodeServer)
     status = "stopped"
-    stoppedCallback({ reason })
     stoppedResolve(reason)
   })
 
   port = await listen({
-    abortSignal,
+    abortSignal: serverOperation.abortSignal,
     server: nodeServer,
     port,
     portHint,
@@ -184,19 +175,19 @@ export const startServer = async ({
     nodeServer,
     onError,
   )
-  serverCleanup.addCallback(removeConnectionErrorListener)
+  serverOperation.cleaner.addCallback(removeConnectionErrorListener)
 
   const connectionsTracker = trackServerPendingConnections(nodeServer, {
     http2,
   })
   // opened connection must be shutdown before the close event is emitted
-  serverCleanup.addCallback(connectionsTracker.stop)
+  serverOperation.cleaner.addCallback(connectionsTracker.stop)
 
   const pendingRequestsTracker = trackServerPendingRequests(nodeServer, {
     http2,
   })
   // ensure pending requests got a response from the server
-  serverCleanup.addCallback((reason) => {
+  serverOperation.cleaner.addCallback((reason) => {
     pendingRequestsTracker.stop({
       status: reason === STOP_REASON_INTERNAL_ERROR ? 500 : 503,
       reason,
@@ -216,7 +207,7 @@ export const startServer = async ({
     }
 
     const request = nodeRequestToRequest(nodeRequest, {
-      serverCleanup,
+      serverOperation,
       serverOrigin,
     })
 
@@ -356,16 +347,18 @@ export const startServer = async ({
         parentHttp2Stream: pushStream,
       })
 
-      const responseLength = responseProperties.headers["content-length"] || 0
-      // should we check on "parentHttp2Stream" or "nodeResponse.stream"?
-      const { effectiveRecvDataLength, remoteWindowSize } =
-        parentHttp2Stream.session.state
-      if (effectiveRecvDataLength + responseLength > remoteWindowSize) {
-        addRequestLog(requestNode, {
-          type: "debug",
-          value: `Aborting stream to prevent exceeding remoteWindowSize`,
-        })
-        pushRequestAbortController.abort()
+      if (responseProperties !== ABORTED_RESPONSE_PROPERTIES) {
+        const responseLength = responseProperties.headers["content-length"] || 0
+        // should we check on "parentHttp2Stream" or "nodeResponse.stream"?
+        const { effectiveRecvDataLength, remoteWindowSize } =
+          parentHttp2Stream.session.state
+        if (effectiveRecvDataLength + responseLength > remoteWindowSize) {
+          addRequestLog(requestNode, {
+            type: "debug",
+            value: `Aborting stream to prevent exceeding remoteWindowSize`,
+          })
+          pushRequestAbortController.abort()
+        }
       }
 
       await sendResponse({
@@ -411,7 +404,7 @@ export const startServer = async ({
           }
         }
       })
-      let { error, responseProperties } = responseFromShortcircuit
+      let { aborted, error, responseProperties } = responseFromShortcircuit
         ? { responseProperties: responseFromShortcircuit }
         : await generateResponseDescription({
             requestToResponse,
@@ -429,6 +422,10 @@ export const startServer = async ({
             },
           })
 
+      if (aborted) {
+        return ABORTED_RESPONSE_PROPERTIES
+      }
+
       // internal error, create 500 response
       if (error) {
         if (
@@ -580,12 +577,25 @@ export const startServer = async ({
 
   const removeRequestListener = listenRequest(nodeServer, requestCallback)
   // ensure we don't try to handle new requests while server is stopping
-  serverCleanup.addCallback(removeRequestListener)
+  serverOperation.cleaner.addCallback(removeRequestListener)
 
   logger.info(
     `${serverName} started at ${serverOrigin} (${serverOrigins.external})`,
   )
-  startedCallback({ origin: serverOrigin })
+
+  cancelAbortOnProcessTeardown() // it's now handled by stop()
+  const cancelProcessTeardownRace = raceProcessTeardownEvents(
+    processTeardownEvents,
+    (winner) => {
+      stop(PROCESS_TEARDOWN_EVENTS_MAP[winner.name])
+    },
+  )
+  serverOperation.cleaner.addCallback(() => {
+    cancelProcessTeardownRace()
+  })
+  nodeServer.once("close", () => {
+    cancelProcessTeardownRace()
+  })
 
   return {
     getStatus: () => status,
@@ -636,6 +646,11 @@ const generateResponseDescription = async ({
       responseProperties: returnValue,
     }
   } catch (error) {
+    if (error.name === "AbortError" && request.abortSignal.aborted) {
+      return {
+        aborted: true,
+      }
+    }
     return {
       error,
     }
@@ -695,38 +710,12 @@ const testCanPushStream = (http2Stream) => {
   }
 }
 
-const EXIT_CALLBACKS = {
-  SIGHUP: (cb) => {
-    process.on("SIGHUP", cb)
-    return () => {
-      process.removeListener("SIGHUP", cb)
-    }
-  },
-  SIGTERM: (cb) => {
-    process.on("SIGTERM", cb)
-    return () => {
-      process.removeListener("SIGTERM", cb)
-    }
-  },
-  beforeExit: (cb) => {
-    process.on("beforeExit", cb)
-    return () => {
-      process.removeListener("beforeExit", cb)
-    }
-  },
-  exit: (cb) => {
-    process.on("exit", cb)
-    return () => {
-      process.removeListener("exit", cb)
-    }
-  },
-}
+const ABORTED_RESPONSE_PROPERTIES = {}
 
-const SIGINT_CALLBACKS = {
-  SIGINT: (cb) => {
-    process.on("SIGINT", cb)
-    return () => {
-      process.removeListener("SIGINT", cb)
-    }
-  },
+const PROCESS_TEARDOWN_EVENTS_MAP = {
+  SIGHUP: STOP_REASON_PROCESS_SIGHUP,
+  SIGTERM: STOP_REASON_PROCESS_SIGTERM,
+  SIGINT: STOP_REASON_PROCESS_SIGINT,
+  beforeExit: STOP_REASON_PROCESS_BEFORE_EXIT,
+  exit: STOP_REASON_PROCESS_EXIT,
 }

package/src/abort/cleanup.js

@@ -1,60 +0,0 @@
-export const Cleanup = {
-  create: () => {
-    let callbacks = []
-
-    const addCallback = (callback) => {
-      if (typeof callback !== "function") {
-        throw new Error(`callback must be a function, got ${callback}`)
-      }
-
-      // don't register twice
-      const existingCallback = callbacks.find((callbackCandidate) => {
-        return callbackCandidate === callback
-      })
-      if (existingCallback) {
-        if (typeof process.emitWarning === "object") {
-          process.emitWarning(`Trying to register same callback twice`, {
-            CODE: "CALLBACK_DUPLICATION",
-            detail: `It's often the sign that code is executd more than once`,
-          })
-        } else {
-          console.warn(`Trying to add same callback twice`)
-        }
-      } else {
-        callbacks = [...callbacks, callback]
-      }
-
-      return () => {
-        callbacks = arrayWithout(callbacks, callback)
-      }
-    }
-
-    const cleanup = async (reason) => {
-      const callbacksCopy = callbacks.slice()
-      callbacks.length = 0
-
-      await Promise.all(
-        callbacksCopy.map(async (callback) => {
-          await callback(reason)
-        }),
-      )
-    }
-
-    return { addCallback, cleanup }
-  },
-}
-
-const arrayWithout = (array, item) => {
-  if (array.length === 0) return array
-  const arrayWithoutItem = []
-  let i = 0
-  while (i < array.length) {
-    const value = array[i]
-    i++
-    if (value === item) {
-      continue
-    }
-    arrayWithoutItem.push(value)
-  }
-  return arrayWithoutItem
-}

package/src/internal/callback_race.js

@@ -1,59 +0,0 @@
-/*
- * Taking different code paths based on different inputs is messy
- * and code oftens forget to clean things behind itself
- * "raceCallbacks" helps to do both properly with the following API:
- *
- * const winnerPromise = raceCallbacks({
- *   timeout: (cb) => {
- *     const timeout = setTimeout(cb, 1000)
- *     return () => {
- *       clearTimeout(timeout)
- *     }
- *   },
- *   error: () => {
- *     something.on('error', cb)
- *     return () => {
- *        return something.removeListener('error', cb)
- *     }
- *   },
- *   end: () => {
- *     something.on('end', cb)
- *     return () => {
- *        return something.removeListener('end', cb)
- *     }
- *   }
- * })
- *
- * // do stuff
- *
- * const winner = await winnerPromise
- * {
- *   timeout: () => console.log('timeout after 1000ms'),
- *   error: (e) => console.error('error', e),
- *   end: (value) => console.log('end', value)
- * }[winner.name](winner.value)
- *
- */
-
-export const raceCallbacks = (raceDescription) => {
-  return new Promise((resolve) => {
-    const cleanupCallbacks = []
-    Object.keys(raceDescription).forEach((candidateName) => {
-      const register = raceDescription[candidateName]
-      const returnValue = register((data) => {
-        const cleanupCallbacksCopy = cleanupCallbacks.slice()
-        cleanupCallbacks.length = 0
-        cleanupCallbacksCopy.forEach((cleanup) => {
-          cleanup()
-        })
-        resolve({
-          name: candidateName,
-          data,
-        })
-      })
-      if (typeof returnValue === "function") {
-        cleanupCallbacks.push(returnValue)
-      }
-    })
-  })
-}