@whatwg-node/server 0.7.4 → 0.7.5-alpha-20230320123631-3fc1dd7

package/esm/utils.js

@@ -0,0 +1,235 @@
+import { URL } from '@whatwg-node/fetch';
+export function isAsyncIterable(body) {
+    return (body != null && typeof body === 'object' && typeof body[Symbol.asyncIterator] === 'function');
+}
+function getPort(nodeRequest) {
+    var _a, _b, _c, _d, _e;
+    if ((_a = nodeRequest.socket) === null || _a === void 0 ? void 0 : _a.localPort) {
+        return (_b = nodeRequest.socket) === null || _b === void 0 ? void 0 : _b.localPort;
+    }
+    const hostInHeader = ((_c = nodeRequest.headers) === null || _c === void 0 ? void 0 : _c[':authority']) || ((_d = nodeRequest.headers) === null || _d === void 0 ? void 0 : _d.host);
+    const portInHeader = (_e = hostInHeader === null || hostInHeader === void 0 ? void 0 : hostInHeader.split(':')) === null || _e === void 0 ? void 0 : _e[1];
+    if (portInHeader) {
+        return portInHeader;
+    }
+    return 80;
+}
+function getHostnameWithPort(nodeRequest) {
+    var _a, _b, _c, _d, _e;
+    if ((_a = nodeRequest.headers) === null || _a === void 0 ? void 0 : _a[':authority']) {
+        return (_b = nodeRequest.headers) === null || _b === void 0 ? void 0 : _b[':authority'];
+    }
+    if ((_c = nodeRequest.headers) === null || _c === void 0 ? void 0 : _c.host) {
+        return (_d = nodeRequest.headers) === null || _d === void 0 ? void 0 : _d.host;
+    }
+    const port = getPort(nodeRequest);
+    if (nodeRequest.hostname) {
+        return nodeRequest.hostname + ':' + port;
+    }
+    const localIp = (_e = nodeRequest.socket) === null || _e === void 0 ? void 0 : _e.localAddress;
+    if (localIp && !(localIp === null || localIp === void 0 ? void 0 : localIp.includes('::')) && !(localIp === null || localIp === void 0 ? void 0 : localIp.includes('ffff'))) {
+        return `${localIp}:${port}`;
+    }
+    return 'localhost';
+}
+function buildFullUrl(nodeRequest) {
+    const hostnameWithPort = getHostnameWithPort(nodeRequest);
+    const protocol = nodeRequest.protocol || 'http';
+    const endpoint = nodeRequest.originalUrl || nodeRequest.url || '/graphql';
+    return `${protocol}://${hostnameWithPort}${endpoint}`;
+}
+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;
+}
+export function normalizeNodeRequest(nodeRequest, RequestCtor) {
+    var _a;
+    const rawRequest = nodeRequest.raw || nodeRequest.req || nodeRequest;
+    let fullUrl = buildFullUrl(rawRequest);
+    if (nodeRequest.query) {
+        const url = new URL(fullUrl);
+        for (const key in nodeRequest.query) {
+            url.searchParams.set(key, nodeRequest.query[key]);
+        }
+        fullUrl = url.toString();
+    }
+    if (nodeRequest.method === 'GET' || nodeRequest.method === 'HEAD') {
+        return new RequestCtor(fullUrl, {
+            method: nodeRequest.method,
+            headers: nodeRequest.headers,
+        });
+    }
+    /**
+     * 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, {
+                method: nodeRequest.method,
+                headers: nodeRequest.headers,
+                body: maybeParsedBody,
+            });
+        }
+        const request = new RequestCtor(fullUrl, {
+            method: nodeRequest.method,
+            headers: nodeRequest.headers,
+        });
+        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;
+                    case 'text':
+                        return async () => JSON.stringify(maybeParsedBody);
+                    default:
+                        return Reflect.get(target, prop, receiver);
+                }
+            },
+        });
+    }
+    // perf: instead of spreading the object, we can just pass it as is and it performs better
+    return new RequestCtor(fullUrl, {
+        method: nodeRequest.method,
+        headers: nodeRequest.headers,
+        body: rawRequest,
+    });
+}
+export function isReadable(stream) {
+    return stream.read != null;
+}
+export function isNodeRequest(request) {
+    return isReadable(request);
+}
+export function isServerResponse(stream) {
+    // Check all used functions are defined
+    return (stream != null &&
+        stream.setHeader != null &&
+        stream.end != null &&
+        stream.once != null &&
+        stream.write != null);
+}
+export function isReadableStream(stream) {
+    return stream != null && stream.getReader != null;
+}
+export function isFetchEvent(event) {
+    return event != null && event.request != null && event.respondWith != null;
+}
+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 endResponse(serverResponse) {
+    // @ts-expect-error Avoid arguments adaptor trampoline https://v8.dev/blog/adaptor-frame
+    serverResponse.end(null, null, null);
+}
+export function getHeadersObj(headers) {
+    return new Proxy({}, {
+        get(_target, prop) {
+            return headers.get(prop) || undefined;
+        },
+        set(_target, prop, value) {
+            headers.set(prop, value);
+            return true;
+        },
+        has(_target, prop) {
+            return headers.has(prop);
+        },
+        deleteProperty(_target, prop) {
+            headers.delete(prop);
+            return true;
+        },
+        ownKeys() {
+            const keys = [];
+            headers.forEach((_, key) => keys.push(key));
+            return keys;
+        },
+        getOwnPropertyDescriptor() {
+            return {
+                enumerable: true,
+                configurable: true,
+            };
+        },
+    });
+}
+export async function sendNodeResponse(fetchResponse, serverResponse, nodeRequest) {
+    const headersObj = getHeadersObj(fetchResponse.headers);
+    serverResponse.writeHead(fetchResponse.status, fetchResponse.statusText, headersObj);
+    // eslint-disable-next-line no-async-promise-executor
+    return new Promise(async (resolve) => {
+        serverResponse.once('close', resolve);
+        // Our Node-fetch enhancements
+        if ('bodyType' in fetchResponse &&
+            fetchResponse.bodyType != null &&
+            (fetchResponse.bodyType === 'String' || fetchResponse.bodyType === 'Uint8Array')) {
+            // @ts-expect-error http and http2 writes are actually compatible
+            serverResponse.write(fetchResponse.bodyInit);
+            endResponse(serverResponse);
+            return;
+        }
+        // Other fetch implementations
+        const fetchBody = fetchResponse.body;
+        if (fetchBody == null) {
+            endResponse(serverResponse);
+            return;
+        }
+        if (fetchBody[Symbol.toStringTag] === 'Uint8Array') {
+            serverResponse
+                // @ts-expect-error http and http2 writes are actually compatible
+                .write(fetchBody);
+            endResponse(serverResponse);
+            return;
+        }
+        configureSocket(nodeRequest);
+        if (isReadable(fetchBody)) {
+            serverResponse.once('close', () => {
+                fetchBody.destroy();
+            });
+            fetchBody.pipe(serverResponse);
+            return;
+        }
+        if (isAsyncIterable(fetchBody)) {
+            for await (const chunk of fetchBody) {
+                if (!serverResponse
+                    // @ts-expect-error http and http2 writes are actually compatible
+                    .write(chunk)) {
+                    break;
+                }
+            }
+            endResponse(serverResponse);
+        }
+    });
+}
+export 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));
+}

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@whatwg-node/server",
-  "version": "0.7.4",
+  "version": "0.7.5-alpha-20230320123631-3fc1dd7",
   "description": "Fetch API compliant HTTP Server adapter",
   "sideEffects": false,
   "dependencies": {
-    "@whatwg-node/fetch": "^0.8.2",
+    "@whatwg-node/fetch": "0.8.3-alpha-20230320123631-3fc1dd7",
     "tslib": "^2.3.1"
   },
   "repository": {
@@ -14,21 +14,28 @@
   },
   "author": "Arda TANRIKULU <ardatanrikulu@gmail.com>",
   "license": "MIT",
-  "main": "index.js",
-  "module": "index.mjs",
-  "typings": "index.d.ts",
+  "main": "cjs/index.js",
+  "module": "esm/index.js",
+  "typings": "typings/index.d.ts",
   "typescript": {
-    "definition": "index.d.ts"
+    "definition": "typings/index.d.ts"
   },
+  "type": "module",
   "exports": {
     ".": {
-      "require": "./index.js",
-      "import": "./index.mjs"
-    },
-    "./*": {
-      "require": "./*.js",
-      "import": "./*.mjs"
+      "require": {
+        "types": "./typings/index.d.cts",
+        "default": "./cjs/index.js"
+      },
+      "import": {
+        "types": "./typings/index.d.ts",
+        "default": "./esm/index.js"
+      },
+      "default": {
+        "types": "./typings/index.d.ts",
+        "default": "./esm/index.js"
+      }
     },
     "./package.json": "./package.json"
   }
-}
+}

package/typings/createServerAdapter.d.cts

@@ -0,0 +1,9 @@
+import { ServerAdapterPlugin } from './plugins/types.cjs';
+import { FetchAPI, ServerAdapter, ServerAdapterBaseObject, ServerAdapterRequestHandler } from './types.cjs';
+export interface ServerAdapterOptions<TServerContext> {
+    plugins?: ServerAdapterPlugin<TServerContext>[];
+    fetchAPI?: Partial<FetchAPI>;
+}
+declare function createServerAdapter<TServerContext = {}, THandleRequest extends ServerAdapterRequestHandler<TServerContext> = ServerAdapterRequestHandler<TServerContext>>(serverAdapterRequestHandler: THandleRequest, options?: ServerAdapterOptions<TServerContext>): ServerAdapter<TServerContext, ServerAdapterBaseObject<TServerContext, THandleRequest>>;
+declare function createServerAdapter<TServerContext, TBaseObject extends ServerAdapterBaseObject<TServerContext>>(serverAdapterBaseObject: TBaseObject, options?: ServerAdapterOptions<TServerContext>): ServerAdapter<TServerContext, TBaseObject>;
+export { createServerAdapter };

package/{createServerAdapter.d.ts → typings/createServerAdapter.d.ts}

@@ -1,5 +1,5 @@
-import { ServerAdapterPlugin } from './plugins/types';
-import { FetchAPI, ServerAdapter, ServerAdapterBaseObject, ServerAdapterRequestHandler } from './types';
+import { ServerAdapterPlugin } from './plugins/types.js';
+import { FetchAPI, ServerAdapter, ServerAdapterBaseObject, ServerAdapterRequestHandler } from './types.js';
 export interface ServerAdapterOptions<TServerContext> {
     plugins?: ServerAdapterPlugin<TServerContext>[];
     fetchAPI?: Partial<FetchAPI>;

package/typings/index.d.cts

@@ -0,0 +1,7 @@
+export * from './createServerAdapter.cjs';
+export * from './types.cjs';
+export * from './utils.cjs';
+export * from './plugins/types.cjs';
+export * from './plugins/useCors.cjs';
+export * from './plugins/useErrorHandling.cjs';
+export { Response } from '@whatwg-node/fetch';

package/typings/index.d.ts

@@ -0,0 +1,7 @@
+export * from './createServerAdapter.js';
+export * from './types.js';
+export * from './utils.js';
+export * from './plugins/types.js';
+export * from './plugins/useCors.js';
+export * from './plugins/useErrorHandling.js';
+export { Response } from '@whatwg-node/fetch';

package/typings/plugins/types.d.cts

@@ -0,0 +1,21 @@
+import { FetchAPI, ServerAdapterRequestHandler } from '../types.cjs';
+export interface ServerAdapterPlugin<TServerContext = {}> {
+    onRequest?: OnRequestHook<TServerContext>;
+    onResponse?: OnResponseHook<TServerContext>;
+}
+export type OnRequestHook<TServerContext> = (payload: OnRequestEventPayload<TServerContext>) => Promise<void> | void;
+export interface OnRequestEventPayload<TServerContext> {
+    request: Request;
+    serverContext: TServerContext | undefined;
+    fetchAPI: FetchAPI;
+    requestHandler: ServerAdapterRequestHandler<TServerContext>;
+    setRequestHandler(newRequestHandler: ServerAdapterRequestHandler<TServerContext>): void;
+    endResponse(response: Response): void;
+    url: URL;
+}
+export type OnResponseHook<TServerContext> = (payload: OnResponseEventPayload<TServerContext>) => Promise<void> | void;
+export interface OnResponseEventPayload<TServerContext> {
+    request: Request;
+    serverContext: TServerContext | undefined;
+    response: Response;
+}

package/{plugins → typings/plugins}/types.d.ts

@@ -1,4 +1,4 @@
-import { FetchAPI, ServerAdapterRequestHandler } from '../types';
+import { FetchAPI, ServerAdapterRequestHandler } from '../types.js';
 export interface ServerAdapterPlugin<TServerContext = {}> {
     onRequest?: OnRequestHook<TServerContext>;
     onResponse?: OnResponseHook<TServerContext>;

package/typings/plugins/useCors.d.cts

@@ -0,0 +1,13 @@
+import { ServerAdapterPlugin } from './types.cjs';
+export type CORSOptions = {
+    origin?: string[] | string;
+    methods?: string[];
+    allowedHeaders?: string[];
+    exposedHeaders?: string[];
+    credentials?: boolean;
+    maxAge?: number;
+} | false;
+export type CORSPluginOptions<TServerContext> = CORSOptionsFactory<TServerContext> | CORSOptions | boolean;
+export type CORSOptionsFactory<TServerContext> = (request: Request, ...args: {} extends TServerContext ? [serverContext?: TServerContext | undefined] : [serverContext: TServerContext]) => CORSOptions | Promise<CORSOptions>;
+export declare function getCORSHeadersByRequestAndOptions(request: Request, corsOptions: CORSOptions): Record<string, string> | null;
+export declare function useCORS<TServerContext>(options?: CORSPluginOptions<TServerContext>): ServerAdapterPlugin<TServerContext>;

package/typings/plugins/useErrorHandling.d.cts

@@ -0,0 +1,11 @@
+import { ServerAdapterPlugin } from './types.cjs';
+export declare function createDefaultErrorHandler<TServerContext = {}>(ResponseCtor?: typeof Response): ErrorHandler<TServerContext>;
+export declare class HTTPError extends Error {
+    status: number;
+    message: string;
+    headers: HeadersInit;
+    details?: any;
+    constructor(status: number, message: string, headers?: HeadersInit, details?: any);
+}
+export type ErrorHandler<TServerContext> = (e: any, request: Request, ctx: TServerContext) => Response | Promise<Response>;
+export declare function useErrorHandling<TServerContext>(onError?: ErrorHandler<TServerContext>): ServerAdapterPlugin<TServerContext>;

package/{plugins → typings/plugins}/useErrorHandling.d.ts

@@ -1,4 +1,4 @@
-import { ServerAdapterPlugin } from './types';
+import { ServerAdapterPlugin } from './types.js';
 export declare function createDefaultErrorHandler<TServerContext = {}>(ResponseCtor?: typeof Response): ErrorHandler<TServerContext>;
 export declare class HTTPError extends Error {
     status: number;

package/typings/types.d.cts

@@ -0,0 +1,56 @@
+/// <reference types="node" />
+import type { RequestListener } from 'node:http';
+import type { NodeRequest, NodeResponse } from './utils.cjs';
+export interface FetchEvent extends Event {
+    waitUntil(f: Promise<void> | void): void;
+    request: Request;
+    respondWith(r: Response | PromiseLike<Response>): void;
+}
+export interface ServerAdapterBaseObject<TServerContext, THandleRequest extends ServerAdapterRequestHandler<TServerContext> = ServerAdapterRequestHandler<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 }`.
+     */
+    handle: THandleRequest;
+}
+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>;
+    /**
+     * WHATWG Fetch spec compliant `fetch` function that can be used for testing purposes.
+     */
+    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, ...ctx: Partial<TServerContext>[]): Promise<Response> | Response;
+    /**
+     * A request listener function that can be used with any Node server variation.
+     */
+    requestListener: RequestListener;
+    handle(req: NodeRequest, res: NodeResponse, ...ctx: Partial<TServerContext>[]): Promise<void>;
+    handle(request: Request, ...ctx: Partial<TServerContext>[]): Promise<Response> | Response;
+    handle(fetchEvent: FetchEvent & Partial<TServerContext>, ...ctx: Partial<TServerContext>[]): void;
+    handle(container: {
+        request: Request;
+    } & Partial<TServerContext>, ...ctx: Partial<TServerContext>[]): Promise<Response> | Response;
+}
+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 ServerAdapterNodeContext = {
+    req: NodeRequest;
+    res: NodeResponse;
+};
+export type WaitUntilFn = (promise: Promise<void> | void) => void;
+export type FetchAPI = ReturnType<typeof import('@whatwg-node/fetch').createFetch>;

