@whatwg-node/server 0.0.1

package/index.d.ts

@@ -0,0 +1,46 @@
+/// <reference types="node" />
+import type { RequestListener, ServerResponse } from 'node:http';
+import { NodeRequest } from './utils';
+import { fetch } from '@whatwg-node/fetch';
+export interface CreateServerAdapterOptions<TServerContext, TBaseObject> {
+    /**
+     * WHATWG Fetch spec compliant `Request` constructor.
+     */
+    Request?: typeof Request;
+    /**
+     * 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;
+}
+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, serverContext: TServerContext) => Promise<Response>;
+    /**
+     * WHATWG Fetch spec compliant `fetch` function that can be used for testing purposes.
+     */
+    fetch: typeof fetch;
+    /**
+     * This function takes Node's request object and returns a WHATWG Fetch spec compliant `Response` object.
+     **/
+    handleNodeRequest(nodeRequest: NodeRequest, serverContext: TServerContext): Promise<Response>;
+    /**
+     * A request listener function that can be used with any Node server variation.
+     */
+    requestListener: RequestListener;
+    /**
+     * Proxy to requestListener to mimic Node middlewares
+     */
+    handle: RequestListener;
+}
+export declare type ServerAdapter<TServerContext, TBaseObject> = TBaseObject & RequestListener & ServerAdapterObject<TServerContext>;
+export declare function createServerAdapter<TServerContext = {
+    req: NodeRequest;
+    res: ServerResponse;
+}, TBaseObject = unknown>({ Request: RequestCtor, handleRequest, baseObject, }: CreateServerAdapterOptions<TServerContext, TBaseObject>): ServerAdapter<TServerContext, TBaseObject>;

package/index.js

