@whatwg-node/server 0.4.5 → 0.4.6-alpha-20220922124249-c941ae6

package/README.md

@@ -117,7 +117,10 @@ app.route({
   url: '/mypath',
   method: ['GET', 'POST', 'OPTIONS'],
   handler: async (req, reply) => {
-    const response = await myServerAdapter.handleNodeRequest(req)
+    const response = await myServerAdapter.handleNodeRequest(req, {
+      req,
+      reply,
+    })
     response.headers.forEach((value, key) => {
       reply.header(key, value)
     })

package/index.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 /// <reference lib="webworker" />
-import type { RequestListener, ServerResponse } from 'node:http';
+import type { IncomingMessage, ServerResponse } from 'node:http';
 import { NodeRequest } from './utils';
 export interface ServerAdapterBaseObject<TServerContext, THandleRequest extends ServerAdapterRequestHandler<TServerContext> = ServerAdapterRequestHandler<TServerContext>> {
     /**
@@ -17,26 +17,32 @@ export interface ServerAdapterObject<TServerContext, TBaseObject extends ServerA
     /**
      * WHATWG Fetch spec compliant `fetch` function that can be used for testing purposes.
      */
-    fetch(request: Request, ...ctx: any[]): Promise<Response> | Response;
-    fetch(urlStr: string, ...ctx: any[]): Promise<Response> | Response;
-    fetch(urlStr: string, init: RequestInit, ...ctx: any[]): Promise<Response> | Response;
-    fetch(url: URL, ...ctx: any[]): Promise<Response> | Response;
-    fetch(url: URL, init: RequestInit, ...ctx: any[]): Promise<Response> | Response;
+    fetch(request: Request, ctx: TServerContext): Promise<Response> | Response;
+    fetch(request: Request, ...ctx: Partial<TServerContext>[]): Promise<Response> | Response;
+    fetch(urlStr: string, ctx: TServerContext): Promise<Response> | Response;
+    fetch(urlStr: string, ...ctx: Partial<TServerContext>[]): Promise<Response> | Response;
+    fetch(urlStr: string, init: RequestInit, ctx: TServerContext): Promise<Response> | Response;
+    fetch(urlStr: string, init: RequestInit, ...ctx: Partial<TServerContext>[]): Promise<Response> | Response;
+    fetch(url: URL, ctx: TServerContext): Promise<Response> | Response;
+    fetch(url: URL, ...ctx: Partial<TServerContext>[]): Promise<Response> | Response;
+    fetch(url: URL, init: RequestInit, ctx: TServerContext): Promise<Response> | Response;
+    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.
      **/
-    handleNodeRequest(nodeRequest: NodeRequest, serverContext: TServerContext): Promise<Response> | Response;
+    handleNodeRequest(nodeRequest: NodeRequest, ctx: TServerContext): Promise<Response> | Response;
     /**
      * A request listener function that can be used with any Node server variation.
      */
-    requestListener: RequestListener;
+    requestListener(req: IncomingMessage, res: ServerResponse, ctx: TServerContext): void;
+    requestListener(req: IncomingMessage, res: ServerResponse, ...ctx: Partial<TServerContext>[]): void;
     /**
      * Proxy to requestListener to mimic Node middlewares
      */
-    handle: RequestListener & ServerAdapterObject<TServerContext, TBaseObject>['fetch'];
+    handle: ServerAdapterObject<TServerContext, TBaseObject>['requestListener'] & ServerAdapterObject<TServerContext, TBaseObject>['fetch'];
 }
-export declare type ServerAdapter<TServerContext, TBaseObject extends ServerAdapterBaseObject<TServerContext>> = TBaseObject & RequestListener & ServerAdapterObject<TServerContext, TBaseObject>['fetch'] & ServerAdapterObject<TServerContext, TBaseObject>;
-export declare type ServerAdapterRequestHandler<TServerContext> = (request: Request, serverContext: TServerContext) => Promise<Response> | Response;
+export declare type ServerAdapter<TServerContext, TBaseObject extends ServerAdapterBaseObject<TServerContext>> = TBaseObject & ServerAdapterObject<TServerContext, TBaseObject>['requestListener'] & ServerAdapterObject<TServerContext, TBaseObject>['fetch'] & ServerAdapterObject<TServerContext, TBaseObject>;
+export declare type ServerAdapterRequestHandler<TServerContext> = (request: Request, ctx: TServerContext) => Promise<Response> | Response;
 export declare type DefaultServerAdapterContext = {
     req: NodeRequest;
     res: ServerResponse;

package/index.js

@@ -154,6 +154,23 @@ async function sendNodeResponse({ headers, status, statusText, body }, serverRes
         }
     });
 }
+function isRequestInit(val) {
+    return (val != null &&
+        typeof val === 'object' &&
+        ('body' in val ||
+            'cache' in val ||
+            'credentials' in val ||
+            'headers' in val ||
+            'integrity' in val ||
+            'keepalive' in val ||
+            'method' in val ||
+            'mode' in val ||
+            'redirect' in val ||
+            'referrer' in val ||
+            'referrerPolicy' in val ||
+            'signal' in val ||
+            'window' in val));
+}
 
 /// <reference lib="webworker" />
 async function handleWaitUntils(waitUntilPromises) {
@@ -170,13 +187,18 @@ function createServerAdapter(serverAdapterBaseObject,
  */
 RequestCtor = fetch.Request) {
     const handleRequest = typeof serverAdapterBaseObject === 'function' ? serverAdapterBaseObject : serverAdapterBaseObject.handle;
-    function handleNodeRequest(nodeRequest, serverContext) {
+    function handleNodeRequest(nodeRequest, ctx) {
         const request = normalizeNodeRequest(nodeRequest, RequestCtor);
-        return handleRequest(request, serverContext);
+        return handleRequest(request, ctx);
     }
-    async function requestListener(nodeRequest, serverResponse) {
+    async function requestListener(nodeRequest, serverResponse, ...ctx) {
         const waitUntilPromises = [];
+        let serverContext = {};
+        if ((ctx === null || ctx === void 0 ? void 0 : ctx.length) > 0) {
+            serverContext = Object.assign({}, serverContext, ...ctx);
+        }
         const response = await handleNodeRequest(nodeRequest, {
+            ...serverContext,
             req: nodeRequest,
             res: serverResponse,
             waitUntil(p) {
@@ -195,30 +217,34 @@ RequestCtor = fetch.Request) {
         if (waitUntilPromises.length > 0) {
             await handleWaitUntils(waitUntilPromises);
         }
+        return response;
     }
-    function handleEvent(event) {
+    function handleEvent(event, ...ctx) {
         if (!event.respondWith || !event.request) {
             throw new TypeError(`Expected FetchEvent, got ${event}`);
         }
-        const response$ = handleRequest(event.request, event);
+        let serverContext = {};
+        if ((ctx === null || ctx === void 0 ? void 0 : ctx.length) > 0) {
+            serverContext = Object.assign({}, serverContext, ...ctx);
+        }
+        const response$ = handleRequest(event.request, serverContext);
         event.respondWith(response$);
+        return response$;
     }
-    function handleRequestWithWaitUntil(request, ctx = {}, ...rest) {
+    function handleRequestWithWaitUntil(request, ctx) {
         var _a;
+        const extendedCtx = ctx;
         if ('process' in globalThis && ((_a = process.versions) === null || _a === void 0 ? void 0 : _a['bun']) != null) {
             // This is required for bun
             request.text();
         }
-        if ((rest === null || rest === void 0 ? void 0 : rest.length) > 0) {
-            ctx = Object.assign({}, ctx, ...rest);
-        }
-        if (!ctx.waitUntil) {
+        if (!extendedCtx.waitUntil) {
             const waitUntilPromises = [];
-            ctx.waitUntil = (p) => {
+            extendedCtx.waitUntil = (p) => {
                 waitUntilPromises.push(p);
             };
             const response$ = handleRequest(request, {
-                ...ctx,
+                ...extendedCtx,
                 waitUntil(p) {
                     waitUntilPromises.push(p);
                 },
@@ -228,32 +254,51 @@ RequestCtor = fetch.Request) {
             }
             return response$;
         }
-        return handleRequest(request, ctx);
+        return handleRequest(request, extendedCtx);
     }
-    function genericRequestHandler(input, ctx, ...rest) {
+    const fetchFn = (input, initOrCtx, ...ctx) => {
+        let init;
+        let serverContext = {};
+        if (isRequestInit(initOrCtx)) {
+            init = initOrCtx;
+        }
+        else {
+            init = {};
+            serverContext = Object.assign({}, serverContext, initOrCtx);
+        }
+        if ((ctx === null || ctx === void 0 ? void 0 : ctx.length) > 0) {
+            serverContext = Object.assign({}, serverContext, ...ctx);
+        }
+        if (typeof input === 'string' || input instanceof URL) {
+            return handleRequestWithWaitUntil(new RequestCtor(input, init), serverContext);
+        }
+        return handleRequestWithWaitUntil(input, serverContext);
+    };
+    const genericRequestHandler = (input, initOrCtxOrRes, ...ctx) => {
         // If it is a Node request
-        if (isReadable(input) && ctx != null && isServerResponse(ctx)) {
-            return requestListener(input, ctx);
+        if (isReadable(input) && isServerResponse(initOrCtxOrRes)) {
+            return requestListener(input, initOrCtxOrRes, ...ctx);
+        }
+        if (isServerResponse(initOrCtxOrRes)) {
+            throw new Error('Got Node response without Node request');
         }
         // Is input a container object over Request?
-        if (input.request) {
+        if (typeof input === 'object' && 'request' in input) {
             // Is it FetchEvent?
-            if (input.respondWith) {
-                return handleEvent(input);
+            if ('respondWith' in input) {
+                return handleEvent(input, isRequestInit(initOrCtxOrRes) ? {} : initOrCtxOrRes, ...ctx);
             }
             // In this input is also the context
-            return handleRequestWithWaitUntil(input.request, input, ...rest);
+            return fetchFn(
+            // @ts-expect-error input can indeed be a Request
+            input.request, initOrCtxOrRes, ...ctx);
         }
         // Or is it Request itself?
         // Then ctx is present and it is the context
-        return handleRequestWithWaitUntil(input, ctx, ...rest);
-    }
-    function fetchFn(input, init, ...ctx) {
-        if (typeof input === 'string' || input instanceof URL) {
-            return handleRequestWithWaitUntil(new RequestCtor(input, init), ...ctx);
-        }
-        return handleRequestWithWaitUntil(input, init, ...ctx);
-    }
+        return fetchFn(
+        // @ts-expect-error input can indeed string | Request | URL
+        input, initOrCtxOrRes, ...ctx);
+    };
     const adapterObj = {
         handleRequest,
         fetch: fetchFn,
@@ -277,12 +322,12 @@ RequestCtor = fetch.Request) {
                 }
                 return adapterProp;
             }
-            const genericRequestHandlerProp = genericRequestHandler[prop];
-            if (genericRequestHandlerProp) {
-                if (genericRequestHandlerProp.bind) {
-                    return genericRequestHandlerProp.bind(genericRequestHandler);
+            const handleProp = genericRequestHandler[prop];
+            if (handleProp) {
+                if (handleProp.bind) {
+                    return handleProp.bind(genericRequestHandler);
                 }
-                return genericRequestHandlerProp;
+                return handleProp;
             }
             if (serverAdapterBaseObject) {
                 const serverAdapterBaseObjectProp = serverAdapterBaseObject[prop];
@@ -297,7 +342,7 @@ RequestCtor = fetch.Request) {
         apply(_, __, [input, ctx]) {
             return genericRequestHandler(input, ctx);
         },
-    });
+    }); // 😡
 }
 
 exports.createServerAdapter = createServerAdapter;

package/index.mjs

@@ -150,6 +150,23 @@ async function sendNodeResponse({ headers, status, statusText, body }, serverRes
         }
     });
 }
+function isRequestInit(val) {
+    return (val != null &&
+        typeof val === 'object' &&
+        ('body' in val ||
+            'cache' in val ||
+            'credentials' in val ||
+            'headers' in val ||
+            'integrity' in val ||
+            'keepalive' in val ||
+            'method' in val ||
+            'mode' in val ||
+            'redirect' in val ||
+            'referrer' in val ||
+            'referrerPolicy' in val ||
+            'signal' in val ||
+            'window' in val));
+}
 
 /// <reference lib="webworker" />
 async function handleWaitUntils(waitUntilPromises) {
@@ -166,13 +183,18 @@ function createServerAdapter(serverAdapterBaseObject,
  */
 RequestCtor = Request) {
     const handleRequest = typeof serverAdapterBaseObject === 'function' ? serverAdapterBaseObject : serverAdapterBaseObject.handle;
-    function handleNodeRequest(nodeRequest, serverContext) {
+    function handleNodeRequest(nodeRequest, ctx) {
         const request = normalizeNodeRequest(nodeRequest, RequestCtor);
-        return handleRequest(request, serverContext);
+        return handleRequest(request, ctx);
     }
-    async function requestListener(nodeRequest, serverResponse) {
+    async function requestListener(nodeRequest, serverResponse, ...ctx) {
         const waitUntilPromises = [];
+        let serverContext = {};
+        if ((ctx === null || ctx === void 0 ? void 0 : ctx.length) > 0) {
+            serverContext = Object.assign({}, serverContext, ...ctx);
+        }
         const response = await handleNodeRequest(nodeRequest, {
+            ...serverContext,
             req: nodeRequest,
             res: serverResponse,
             waitUntil(p) {
@@ -191,30 +213,34 @@ RequestCtor = Request) {
         if (waitUntilPromises.length > 0) {
             await handleWaitUntils(waitUntilPromises);
         }
+        return response;
     }
-    function handleEvent(event) {
+    function handleEvent(event, ...ctx) {
         if (!event.respondWith || !event.request) {
             throw new TypeError(`Expected FetchEvent, got ${event}`);
         }
-        const response$ = handleRequest(event.request, event);
+        let serverContext = {};
+        if ((ctx === null || ctx === void 0 ? void 0 : ctx.length) > 0) {
+            serverContext = Object.assign({}, serverContext, ...ctx);
+        }
+        const response$ = handleRequest(event.request, serverContext);
         event.respondWith(response$);
+        return response$;
     }
-    function handleRequestWithWaitUntil(request, ctx = {}, ...rest) {
+    function handleRequestWithWaitUntil(request, ctx) {
         var _a;
+        const extendedCtx = ctx;
         if ('process' in globalThis && ((_a = process.versions) === null || _a === void 0 ? void 0 : _a['bun']) != null) {
             // This is required for bun
             request.text();
         }
-        if ((rest === null || rest === void 0 ? void 0 : rest.length) > 0) {
-            ctx = Object.assign({}, ctx, ...rest);
-        }
-        if (!ctx.waitUntil) {
+        if (!extendedCtx.waitUntil) {
             const waitUntilPromises = [];
-            ctx.waitUntil = (p) => {
+            extendedCtx.waitUntil = (p) => {
                 waitUntilPromises.push(p);
             };
             const response$ = handleRequest(request, {
-                ...ctx,
+                ...extendedCtx,
                 waitUntil(p) {
                     waitUntilPromises.push(p);
                 },
@@ -224,32 +250,51 @@ RequestCtor = Request) {
             }
             return response$;
         }
-        return handleRequest(request, ctx);
+        return handleRequest(request, extendedCtx);
     }
-    function genericRequestHandler(input, ctx, ...rest) {
+    const fetchFn = (input, initOrCtx, ...ctx) => {
+        let init;
+        let serverContext = {};
+        if (isRequestInit(initOrCtx)) {
+            init = initOrCtx;
+        }
+        else {
+            init = {};
+            serverContext = Object.assign({}, serverContext, initOrCtx);
+        }
+        if ((ctx === null || ctx === void 0 ? void 0 : ctx.length) > 0) {
+            serverContext = Object.assign({}, serverContext, ...ctx);
+        }
+        if (typeof input === 'string' || input instanceof URL) {
+            return handleRequestWithWaitUntil(new RequestCtor(input, init), serverContext);
+        }
+        return handleRequestWithWaitUntil(input, serverContext);
+    };
+    const genericRequestHandler = (input, initOrCtxOrRes, ...ctx) => {
         // If it is a Node request
-        if (isReadable(input) && ctx != null && isServerResponse(ctx)) {
-            return requestListener(input, ctx);
+        if (isReadable(input) && isServerResponse(initOrCtxOrRes)) {
+            return requestListener(input, initOrCtxOrRes, ...ctx);
+        }
+        if (isServerResponse(initOrCtxOrRes)) {
+            throw new Error('Got Node response without Node request');
         }
         // Is input a container object over Request?
-        if (input.request) {
+        if (typeof input === 'object' && 'request' in input) {
             // Is it FetchEvent?
-            if (input.respondWith) {
-                return handleEvent(input);
+            if ('respondWith' in input) {
+                return handleEvent(input, isRequestInit(initOrCtxOrRes) ? {} : initOrCtxOrRes, ...ctx);
             }
             // In this input is also the context
-            return handleRequestWithWaitUntil(input.request, input, ...rest);
+            return fetchFn(
+            // @ts-expect-error input can indeed be a Request
+            input.request, initOrCtxOrRes, ...ctx);
         }
         // Or is it Request itself?
         // Then ctx is present and it is the context
-        return handleRequestWithWaitUntil(input, ctx, ...rest);
-    }
-    function fetchFn(input, init, ...ctx) {
-        if (typeof input === 'string' || input instanceof URL) {
-            return handleRequestWithWaitUntil(new RequestCtor(input, init), ...ctx);
-        }
-        return handleRequestWithWaitUntil(input, init, ...ctx);
-    }
+        return fetchFn(
+        // @ts-expect-error input can indeed string | Request | URL
+        input, initOrCtxOrRes, ...ctx);
+    };
     const adapterObj = {
         handleRequest,
         fetch: fetchFn,
@@ -273,12 +318,12 @@ RequestCtor = Request) {
                 }
                 return adapterProp;
             }
-            const genericRequestHandlerProp = genericRequestHandler[prop];
-            if (genericRequestHandlerProp) {
-                if (genericRequestHandlerProp.bind) {
-                    return genericRequestHandlerProp.bind(genericRequestHandler);
+            const handleProp = genericRequestHandler[prop];
+            if (handleProp) {
+                if (handleProp.bind) {
+                    return handleProp.bind(genericRequestHandler);
                 }
-                return genericRequestHandlerProp;
+                return handleProp;
             }
             if (serverAdapterBaseObject) {
                 const serverAdapterBaseObjectProp = serverAdapterBaseObject[prop];
@@ -293,7 +338,7 @@ RequestCtor = Request) {
         apply(_, __, [input, ctx]) {
             return genericRequestHandler(input, ctx);
         },
-    });
+    }); // 😡
 }
 
 export { createServerAdapter };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@whatwg-node/server",
-  "version": "0.4.5",
+  "version": "0.4.6-alpha-20220922124249-c941ae6",
   "description": "Fetch API compliant HTTP Server adapter",
   "sideEffects": false,
   "peerDependencies": {

package/utils.d.ts

@@ -21,3 +21,4 @@ export declare function normalizeNodeRequest(nodeRequest: NodeRequest, RequestCt
 export declare function isReadable(stream: any): stream is Readable;
 export declare function isServerResponse(stream: any): stream is ServerResponse;
 export declare function sendNodeResponse({ headers, status, statusText, body }: Response, serverResponse: ServerResponse): Promise<void>;
+export declare function isRequestInit(val: unknown): val is RequestInit;