@whatwg-node/server 0.1.1 → 0.3.0-alpha-20220912131329-1c53d82

package/index.d.ts

@@ -43,8 +43,9 @@ export interface ServerAdapterObject<TServerContext> extends EventListenerObject
      */
     handle: RequestListener;
 }
-export declare type ServerAdapter<TServerContext, TBaseObject> = TBaseObject & RequestListener & ServerAdapterObject<TServerContext>;
+export declare type ServerAdapter<TServerContext, TBaseObject> = TBaseObject & RequestListener & ServerAdapterObject<TServerContext>['fetch'] & ServerAdapterObject<TServerContext>;
 export declare function createServerAdapter<TServerContext = {
     req: NodeRequest;
     res: ServerResponse;
+    waitUntil(promise: Promise<unknown>): void;
 }, TBaseObject = unknown>({ Request: RequestCtor, handleRequest, baseObject, }: CreateServerAdapterOptions<TServerContext, TBaseObject>): ServerAdapter<TServerContext, TBaseObject>;

package/index.js

@@ -102,6 +102,8 @@ function normalizeNodeRequest(nodeRequest, RequestCtor) {
                 switch (prop) {
                     case 'json':
                         return async () => maybeParsedBody;
+                    case 'text':
+                        return async () => JSON.stringify(maybeParsedBody);
                     default:
                         return Reflect.get(target, prop, receiver);
                 }
@@ -154,6 +156,13 @@ async function sendNodeResponse({ headers, status, statusText, body }, serverRes
 }
 
 /// <reference lib="webworker" />
+function handleWaitUntils(waitUntilPromises) {
+    return Promise.allSettled(waitUntilPromises).then(waitUntils => waitUntils.forEach(waitUntil => {
+        if (waitUntil.status === 'rejected') {
+            console.error(waitUntil.reason);
+        }
+    }));
+}
 function createServerAdapter({ Request: RequestCtor = fetch.Request, handleRequest, baseObject, }) {
     function fetchFn(input, init, ...ctx) {
         if (typeof input === 'string' || input instanceof URL) {
@@ -166,14 +175,24 @@ function createServerAdapter({ Request: RequestCtor = fetch.Request, handleReque
         return handleRequest(request, serverContext);
     }
     async function requestListener(nodeRequest, serverResponse) {
+        const waitUntilPromises = [];
         const response = await handleNodeRequest(nodeRequest, {
             req: nodeRequest,
             res: serverResponse,
             waitUntil(p) {
-                p.catch(err => console.error(err));
+                waitUntilPromises.push(p);
             },
         });
-        return sendNodeResponse(response, serverResponse);
+        if (response) {
+            await sendNodeResponse(response, serverResponse);
+        }
+        else {
+            await new Promise(resolve => {
+                serverResponse.statusCode = 404;
+                serverResponse.end(resolve);
+            });
+        }
+        await handleWaitUntils(waitUntilPromises);
     }
     function handleEvent(event) {
         if (!event.respondWith || !event.request) {
@@ -190,7 +209,12 @@ function createServerAdapter({ Request: RequestCtor = fetch.Request, handleReque
         handleEvent,
         handle: requestListener,
     };
-    function genericRequestHandler(input, ctx) {
+    function genericRequestHandler(input, ctx, ...rest) {
+        var _a;
+        if ('process' in globalThis && ((_a = process.versions) === null || _a === void 0 ? void 0 : _a['bun']) != null) {
+            // This is required for bun
+            input.text();
+        }
         // If it is a Node request
         if (isReadable(input) && ctx != null && isServerResponse(ctx)) {
             return requestListener(input, ctx);
@@ -206,6 +230,24 @@ function createServerAdapter({ Request: RequestCtor = fetch.Request, handleReque
         }
         // Or is it Request itself?
         // Then ctx is present and it is the context
+        if ((rest === null || rest === void 0 ? void 0 : rest.length) > 0) {
+            ctx = Object.assign({}, ctx, ...rest);
+        }
+        if (!ctx.waitUntil) {
+            const waitUntilPromises = [];
+            ctx.waitUntil = (p) => {
+                waitUntilPromises.push(p);
+            };
+            const response$ = handleRequest(input, {
+                ...ctx,
+                waitUntil(p) {
+                    waitUntilPromises.push(p);
+                }
+            });
+            if (waitUntilPromises.length > 0) {
+                return handleWaitUntils(waitUntilPromises).then(() => response$);
+            }
+        }
         return handleRequest(input, ctx);
     }
     return new Proxy(genericRequestHandler, {

package/index.mjs

@@ -98,6 +98,8 @@ function normalizeNodeRequest(nodeRequest, RequestCtor) {
                 switch (prop) {
                     case 'json':
                         return async () => maybeParsedBody;
+                    case 'text':
+                        return async () => JSON.stringify(maybeParsedBody);
                     default:
                         return Reflect.get(target, prop, receiver);
                 }
@@ -150,6 +152,13 @@ async function sendNodeResponse({ headers, status, statusText, body }, serverRes
 }
 
 /// <reference lib="webworker" />
+function handleWaitUntils(waitUntilPromises) {
+    return Promise.allSettled(waitUntilPromises).then(waitUntils => waitUntils.forEach(waitUntil => {
+        if (waitUntil.status === 'rejected') {
+            console.error(waitUntil.reason);
+        }
+    }));
+}
 function createServerAdapter({ Request: RequestCtor = Request, handleRequest, baseObject, }) {
     function fetchFn(input, init, ...ctx) {
         if (typeof input === 'string' || input instanceof URL) {
@@ -162,14 +171,24 @@ function createServerAdapter({ Request: RequestCtor = Request, handleRequest, ba
         return handleRequest(request, serverContext);
     }
     async function requestListener(nodeRequest, serverResponse) {
+        const waitUntilPromises = [];
         const response = await handleNodeRequest(nodeRequest, {
             req: nodeRequest,
             res: serverResponse,
             waitUntil(p) {
-                p.catch(err => console.error(err));
+                waitUntilPromises.push(p);
             },
         });
-        return sendNodeResponse(response, serverResponse);
+        if (response) {
+            await sendNodeResponse(response, serverResponse);
+        }
+        else {
+            await new Promise(resolve => {
+                serverResponse.statusCode = 404;
+                serverResponse.end(resolve);
+            });
+        }
+        await handleWaitUntils(waitUntilPromises);
     }
     function handleEvent(event) {
         if (!event.respondWith || !event.request) {
@@ -186,7 +205,12 @@ function createServerAdapter({ Request: RequestCtor = Request, handleRequest, ba
         handleEvent,
         handle: requestListener,
     };
-    function genericRequestHandler(input, ctx) {
+    function genericRequestHandler(input, ctx, ...rest) {
+        var _a;
+        if ('process' in globalThis && ((_a = process.versions) === null || _a === void 0 ? void 0 : _a['bun']) != null) {
+            // This is required for bun
+            input.text();
+        }
         // If it is a Node request
         if (isReadable(input) && ctx != null && isServerResponse(ctx)) {
             return requestListener(input, ctx);
@@ -202,6 +226,24 @@ function createServerAdapter({ Request: RequestCtor = Request, handleRequest, ba
         }
         // Or is it Request itself?
         // Then ctx is present and it is the context
+        if ((rest === null || rest === void 0 ? void 0 : rest.length) > 0) {
+            ctx = Object.assign({}, ctx, ...rest);
+        }
+        if (!ctx.waitUntil) {
+            const waitUntilPromises = [];
+            ctx.waitUntil = (p) => {
+                waitUntilPromises.push(p);
+            };
+            const response$ = handleRequest(input, {
+                ...ctx,
+                waitUntil(p) {
+                    waitUntilPromises.push(p);
+                }
+            });
+            if (waitUntilPromises.length > 0) {
+                return handleWaitUntils(waitUntilPromises).then(() => response$);
+            }
+        }
         return handleRequest(input, ctx);
     }
     return new Proxy(genericRequestHandler, {

package/package.json

@@ -1,19 +1,19 @@
 {
   "name": "@whatwg-node/server",
-  "version": "0.1.1",
+  "version": "0.3.0-alpha-20220912131329-1c53d82",
   "description": "Fetch API compliant HTTP Server adapter",
   "sideEffects": false,
   "peerDependencies": {
     "@types/node": "^18.0.6"
   },
   "dependencies": {
-    "@whatwg-node/fetch": "^0.2.9",
+    "@whatwg-node/fetch": "^0.4.0",
     "tslib": "^2.3.1"
   },
   "repository": {
     "type": "git",
     "url": "ardatan/whatwg-node",
-    "directory": "packages/whatwg-server"
+    "directory": "packages/server"
   },
   "author": "Arda TANRIKULU <ardatanrikulu@gmail.com>",
   "license": "MIT",