@@ -0,0 +1,219 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const fetch = require('@whatwg-node/fetch');
+
+function isAsyncIterable(body) {
+    return body != null && typeof body === 'object' && typeof body[Symbol.asyncIterator] === 'function';
+}
+function buildFullUrl(nodeRequest) {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    const hostname = nodeRequest.hostname ||
+        ((_e = (_d = (_c = (_b = (_a = nodeRequest.socket) === null || _a === void 0 ? void 0 : _a.localAddress) === null || _b === void 0 ? void 0 : _b.split('ffff')) === null || _c === void 0 ? void 0 : _c.join('')) === null || _d === void 0 ? void 0 : _d.split(':')) === null || _e === void 0 ? void 0 : _e.join('')) ||
+        ((_g = (_f = nodeRequest.headers) === null || _f === void 0 ? void 0 : _f.host) === null || _g === void 0 ? void 0 : _g.split(':')[0]) ||
+        'localhost';
+    const port = ((_h = nodeRequest.socket) === null || _h === void 0 ? void 0 : _h.localPort) || 80;
+    const protocol = nodeRequest.protocol || 'http';
+    const endpoint = nodeRequest.url || '/graphql';
+    return `${protocol}://${hostname}:${port}${endpoint}`;
+}
+function configureSocket(rawRequest) {
+    var _a, _b, _c, _d, _e, _f;
+    (_b = (_a = rawRequest === null || rawRequest === void 0 ? void 0 : rawRequest.socket) === null || _a === void 0 ? void 0 : _a.setTimeout) === null || _b === void 0 ? void 0 : _b.call(_a, 0);
+    (_d = (_c = rawRequest === null || rawRequest === void 0 ? void 0 : rawRequest.socket) === null || _c === void 0 ? void 0 : _c.setNoDelay) === null || _d === void 0 ? void 0 : _d.call(_c, true);
+    (_f = (_e = rawRequest === null || rawRequest === void 0 ? void 0 : rawRequest.socket) === null || _e === void 0 ? void 0 : _e.setKeepAlive) === null || _f === void 0 ? void 0 : _f.call(_e, true);
+}
+function isRequestBody(body) {
+    const stringTag = body[Symbol.toStringTag];
+    if (typeof body === 'string' ||
+        stringTag === 'Uint8Array' ||
+        stringTag === 'Blob' ||
+        stringTag === 'FormData' ||
+        stringTag === 'URLSearchParams' ||
+        isAsyncIterable(body)) {
+        return true;
+    }
+    return false;
+}
+function normalizeNodeRequest(nodeRequest, RequestCtor) {
+    var _a;
+    const rawRequest = nodeRequest.raw || nodeRequest.req || nodeRequest;
+    configureSocket(rawRequest);
+    const fullUrl = buildFullUrl(rawRequest);
+    if (nodeRequest.query) {
+        const urlObj = new URL(fullUrl);
+        for (const queryName in nodeRequest.query) {
+            const queryValue = nodeRequest.query[queryName];
+            urlObj.searchParams.set(queryName, queryValue);
+        }
+    }
+    const baseRequestInit = {
+        method: nodeRequest.method,
+        headers: nodeRequest.headers,
+    };
+    if (nodeRequest.method === 'GET' || nodeRequest.method === 'HEAD') {
+        return new RequestCtor(fullUrl, baseRequestInit);
+    }
+    /**
+     * Some Node server frameworks like Serverless Express sends a dummy object with body but as a Buffer not string
+     * so we do those checks to see is there something we can use directly as BodyInit
+     * because the presence of body means the request stream is already consumed and,
+     * rawRequest cannot be used as BodyInit/ReadableStream by Fetch API in this case.
+     */
+    const maybeParsedBody = nodeRequest.body;
+    if (maybeParsedBody != null && Object.keys(maybeParsedBody).length > 0) {
+        if (isRequestBody(maybeParsedBody)) {
+            return new RequestCtor(fullUrl, {
+                ...baseRequestInit,
+                body: maybeParsedBody,
+            });
+        }
+        const request = new RequestCtor(fullUrl, {
+            ...baseRequestInit,
+        });
+        if (!((_a = request.headers.get('content-type')) === null || _a === void 0 ? void 0 : _a.includes('json'))) {
+            request.headers.set('content-type', 'application/json');
+        }
+        return new Proxy(request, {
+            get: (target, prop, receiver) => {
+                switch (prop) {
+                    case 'json':
+                        return async () => maybeParsedBody;
+                    default:
+                        return Reflect.get(target, prop, receiver);
+                }
+            },
+        });
+    }
+    return new RequestCtor(fullUrl, {
+        headers: nodeRequest.headers,
+        method: nodeRequest.method,
+        body: rawRequest,
+    });
+}
+function isReadable(stream) {
+    return stream.read != null;
+}
+function isServerResponse(stream) {
+    // Check all used functions are defined
+    return stream.setHeader != null && stream.end != null && stream.once != null && stream.write != null;
+}
+async function sendNodeResponse({ headers, status, statusText, body }, serverResponse) {
+    headers.forEach((value, name) => {
+        serverResponse.setHeader(name, value);
+    });
+    serverResponse.statusCode = status;
+    serverResponse.statusMessage = statusText;
+    // eslint-disable-next-line no-async-promise-executor
+    return new Promise(async (resolve) => {
+        if (body == null) {
+            serverResponse.end(resolve);
+        }
+        else if (body[Symbol.toStringTag] === 'Uint8Array') {
+            serverResponse.end(body, resolve);
+        }
+        else if (isReadable(body)) {
+            serverResponse.once('close', () => {
+                body.destroy();
+            });
+            body.pipe(serverResponse);
+        }
+        else if (isAsyncIterable(body)) {
+            for await (const chunk of body) {
+                if (!serverResponse.write(chunk)) {
+                    resolve();
+                    return;
+                }
+            }
+            serverResponse.end(resolve);
+        }
+    });
+}
+
+function createServerAdapter({ Request: RequestCtor = fetch.Request, handleRequest, baseObject, }) {
+    function fetchFn(...[input, init]) {
+        let request;
+        if (typeof input === 'string' || input instanceof URL) {
+            request = new RequestCtor(input, init);
+        }
+        else {
+            request = input;
+        }
+        return handleRequest(request, init);
+    }
+    function handleNodeRequest(nodeRequest, serverContext) {
+        const request = normalizeNodeRequest(nodeRequest, RequestCtor);
+        return handleRequest(request, serverContext);
+    }
+    async function requestListener(nodeRequest, serverResponse) {
+        const response = await handleNodeRequest(nodeRequest, { req: nodeRequest, res: serverResponse });
+        return sendNodeResponse(response, serverResponse);
+    }
+    function handleEvent(event) {
+        if (!event.respondWith || !event.request) {
+            throw new TypeError(`Expected FetchEvent, got ${event}`);
+        }
+        const response$ = handleRequest(event.request, event);
+        event.respondWith(response$);
+    }
+    const adapterObj = {
+        handleRequest,
+        fetch: fetchFn,
+        handleNodeRequest,
+        requestListener,
+        handleEvent,
+        handle: requestListener,
+    };
+    function genericRequestHandler(input, ctx) {
+        // If it is a Node request
+        if (isReadable(input) && ctx != null && isServerResponse(ctx)) {
+            return requestListener(input, ctx);
+        }
+        // Is input a container object over Request?
+        if (input.request) {
+            // Is it FetchEvent?
+            if (input.respondWith) {
+                return handleEvent(input);
+            }
+            // In this input is also the context
+            return handleRequest(input.request, input);
+        }
+        // Or is it Request itself?
+        // Then ctx is present and it is the context
+        return handleRequest(input, ctx);
+    }
+    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;
+        },
+        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);
+                }
+                return adapterObj[prop];
+            }
+            if (genericRequestHandler[prop]) {
+                if (genericRequestHandler[prop].bind) {
+                    return genericRequestHandler[prop].bind(genericRequestHandler);
+                }
+                return genericRequestHandler[prop];
+            }
+        },
+        apply(_, __, [input, ctx]) {
+            return genericRequestHandler(input, ctx);
+        },
+    });
+}
+
+exports.createServerAdapter = createServerAdapter;

