@whatwg-node/server 0.3.0 → 0.4.0-alpha-20220916163416-8c6abfa

package/README.md

@@ -12,10 +12,8 @@ Let's create a basic Hello World server adapter.
 // myServerAdapter.ts
 import { createServerAdapter } from '@whatwg-node/server'
 
-export default createServerAdapter({
-  handleRequest(request: Request) {
-    return new Response(`Hello World!`, { status: 200 })
-  }
+export default createServerAdapter((request: Request) => {
+  return new Response(`Hello World!`, { status: 200 })
 })
 ```
 
@@ -203,25 +201,22 @@ For example, if you send a multipart request from a browser with `FormData`, you
 ```ts
 import { createServerAdapter } from '@whatwg-node/server'
 
-const myServerAdapter = createServerAdapter({
+const myServerAdapter = createServerAdapter(async request => {
+  // Parse the request as `FormData`
+  const formData = await request.formData()
+  // Select the file
+  const file = formData.get('file')
+  // Process it as a string
+  const fileTextContent = await file.text()
+  // Select the other text parameter
+  const regularTextData = formData.get('additionalStuff')
   // ...
-  async handleRequest(request) {
-    // Parse the request as `FormData`
-    const formData = await request.formData()
-    // Select the file
-    const file = formData.get('file')
-    // Process it as a string
-    const fileTextContent = await file.text()
-    // Select the other text parameter
-    const regularTextData = formData.get('additionalStuff')
-    // ...
-    return new Response('{ "message": "ok" }', {
-      status: 200,
-      headers: {
-        'Content-Type': 'application/json'
-      }
-    })
-  }
+  return new Response('{ "message": "ok" }', {
+    status: 200,
+    headers: {
+      'Content-Type': 'application/json'
+    }
+  })
 })
 ```
 
@@ -236,6 +231,7 @@ We'd recommend to use [itty-router](https://github.com/kwhitley/itty-router) to
 ```ts
 import { Router } from 'itty-router'
 import { createServerAdapter } from '@whatwg-node/server'
+
 // now let's create a router (note the lack of "new")
 const router = Router()
 // GET collection index
@@ -247,12 +243,15 @@ router.post('/todos', async request => {
   const content = await request.json()
   return new Response('Creating Todo: ' + JSON.stringify(content))
 })
+
+// Redirect to a URL
+router.get('/google', () => Response.redirect('http://www.google.com'))
+
 // 404 for everything else
 router.all('*', () => new Response('Not Found.', { status: 404 }))
-// attach the router "handle" to our server adapter
-const myServerAdapter = createServerAdapter({
-  handleRequest: router.handle
-})
+
+// attach the router to our server adapter
+const myServerAdapter = createServerAdapter(router)
 
 // Then use it in any environment
 import { createServer } from 'http'

package/index.d.ts

@@ -2,38 +2,30 @@
 /// <reference lib="webworker" />
 import type { RequestListener, ServerResponse } from 'node:http';
 import { NodeRequest } from './utils';
-export interface CreateServerAdapterOptions<TServerContext, TBaseObject> {
-    /**
-     * WHATWG Fetch spec compliant `Request` constructor.
-     */
-    Request?: typeof Request;
+export interface ServerAdapterBaseObject<TServerContext, THandleRequest extends HandleRequestFn<TServerContext>> {
     /**
      * An async function that takes `Request` and the server context and returns a `Response`.
      * If you use `requestListener`, the server context is `{ req: IncomingMessage, res: ServerResponse }`.
      */
-    handleRequest: (request: Request, serverContext: TServerContext) => Promise<Response>;
-    /**
-     * If you extend a server object with this, you can pass the original object and it will be extended with the required methods and functionalities.
-     */
-    baseObject?: TBaseObject;
+    handle: THandleRequest;
 }
-export interface ServerAdapterObject<TServerContext> extends EventListenerObject {
+export interface ServerAdapterObject<TServerContext, TBaseObject extends ServerAdapterBaseObject<TServerContext, HandleRequestFn<TServerContext>>> extends EventListenerObject {
     /**
      * A basic request listener that takes a `Request` with the server context and returns a `Response`.
      */
-    handleRequest: (request: Request, serverContext: TServerContext) => Promise<Response>;
+    handleRequest: TBaseObject['handle'];
     /**
      * WHATWG Fetch spec compliant `fetch` function that can be used for testing purposes.
      */
-    fetch(request: Request, ...ctx: any[]): Promise<Response>;
-    fetch(urlStr: string, ...ctx: any[]): Promise<Response>;
-    fetch(urlStr: string, init: RequestInit, ...ctx: any[]): Promise<Response>;
-    fetch(url: URL, ...ctx: any[]): Promise<Response>;
-    fetch(url: URL, init: RequestInit, ...ctx: any[]): Promise<Response>;
+    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;
     /**
      * This function takes Node's request object and returns a WHATWG Fetch spec compliant `Response` object.
      **/
-    handleNodeRequest(nodeRequest: NodeRequest, serverContext: TServerContext): Promise<Response>;
+    handleNodeRequest(nodeRequest: NodeRequest, serverContext: TServerContext): Promise<Response> | Response;
     /**
      * A request listener function that can be used with any Node server variation.
      */
@@ -41,11 +33,15 @@ export interface ServerAdapterObject<TServerContext> extends EventListenerObject
     /**
      * Proxy to requestListener to mimic Node middlewares
      */
-    handle: RequestListener;
+    handle: RequestListener & ServerAdapterObject<TServerContext, TBaseObject>['fetch'];
 }
-export declare type ServerAdapter<TServerContext, TBaseObject> = TBaseObject & RequestListener & ServerAdapterObject<TServerContext>['fetch'] & ServerAdapterObject<TServerContext>;
-export declare function createServerAdapter<TServerContext = {
+export declare type ServerAdapter<TServerContext, THandleRequest extends HandleRequestFn<TServerContext>, TBaseObject extends ServerAdapterBaseObject<TServerContext, THandleRequest>> = Omit<TBaseObject, 'handle'> & RequestListener & ServerAdapterObject<TServerContext, TBaseObject>['fetch'] & ServerAdapterObject<TServerContext, TBaseObject>;
+declare type HandleRequestFn<TServerContext> = (request: Request, serverContext: TServerContext) => Promise<Response> | Response;
+declare type DefaultServerContext = {
     req: NodeRequest;
     res: ServerResponse;
     waitUntil(promise: Promise<unknown>): void;
-}, TBaseObject = unknown>({ Request: RequestCtor, handleRequest, baseObject, }: CreateServerAdapterOptions<TServerContext, TBaseObject>): ServerAdapter<TServerContext, TBaseObject>;
+};
+declare function createServerAdapter<TServerContext = DefaultServerContext, THandleRequest extends HandleRequestFn<TServerContext> = HandleRequestFn<TServerContext>>(serverAdapterBaseObject: THandleRequest): ServerAdapter<TServerContext, THandleRequest, ServerAdapterBaseObject<TServerContext, THandleRequest>>;
+declare function createServerAdapter<TServerContext = DefaultServerContext, THandleRequest extends HandleRequestFn<TServerContext> = HandleRequestFn<TServerContext>, TBaseObject extends ServerAdapterBaseObject<TServerContext, THandleRequest> = ServerAdapterBaseObject<TServerContext, THandleRequest>>(serverAdapterBaseObject: TBaseObject): ServerAdapter<TServerContext, THandleRequest, TBaseObject>;
+export { createServerAdapter };

package/index.js

@@ -156,14 +156,20 @@ async function sendNodeResponse({ headers, status, statusText, body }, serverRes
 }
 
 /// <reference lib="webworker" />
-function handleWaitUntils(waitUntilPromises) {
-    return Promise.allSettled(waitUntilPromises).then(waitUntils => waitUntils.forEach(waitUntil => {
+async function handleWaitUntils(waitUntilPromises) {
+    const waitUntils = await Promise.allSettled(waitUntilPromises);
+    waitUntils.forEach(waitUntil => {
         if (waitUntil.status === 'rejected') {
             console.error(waitUntil.reason);
         }
-    }));
+    });
 }
-function createServerAdapter({ Request: RequestCtor = fetch.Request, handleRequest, baseObject, }) {
+function createServerAdapter(serverAdapterBaseObject, 
+/**
+ * WHATWG Fetch spec compliant `Request` constructor.
+ */
+RequestCtor = fetch.Request) {
+    const handleRequest = typeof serverAdapterBaseObject === 'function' ? serverAdapterBaseObject : serverAdapterBaseObject.handle;
     function fetchFn(input, init, ...ctx) {
         if (typeof input === 'string' || input instanceof URL) {
             return handleRequest(new RequestCtor(input, init), Object.assign({}, ...ctx));
@@ -192,7 +198,9 @@ function createServerAdapter({ Request: RequestCtor = fetch.Request, handleReque
                 serverResponse.end(resolve);
             });
         }
-        await handleWaitUntils(waitUntilPromises);
+        if (waitUntilPromises.length > 0) {
+            await handleWaitUntils(waitUntilPromises);
+        }
     }
     function handleEvent(event) {
         if (!event.respondWith || !event.request) {
@@ -201,14 +209,6 @@ function createServerAdapter({ Request: RequestCtor = fetch.Request, handleReque
         const response$ = handleRequest(event.request, event);
         event.respondWith(response$);
     }
-    const adapterObj = {
-        handleRequest,
-        fetch: fetchFn,
-        handleNodeRequest,
-        requestListener,
-        handleEvent,
-        handle: requestListener,
-    };
     function genericRequestHandler(input, ctx, ...rest) {
         var _a;
         if ('process' in globalThis && ((_a = process.versions) === null || _a === void 0 ? void 0 : _a['bun']) != null) {
@@ -250,20 +250,22 @@ function createServerAdapter({ Request: RequestCtor = fetch.Request, handleReque
         }
         return handleRequest(input, ctx);
     }
+    const adapterObj = {
+        handleRequest,
+        fetch: fetchFn,
+        handleNodeRequest,
+        requestListener,
+        handleEvent,
+        handle: genericRequestHandler,
+    };
     return new Proxy(genericRequestHandler, {
         // It should have all the attributes of the handler function and the server instance
         has: (_, prop) => {
-            return (baseObject && prop in baseObject) || prop in adapterObj || prop in genericRequestHandler;
+            return (prop in adapterObj ||
+                prop in genericRequestHandler ||
+                (serverAdapterBaseObject && prop in serverAdapterBaseObject));
         },
         get: (_, prop) => {
-            if (baseObject) {
-                if (prop in baseObject) {
-                    if (baseObject[prop].bind) {
-                        return baseObject[prop].bind(baseObject);
-                    }
-                    return baseObject[prop];
-                }
-            }
             if (adapterObj[prop]) {
                 if (adapterObj[prop].bind) {
                     return adapterObj[prop].bind(adapterObj);
@@ -276,6 +278,12 @@ function createServerAdapter({ Request: RequestCtor = fetch.Request, handleReque
                 }
                 return genericRequestHandler[prop];
             }
+            if (prop in serverAdapterBaseObject) {
+                if (serverAdapterBaseObject[prop].bind) {
+                    return serverAdapterBaseObject[prop].bind(serverAdapterBaseObject);
+                }
+                return serverAdapterBaseObject[prop];
+            }
         },
         apply(_, __, [input, ctx]) {
             return genericRequestHandler(input, ctx);

package/index.mjs

@@ -152,14 +152,20 @@ async function sendNodeResponse({ headers, status, statusText, body }, serverRes
 }
 
 /// <reference lib="webworker" />
-function handleWaitUntils(waitUntilPromises) {
-    return Promise.allSettled(waitUntilPromises).then(waitUntils => waitUntils.forEach(waitUntil => {
+async function handleWaitUntils(waitUntilPromises) {
+    const waitUntils = await Promise.allSettled(waitUntilPromises);
+    waitUntils.forEach(waitUntil => {
         if (waitUntil.status === 'rejected') {
             console.error(waitUntil.reason);
         }
-    }));
+    });
 }
-function createServerAdapter({ Request: RequestCtor = Request, handleRequest, baseObject, }) {
+function createServerAdapter(serverAdapterBaseObject, 
+/**
+ * WHATWG Fetch spec compliant `Request` constructor.
+ */
+RequestCtor = Request) {
+    const handleRequest = typeof serverAdapterBaseObject === 'function' ? serverAdapterBaseObject : serverAdapterBaseObject.handle;
     function fetchFn(input, init, ...ctx) {
         if (typeof input === 'string' || input instanceof URL) {
             return handleRequest(new RequestCtor(input, init), Object.assign({}, ...ctx));
@@ -188,7 +194,9 @@ function createServerAdapter({ Request: RequestCtor = Request, handleRequest, ba
                 serverResponse.end(resolve);
             });
         }
-        await handleWaitUntils(waitUntilPromises);
+        if (waitUntilPromises.length > 0) {
+            await handleWaitUntils(waitUntilPromises);
+        }
     }
     function handleEvent(event) {
         if (!event.respondWith || !event.request) {
@@ -197,14 +205,6 @@ function createServerAdapter({ Request: RequestCtor = Request, handleRequest, ba
         const response$ = handleRequest(event.request, event);
         event.respondWith(response$);
     }
-    const adapterObj = {
-        handleRequest,
-        fetch: fetchFn,
-        handleNodeRequest,
-        requestListener,
-        handleEvent,
-        handle: requestListener,
-    };
     function genericRequestHandler(input, ctx, ...rest) {
         var _a;
         if ('process' in globalThis && ((_a = process.versions) === null || _a === void 0 ? void 0 : _a['bun']) != null) {
@@ -246,20 +246,22 @@ function createServerAdapter({ Request: RequestCtor = Request, handleRequest, ba
         }
         return handleRequest(input, ctx);
     }
+    const adapterObj = {
+        handleRequest,
+        fetch: fetchFn,
+        handleNodeRequest,
+        requestListener,
+        handleEvent,
+        handle: genericRequestHandler,
+    };
     return new Proxy(genericRequestHandler, {
         // It should have all the attributes of the handler function and the server instance
         has: (_, prop) => {
-            return (baseObject && prop in baseObject) || prop in adapterObj || prop in genericRequestHandler;
+            return (prop in adapterObj ||
+                prop in genericRequestHandler ||
+                (serverAdapterBaseObject && prop in serverAdapterBaseObject));
         },
         get: (_, prop) => {
-            if (baseObject) {
-                if (prop in baseObject) {
-                    if (baseObject[prop].bind) {
-                        return baseObject[prop].bind(baseObject);
-                    }
-                    return baseObject[prop];
-                }
-            }
             if (adapterObj[prop]) {
                 if (adapterObj[prop].bind) {
                     return adapterObj[prop].bind(adapterObj);
@@ -272,6 +274,12 @@ function createServerAdapter({ Request: RequestCtor = Request, handleRequest, ba
                 }
                 return genericRequestHandler[prop];
             }
+            if (prop in serverAdapterBaseObject) {
+                if (serverAdapterBaseObject[prop].bind) {
+                    return serverAdapterBaseObject[prop].bind(serverAdapterBaseObject);
+                }
+                return serverAdapterBaseObject[prop];
+            }
         },
         apply(_, __, [input, ctx]) {
             return genericRequestHandler(input, ctx);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@whatwg-node/server",
-  "version": "0.3.0",
+  "version": "0.4.0-alpha-20220916163416-8c6abfa",
   "description": "Fetch API compliant HTTP Server adapter",
   "sideEffects": false,
   "peerDependencies": {