@whatwg-node/server 0.9.39 → 0.9.40

package/cjs/createServerAdapter.js

@@ -117,19 +117,18 @@ function createServerAdapter(serverAdapterBaseObject, options) {
         utils_js_1.nodeRequestResponseMap.set(nodeRequest, nodeResponse);
         return handleNodeRequest(nodeRequest, ...ctx);
     }
-    function requestListener(nodeRequest, serverResponse, ...ctx) {
+    function requestListener(nodeRequest, nodeResponse, ...ctx) {
         const waitUntilPromises = [];
         const defaultServerContext = {
             req: nodeRequest,
-            res: serverResponse,
+            res: nodeResponse,
             waitUntil(cb) {
                 waitUntilPromises.push(cb.catch(err => console.error(err)));
             },
         };
-        utils_js_1.nodeRequestResponseMap.set(nodeRequest, serverResponse);
         let response$;
         try {
-            response$ = handleNodeRequest(nodeRequest, defaultServerContext, ...ctx);
+            response$ = handleNodeRequestAndResponse(nodeRequest, nodeResponse, defaultServerContext, ...ctx);
         }
         catch (err) {
             response$ = (0, utils_js_1.handleErrorFromRequestHandler)(err, fetchAPI.Response);
@@ -137,13 +136,13 @@ function createServerAdapter(serverAdapterBaseObject, options) {
         if ((0, utils_js_1.isPromise)(response$)) {
             return response$
                 .catch((e) => (0, utils_js_1.handleErrorFromRequestHandler)(e, fetchAPI.Response))
-                .then(response => (0, utils_js_1.sendNodeResponse)(response, serverResponse, nodeRequest))
+                .then(response => (0, utils_js_1.sendNodeResponse)(response, nodeResponse, nodeRequest))
                 .catch(err => {
                 console.error(`Unexpected error while handling request: ${err.message || err}`);
             });
         }
         try {
-            return (0, utils_js_1.sendNodeResponse)(response$, serverResponse, nodeRequest);
+            return (0, utils_js_1.sendNodeResponse)(response$, nodeResponse, nodeRequest);
         }
         catch (err) {
             console.error(`Unexpected error while handling request: ${err.message || err}`);
@@ -285,7 +284,7 @@ function createServerAdapter(serverAdapterBaseObject, options) {
         return fetchFn(input, ...maybeCtx);
     };
     const adapterObj = {
-        handleRequest,
+        handleRequest: handleRequestWithWaitUntil,
         fetch: fetchFn,
         handleNodeRequest,
         handleNodeRequestAndResponse,

package/esm/createServerAdapter.js

@@ -113,19 +113,18 @@ function createServerAdapter(serverAdapterBaseObject, options) {
         nodeRequestResponseMap.set(nodeRequest, nodeResponse);
         return handleNodeRequest(nodeRequest, ...ctx);
     }
-    function requestListener(nodeRequest, serverResponse, ...ctx) {
+    function requestListener(nodeRequest, nodeResponse, ...ctx) {
         const waitUntilPromises = [];
         const defaultServerContext = {
             req: nodeRequest,
-            res: serverResponse,
+            res: nodeResponse,
             waitUntil(cb) {
                 waitUntilPromises.push(cb.catch(err => console.error(err)));
             },
         };
-        nodeRequestResponseMap.set(nodeRequest, serverResponse);
         let response$;
         try {
-            response$ = handleNodeRequest(nodeRequest, defaultServerContext, ...ctx);
+            response$ = handleNodeRequestAndResponse(nodeRequest, nodeResponse, defaultServerContext, ...ctx);
         }
         catch (err) {
             response$ = handleErrorFromRequestHandler(err, fetchAPI.Response);
@@ -133,13 +132,13 @@ function createServerAdapter(serverAdapterBaseObject, options) {
         if (isPromise(response$)) {
             return response$
                 .catch((e) => handleErrorFromRequestHandler(e, fetchAPI.Response))
-                .then(response => sendNodeResponse(response, serverResponse, nodeRequest))
+                .then(response => sendNodeResponse(response, nodeResponse, nodeRequest))
                 .catch(err => {
                 console.error(`Unexpected error while handling request: ${err.message || err}`);
             });
         }
         try {
-            return sendNodeResponse(response$, serverResponse, nodeRequest);
+            return sendNodeResponse(response$, nodeResponse, nodeRequest);
         }
         catch (err) {
             console.error(`Unexpected error while handling request: ${err.message || err}`);
@@ -281,7 +280,7 @@ function createServerAdapter(serverAdapterBaseObject, options) {
         return fetchFn(input, ...maybeCtx);
     };
     const adapterObj = {
-        handleRequest,
+        handleRequest: handleRequestWithWaitUntil,
         fetch: fetchFn,
         handleNodeRequest,
         handleNodeRequestAndResponse,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@whatwg-node/server",
-  "version": "0.9.39",
+  "version": "0.9.40",
   "description": "Fetch API compliant HTTP Server adapter",
   "sideEffects": false,
   "dependencies": {

package/typings/plugins/types.d.cts

@@ -1,13 +1,13 @@
-import { FetchAPI, ServerAdapterRequestHandler } from '../types.cjs';
+import { FetchAPI, ServerAdapterRequestHandler, type ServerAdapterInitialContext } from '../types.cjs';
 export interface ServerAdapterPlugin<TServerContext = {}> {
-    onRequest?: OnRequestHook<TServerContext>;
-    onResponse?: OnResponseHook<TServerContext>;
+    onRequest?: OnRequestHook<TServerContext & ServerAdapterInitialContext>;
+    onResponse?: OnResponseHook<TServerContext & ServerAdapterInitialContext>;
 }
 export type OnRequestHook<TServerContext> = (payload: OnRequestEventPayload<TServerContext>) => Promise<void> | void;
 export interface OnRequestEventPayload<TServerContext> {
     request: Request;
     setRequest(newRequest: Request): void;
-    serverContext: TServerContext | undefined;
+    serverContext: TServerContext;
     fetchAPI: FetchAPI;
     requestHandler: ServerAdapterRequestHandler<TServerContext>;
     setRequestHandler(newRequestHandler: ServerAdapterRequestHandler<TServerContext>): void;
@@ -17,7 +17,7 @@ export interface OnRequestEventPayload<TServerContext> {
 export type OnResponseHook<TServerContext> = (payload: OnResponseEventPayload<TServerContext>) => Promise<void> | void;
 export interface OnResponseEventPayload<TServerContext> {
     request: Request;
-    serverContext: TServerContext | undefined;
+    serverContext: TServerContext;
     response: Response;
     setResponse(newResponse: Response): void;
     fetchAPI: FetchAPI;

package/typings/plugins/types.d.ts

@@ -1,13 +1,13 @@
-import { FetchAPI, ServerAdapterRequestHandler } from '../types.js';
+import { FetchAPI, ServerAdapterRequestHandler, type ServerAdapterInitialContext } from '../types.js';
 export interface ServerAdapterPlugin<TServerContext = {}> {
-    onRequest?: OnRequestHook<TServerContext>;
-    onResponse?: OnResponseHook<TServerContext>;
+    onRequest?: OnRequestHook<TServerContext & ServerAdapterInitialContext>;
+    onResponse?: OnResponseHook<TServerContext & ServerAdapterInitialContext>;
 }
 export type OnRequestHook<TServerContext> = (payload: OnRequestEventPayload<TServerContext>) => Promise<void> | void;
 export interface OnRequestEventPayload<TServerContext> {
     request: Request;
     setRequest(newRequest: Request): void;
-    serverContext: TServerContext | undefined;
+    serverContext: TServerContext;
     fetchAPI: FetchAPI;
     requestHandler: ServerAdapterRequestHandler<TServerContext>;
     setRequestHandler(newRequestHandler: ServerAdapterRequestHandler<TServerContext>): void;
@@ -17,7 +17,7 @@ export interface OnRequestEventPayload<TServerContext> {
 export type OnResponseHook<TServerContext> = (payload: OnResponseEventPayload<TServerContext>) => Promise<void> | void;
 export interface OnResponseEventPayload<TServerContext> {
     request: Request;
-    serverContext: TServerContext | undefined;
+    serverContext: TServerContext;
     response: Response;
     setResponse(newResponse: Response): void;
     fetchAPI: FetchAPI;

package/typings/types.d.cts

@@ -17,7 +17,7 @@ export interface ServerAdapterObject<TServerContext> extends EventListenerObject
     /**
      * A basic request listener that takes a `Request` with the server context and returns a `Response`.
      */
-    handleRequest: (request: Request, ctx: TServerContext) => Promise<Response> | Response;
+    handleRequest: (request: Request, ctx: TServerContext & Partial<ServerAdapterInitialContext>) => Promise<Response> | Response;
     /**
      * WHATWG Fetch spec compliant `fetch` function that can be used for testing purposes.
      */
@@ -33,27 +33,29 @@ export interface ServerAdapterObject<TServerContext> extends EventListenerObject
     fetch(url: URL, init: RequestInit, ...ctx: Partial<TServerContext>[]): Promise<Response> | Response;
     /**
      * This function takes Node's request object and returns a WHATWG Fetch spec compliant `Response` object.
+     *
+     * @deprecated Use `handleNodeRequestAndResponse` instead.
      **/
-    handleNodeRequest(nodeRequest: NodeRequest, ...ctx: Partial<TServerContext>[]): Promise<Response> | Response;
+    handleNodeRequest(nodeRequest: NodeRequest, ...ctx: Partial<TServerContext & ServerAdapterInitialContext>[]): Promise<Response> | Response;
     /**
      * This function takes Node's request and response objects and returns a WHATWG Fetch spec compliant `Response` object.
      */
     handleNodeRequestAndResponse(nodeRequest: NodeRequest, nodeResponseOrContainer: {
         raw: NodeResponse;
-    } | NodeResponse, ...ctx: Partial<TServerContext>[]): Promise<Response> | Response;
+    } | NodeResponse, ...ctx: Partial<TServerContext & ServerAdapterInitialContext>[]): Promise<Response> | Response;
     /**
      * A request listener function that can be used with any Node server variation.
      */
     requestListener: RequestListener;
     handleUWS: UWSHandler;
-    handle(req: NodeRequest, res: NodeResponse, ...ctx: Partial<TServerContext>[]): Promise<void>;
-    handle(requestLike: RequestLike, ...ctx: Partial<TServerContext>[]): Promise<Response> | Response;
-    handle(request: Request, ...ctx: Partial<TServerContext>[]): Promise<Response> | Response;
-    handle(fetchEvent: FetchEvent & Partial<TServerContext>, ...ctx: Partial<TServerContext>[]): void;
-    handle(res: UWSResponse, req: UWSRequest, ...ctx: Partial<TServerContext>[]): Promise<void>;
+    handle(req: NodeRequest, res: NodeResponse, ...ctx: Partial<TServerContext & ServerAdapterInitialContext>[]): Promise<void>;
+    handle(requestLike: RequestLike, ...ctx: Partial<TServerContext & ServerAdapterInitialContext>[]): Promise<Response> | Response;
+    handle(request: Request, ...ctx: Partial<TServerContext & ServerAdapterInitialContext>[]): Promise<Response> | Response;
+    handle(fetchEvent: FetchEvent & Partial<TServerContext & ServerAdapterInitialContext>, ...ctx: Partial<TServerContext>[]): void;
+    handle(res: UWSResponse, req: UWSRequest, ...ctx: Partial<TServerContext & ServerAdapterInitialContext>[]): Promise<void>;
     handle(container: {
         request: Request;
-    } & Partial<TServerContext>, ...ctx: Partial<TServerContext>[]): Promise<Response> | Response;
+    } & Partial<TServerContext & ServerAdapterInitialContext>, ...ctx: Partial<TServerContext & ServerAdapterInitialContext>[]): Promise<Response> | Response;
 }
 export interface RequestLike {
     url: string;
@@ -67,10 +69,20 @@ export interface HeadersLike extends Iterable<[string, string]> {
     has(name: string): boolean;
 }
 export type ServerAdapter<TServerContext, TBaseObject extends ServerAdapterBaseObject<TServerContext>> = TBaseObject & ServerAdapterObject<TServerContext>['handle'] & ServerAdapterObject<TServerContext>;
-export type ServerAdapterRequestHandler<TServerContext> = (request: Request, ctx: TServerContext) => Promise<Response> | Response;
+export type ServerAdapterRequestHandler<TServerContext> = (request: Request, ctx: TServerContext & ServerAdapterInitialContext) => Promise<Response> | Response;
 export type ServerAdapterNodeContext = {
     req: NodeRequest;
     res: NodeResponse;
 };
-export type WaitUntilFn = (promise: Promise<void> | void) => void;
+export type WaitUntilFn = (promise: Promise<unknown>) => void;
 export type FetchAPI = ReturnType<typeof import('@whatwg-node/fetch').createFetch>;
+export type ServerAdapterInitialContext = {
+    /**
+     * Register a promise that should be waited in the background for before the server process is exited.
+     *
+     * This also avoids unhandled promise rejections, which would otherwise cause the process to exit on some environment like Node.
+     * @param promise The promise to wait for
+     * @returns
+     */
+    waitUntil: WaitUntilFn;
+};

package/typings/types.d.ts

@@ -17,7 +17,7 @@ export interface ServerAdapterObject<TServerContext> extends EventListenerObject
     /**
      * A basic request listener that takes a `Request` with the server context and returns a `Response`.
      */
-    handleRequest: (request: Request, ctx: TServerContext) => Promise<Response> | Response;
+    handleRequest: (request: Request, ctx: TServerContext & Partial<ServerAdapterInitialContext>) => Promise<Response> | Response;
     /**
      * WHATWG Fetch spec compliant `fetch` function that can be used for testing purposes.
      */
@@ -33,27 +33,29 @@ export interface ServerAdapterObject<TServerContext> extends EventListenerObject
     fetch(url: URL, init: RequestInit, ...ctx: Partial<TServerContext>[]): Promise<Response> | Response;
     /**
      * This function takes Node's request object and returns a WHATWG Fetch spec compliant `Response` object.
+     *
+     * @deprecated Use `handleNodeRequestAndResponse` instead.
      **/
-    handleNodeRequest(nodeRequest: NodeRequest, ...ctx: Partial<TServerContext>[]): Promise<Response> | Response;
+    handleNodeRequest(nodeRequest: NodeRequest, ...ctx: Partial<TServerContext & ServerAdapterInitialContext>[]): Promise<Response> | Response;
     /**
      * This function takes Node's request and response objects and returns a WHATWG Fetch spec compliant `Response` object.
      */
     handleNodeRequestAndResponse(nodeRequest: NodeRequest, nodeResponseOrContainer: {
         raw: NodeResponse;
-    } | NodeResponse, ...ctx: Partial<TServerContext>[]): Promise<Response> | Response;
+    } | NodeResponse, ...ctx: Partial<TServerContext & ServerAdapterInitialContext>[]): Promise<Response> | Response;
     /**
      * A request listener function that can be used with any Node server variation.
      */
     requestListener: RequestListener;
     handleUWS: UWSHandler;
-    handle(req: NodeRequest, res: NodeResponse, ...ctx: Partial<TServerContext>[]): Promise<void>;
-    handle(requestLike: RequestLike, ...ctx: Partial<TServerContext>[]): Promise<Response> | Response;
-    handle(request: Request, ...ctx: Partial<TServerContext>[]): Promise<Response> | Response;
-    handle(fetchEvent: FetchEvent & Partial<TServerContext>, ...ctx: Partial<TServerContext>[]): void;
-    handle(res: UWSResponse, req: UWSRequest, ...ctx: Partial<TServerContext>[]): Promise<void>;
+    handle(req: NodeRequest, res: NodeResponse, ...ctx: Partial<TServerContext & ServerAdapterInitialContext>[]): Promise<void>;
+    handle(requestLike: RequestLike, ...ctx: Partial<TServerContext & ServerAdapterInitialContext>[]): Promise<Response> | Response;
+    handle(request: Request, ...ctx: Partial<TServerContext & ServerAdapterInitialContext>[]): Promise<Response> | Response;
+    handle(fetchEvent: FetchEvent & Partial<TServerContext & ServerAdapterInitialContext>, ...ctx: Partial<TServerContext>[]): void;
+    handle(res: UWSResponse, req: UWSRequest, ...ctx: Partial<TServerContext & ServerAdapterInitialContext>[]): Promise<void>;
     handle(container: {
         request: Request;
-    } & Partial<TServerContext>, ...ctx: Partial<TServerContext>[]): Promise<Response> | Response;
+    } & Partial<TServerContext & ServerAdapterInitialContext>, ...ctx: Partial<TServerContext & ServerAdapterInitialContext>[]): Promise<Response> | Response;
 }
 export interface RequestLike {
     url: string;
@@ -67,10 +69,20 @@ export interface HeadersLike extends Iterable<[string, string]> {
     has(name: string): boolean;
 }
 export type ServerAdapter<TServerContext, TBaseObject extends ServerAdapterBaseObject<TServerContext>> = TBaseObject & ServerAdapterObject<TServerContext>['handle'] & ServerAdapterObject<TServerContext>;
-export type ServerAdapterRequestHandler<TServerContext> = (request: Request, ctx: TServerContext) => Promise<Response> | Response;
+export type ServerAdapterRequestHandler<TServerContext> = (request: Request, ctx: TServerContext & ServerAdapterInitialContext) => Promise<Response> | Response;
 export type ServerAdapterNodeContext = {
     req: NodeRequest;
     res: NodeResponse;
 };
-export type WaitUntilFn = (promise: Promise<void> | void) => void;
+export type WaitUntilFn = (promise: Promise<unknown>) => void;
 export type FetchAPI = ReturnType<typeof import('@whatwg-node/fetch').createFetch>;
+export type ServerAdapterInitialContext = {
+    /**
+     * Register a promise that should be waited in the background for before the server process is exited.
+     *
+     * This also avoids unhandled promise rejections, which would otherwise cause the process to exit on some environment like Node.
+     * @param promise The promise to wait for
+     * @returns
+     */
+    waitUntil: WaitUntilFn;
+};