package/index.mjs

@@ -0,0 +1,215 @@
+import { Request } from '@whatwg-node/fetch';
+
+function isAsyncIterable(body) {
+    return body != null && typeof body === 'object' && typeof body[Symbol.asyncIterator] === 'function';
+}
+function buildFullUrl(nodeRequest) {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    const hostname = nodeRequest.hostname ||
+        ((_e = (_d = (_c = (_b = (_a = nodeRequest.socket) === null || _a === void 0 ? void 0 : _a.localAddress) === null || _b === void 0 ? void 0 : _b.split('ffff')) === null || _c === void 0 ? void 0 : _c.join('')) === null || _d === void 0 ? void 0 : _d.split(':')) === null || _e === void 0 ? void 0 : _e.join('')) ||
+        ((_g = (_f = nodeRequest.headers) === null || _f === void 0 ? void 0 : _f.host) === null || _g === void 0 ? void 0 : _g.split(':')[0]) ||
+        'localhost';
+    const port = ((_h = nodeRequest.socket) === null || _h === void 0 ? void 0 : _h.localPort) || 80;
+    const protocol = nodeRequest.protocol || 'http';
+    const endpoint = nodeRequest.url || '/graphql';
+    return `${protocol}://${hostname}:${port}${endpoint}`;
+}
+function configureSocket(rawRequest) {
+    var _a, _b, _c, _d, _e, _f;
+    (_b = (_a = rawRequest === null || rawRequest === void 0 ? void 0 : rawRequest.socket) === null || _a === void 0 ? void 0 : _a.setTimeout) === null || _b === void 0 ? void 0 : _b.call(_a, 0);
+    (_d = (_c = rawRequest === null || rawRequest === void 0 ? void 0 : rawRequest.socket) === null || _c === void 0 ? void 0 : _c.setNoDelay) === null || _d === void 0 ? void 0 : _d.call(_c, true);
+    (_f = (_e = rawRequest === null || rawRequest === void 0 ? void 0 : rawRequest.socket) === null || _e === void 0 ? void 0 : _e.setKeepAlive) === null || _f === void 0 ? void 0 : _f.call(_e, true);
+}
+function isRequestBody(body) {
+    const stringTag = body[Symbol.toStringTag];
+    if (typeof body === 'string' ||
+        stringTag === 'Uint8Array' ||
+        stringTag === 'Blob' ||
+        stringTag === 'FormData' ||
+        stringTag === 'URLSearchParams' ||
+        isAsyncIterable(body)) {
+        return true;
+    }
+    return false;
+}
+function normalizeNodeRequest(nodeRequest, RequestCtor) {
+    var _a;
+    const rawRequest = nodeRequest.raw || nodeRequest.req || nodeRequest;
+    configureSocket(rawRequest);
+    const fullUrl = buildFullUrl(rawRequest);
+    if (nodeRequest.query) {
+        const urlObj = new URL(fullUrl);
+        for (const queryName in nodeRequest.query) {
+            const queryValue = nodeRequest.query[queryName];
+            urlObj.searchParams.set(queryName, queryValue);
+        }
+    }
+    const baseRequestInit = {
+        method: nodeRequest.method,
+        headers: nodeRequest.headers,
+    };
+    if (nodeRequest.method === 'GET' || nodeRequest.method === 'HEAD') {
+        return new RequestCtor(fullUrl, baseRequestInit);
+    }
+    /**
+     * Some Node server frameworks like Serverless Express sends a dummy object with body but as a Buffer not string
+     * so we do those checks to see is there something we can use directly as BodyInit
+     * because the presence of body means the request stream is already consumed and,
+     * rawRequest cannot be used as BodyInit/ReadableStream by Fetch API in this case.
+     */
+    const maybeParsedBody = nodeRequest.body;
+    if (maybeParsedBody != null && Object.keys(maybeParsedBody).length > 0) {
+        if (isRequestBody(maybeParsedBody)) {
+            return new RequestCtor(fullUrl, {
+                ...baseRequestInit,
+                body: maybeParsedBody,
+            });
+        }
+        const request = new RequestCtor(fullUrl, {
+            ...baseRequestInit,
+        });
+        if (!((_a = request.headers.get('content-type')) === null || _a === void 0 ? void 0 : _a.includes('json'))) {
+            request.headers.set('content-type', 'application/json');
+        }
+        return new Proxy(request, {
+            get: (target, prop, receiver) => {
+                switch (prop) {
+                    case 'json':
+                        return async () => maybeParsedBody;
+                    default:
+                        return Reflect.get(target, prop, receiver);
+                }
+            },
+        });
+    }
+    return new RequestCtor(fullUrl, {
+        headers: nodeRequest.headers,
+        method: nodeRequest.method,
+        body: rawRequest,
+    });
+}
+function isReadable(stream) {
+    return stream.read != null;
+}
+function isServerResponse(stream) {
+    // Check all used functions are defined
+    return stream.setHeader != null && stream.end != null && stream.once != null && stream.write != null;
+}
+async function sendNodeResponse({ headers, status, statusText, body }, serverResponse) {
+    headers.forEach((value, name) => {
+        serverResponse.setHeader(name, value);
+    });
+    serverResponse.statusCode = status;
+    serverResponse.statusMessage = statusText;
+    // eslint-disable-next-line no-async-promise-executor
+    return new Promise(async (resolve) => {
+        if (body == null) {
+            serverResponse.end(resolve);
+        }
+        else if (body[Symbol.toStringTag] === 'Uint8Array') {
+            serverResponse.end(body, resolve);
+        }
+        else if (isReadable(body)) {
+            serverResponse.once('close', () => {
+                body.destroy();
+            });
+            body.pipe(serverResponse);
+        }
+        else if (isAsyncIterable(body)) {
+            for await (const chunk of body) {
+                if (!serverResponse.write(chunk)) {
+                    resolve();
+                    return;
+                }
+            }
+            serverResponse.end(resolve);
+        }
+    });
+}
+
+function createServerAdapter({ Request: RequestCtor = Request, handleRequest, baseObject, }) {
+    function fetchFn(...[input, init]) {
+        let request;
+        if (typeof input === 'string' || input instanceof URL) {
+            request = new RequestCtor(input, init);
+        }
+        else {
+            request = input;
+        }
+        return handleRequest(request, init);
+    }
+    function handleNodeRequest(nodeRequest, serverContext) {
+        const request = normalizeNodeRequest(nodeRequest, RequestCtor);
+        return handleRequest(request, serverContext);
+    }
+    async function requestListener(nodeRequest, serverResponse) {
+        const response = await handleNodeRequest(nodeRequest, { req: nodeRequest, res: serverResponse });
+        return sendNodeResponse(response, serverResponse);
+    }
+    function handleEvent(event) {
+        if (!event.respondWith || !event.request) {
+            throw new TypeError(`Expected FetchEvent, got ${event}`);
+        }
+        const response$ = handleRequest(event.request, event);
+        event.respondWith(response$);
+    }
+    const adapterObj = {
+        handleRequest,
+        fetch: fetchFn,
+        handleNodeRequest,
+        requestListener,
+        handleEvent,
+        handle: requestListener,
+    };
+    function genericRequestHandler(input, ctx) {
+        // If it is a Node request
+        if (isReadable(input) && ctx != null && isServerResponse(ctx)) {
+            return requestListener(input, ctx);
+        }
+        // Is input a container object over Request?
+        if (input.request) {
+            // Is it FetchEvent?
+            if (input.respondWith) {
+                return handleEvent(input);
+            }
+            // In this input is also the context
+            return handleRequest(input.request, input);
+        }
+        // Or is it Request itself?
+        // Then ctx is present and it is the context
+        return handleRequest(input, ctx);
+    }
+    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;
+        },
+        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);
+                }
+                return adapterObj[prop];
+            }
+            if (genericRequestHandler[prop]) {
+                if (genericRequestHandler[prop].bind) {
+                    return genericRequestHandler[prop].bind(genericRequestHandler);
+                }
+                return genericRequestHandler[prop];
+            }
+        },
+        apply(_, __, [input, ctx]) {
+            return genericRequestHandler(input, ctx);
+        },
+    });
+}
+
+export { createServerAdapter };

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@whatwg-node/server",
+  "version": "0.0.1",
+  "description": "Fetch API compliant HTTP Server adapter",
+  "sideEffects": false,
+  "peerDependencies": {
+    "@types/node": "^18.0.6"
+  },
+  "dependencies": {
+    "@whatwg-node/fetch": "^0.0.1",
+    "tslib": "^2.3.1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "ardatan/whatwg-node",
+    "directory": "packages/whatwg-server"
+  },
+  "author": "Arda TANRIKULU <ardatanrikulu@gmail.com>",
+  "license": "MIT",
+  "main": "index.js",
+  "module": "index.mjs",
+  "typings": "index.d.ts",
+  "typescript": {
+    "definition": "index.d.ts"
+  },
+  "exports": {
+    ".": {
+      "require": "./index.js",
+      "import": "./index.mjs"
+    },
+    "./*": {
+      "require": "./*.js",
+      "import": "./*.mjs"
+    },
+    "./package.json": "./package.json"
+  }
+}

package/utils.d.ts

@@ -0,0 +1,20 @@
+/// <reference types="node" />
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import type { Socket } from 'node:net';
+import type { Readable } from 'node:stream';
+export interface NodeRequest {
+    protocol?: string;
+    hostname?: string;
+    body?: any;
+    url?: string;
+    method?: string;
+    headers: any;
+    req?: IncomingMessage;
+    raw?: IncomingMessage;
+    socket?: Socket;
+    query?: any;
+}
+export declare function normalizeNodeRequest(nodeRequest: NodeRequest, RequestCtor: typeof Request): Request;
+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>;