package/{types.d.ts → typings/types.d.ts}

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 import type { RequestListener } from 'node:http';
-import type { NodeRequest, NodeResponse } from './utils';
+import type { NodeRequest, NodeResponse } from './utils.js';
 export interface FetchEvent extends Event {
     waitUntil(f: Promise<void> | void): void;
     request: Request;

package/typings/utils.d.cts

@@ -0,0 +1,33 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import type { Http2ServerRequest, Http2ServerResponse, OutgoingHttpHeaders } from 'node:http2';
+import type { Socket } from 'node:net';
+import type { Readable } from 'node:stream';
+import { FetchEvent } from './types.cjs';
+export declare function isAsyncIterable(body: any): body is AsyncIterable<any>;
+export interface NodeRequest {
+    protocol?: string;
+    hostname?: string;
+    body?: any;
+    url?: string;
+    originalUrl?: string;
+    method?: string;
+    headers?: any;
+    req?: IncomingMessage | Http2ServerRequest;
+    raw?: IncomingMessage | Http2ServerRequest;
+    socket?: Socket;
+    query?: any;
+}
+export type NodeResponse = ServerResponse | Http2ServerResponse;
+export declare function normalizeNodeRequest(nodeRequest: NodeRequest, RequestCtor: typeof Request): Request;
+export declare function isReadable(stream: any): stream is Readable;
+export declare function isNodeRequest(request: any): request is NodeRequest;
+export declare function isServerResponse(stream: any): stream is NodeResponse;
+export declare function isReadableStream(stream: any): stream is ReadableStream;
+export declare function isFetchEvent(event: any): event is FetchEvent;
+export declare function getHeadersObj(headers: Headers): OutgoingHttpHeaders;
+export declare function sendNodeResponse(fetchResponse: Response, serverResponse: NodeResponse, nodeRequest: NodeRequest): Promise<void>;
+export declare function isRequestInit(val: unknown): val is RequestInit;

package/{utils.d.ts → typings/utils.d.ts}

@@ -6,7 +6,7 @@ import type { IncomingMessage, ServerResponse } from 'node:http';
 import type { Http2ServerRequest, Http2ServerResponse, OutgoingHttpHeaders } from 'node:http2';
 import type { Socket } from 'node:net';
 import type { Readable } from 'node:stream';
-import { FetchEvent } from './types';
+import { FetchEvent } from './types.js';
 export declare function isAsyncIterable(body: any): body is AsyncIterable<any>;
 export interface NodeRequest {
     protocol?: string;

package/index.d.ts

@@ -1,7 +0,0 @@
-export * from './createServerAdapter';
-export * from './types';
-export * from './utils';
-export * from './plugins/types';
-export * from './plugins/useCors';
-export * from './plugins/useErrorHandling';
-export { Response } from '@whatwg-node/fetch';