@trpc/server 11.0.0-alpha-tmp-export-from-main-nuke-core.240 → 11.0.0-alpha-tmp-export-from-main.222

package/dist/adapters/node-http/{types.d.ts → content-type/json/index.d.mts}

@@ -1,26 +1,26 @@
-/// <reference types="node" />
+import { AnyRouter, inferRouterContext } from '@trpc/server';
+import { HTTPBaseHandlerOptions, MaybePromise, TRPCRequestInfo, BaseContentTypeHandler } from '@trpc/core';
+import { IncomingMessage, ServerResponse } from 'http';
+
 /**
  * If you're making an adapter for tRPC and looking at this file for reference, you should import types and functions from `@trpc/server` and `@trpc/server/http`
  *
+ * Do **not** import from `@trpc/core`
  * @example
  * ```ts
  * import type { AnyTRPCRouter } from '@trpc/server'
  * import type { HTTPBaseHandlerOptions } from '@trpc/server/http'
  * ```
  */
-import type { IncomingMessage, ServerResponse } from 'http';
-import type { AnyRouter, inferRouterContext } from '../../@trpc/server';
-import type { HTTPBaseHandlerOptions, TRPCRequestInfo } from '../../@trpc/server/http';
-import type { MaybePromise } from '../../unstable-core-do-not-import';
-import type { NodeHTTPContentTypeHandler } from './internals/contentType';
+
 interface ParsedQs {
     [key: string]: ParsedQs | ParsedQs[] | string[] | string | undefined;
 }
-export type NodeHTTPRequest = IncomingMessage & {
+type NodeHTTPRequest = IncomingMessage & {
     query?: ParsedQs;
     body?: unknown;
 };
-export type NodeHTTPResponse = ServerResponse & {
+type NodeHTTPResponse = ServerResponse & {
     /**
      * Force the partially-compressed response to be flushed to the client.
      *
@@ -31,7 +31,7 @@ export type NodeHTTPResponse = ServerResponse & {
      */
     flush?: () => void;
 };
-export type NodeHTTPCreateContextOption<TRouter extends AnyRouter, TRequest, TResponse> = object extends inferRouterContext<TRouter> ? {
+type NodeHTTPCreateContextOption<TRouter extends AnyRouter, TRequest, TResponse> = object extends inferRouterContext<TRouter> ? {
     /**
      * @link https://trpc.io/docs/v11/context
      **/
@@ -46,7 +46,7 @@ export type NodeHTTPCreateContextOption<TRouter extends AnyRouter, TRequest, TRe
  * @internal
  */
 type ConnectMiddleware<TRequest extends NodeHTTPRequest = NodeHTTPRequest, TResponse extends NodeHTTPResponse = NodeHTTPResponse> = (req: TRequest, res: TResponse, next: (err?: any) => any) => void;
-export type NodeHTTPHandlerOptions<TRouter extends AnyRouter, TRequest extends NodeHTTPRequest, TResponse extends NodeHTTPResponse> = HTTPBaseHandlerOptions<TRouter, TRequest> & NodeHTTPCreateContextOption<TRouter, TRequest, TResponse> & {
+type NodeHTTPHandlerOptions<TRouter extends AnyRouter, TRequest extends NodeHTTPRequest, TResponse extends NodeHTTPResponse> = HTTPBaseHandlerOptions<TRouter, TRequest> & NodeHTTPCreateContextOption<TRouter, TRequest, TResponse> & {
     /**
      * By default, http `OPTIONS` requests are not handled, and CORS headers are not returned.
      *
@@ -67,16 +67,23 @@ export type NodeHTTPHandlerOptions<TRouter extends AnyRouter, TRequest extends N
     maxBodySize?: number;
     experimental_contentTypeHandlers?: NodeHTTPContentTypeHandler<TRequest, TResponse>[];
 };
-export type NodeHTTPRequestHandlerOptions<TRouter extends AnyRouter, TRequest extends NodeHTTPRequest, TResponse extends NodeHTTPResponse> = {
+type NodeHTTPRequestHandlerOptions<TRouter extends AnyRouter, TRequest extends NodeHTTPRequest, TResponse extends NodeHTTPResponse> = {
     req: TRequest;
     res: TResponse;
     path: string;
 } & NodeHTTPHandlerOptions<TRouter, TRequest, TResponse>;
-export type NodeHTTPCreateContextFnOptions<TRequest, TResponse> = {
+type NodeHTTPCreateContextFnOptions<TRequest, TResponse> = {
     req: TRequest;
     res: TResponse;
     info: TRPCRequestInfo;
 };
-export type NodeHTTPCreateContextFn<TRouter extends AnyRouter, TRequest, TResponse> = (opts: NodeHTTPCreateContextFnOptions<TRequest, TResponse>) => MaybePromise<inferRouterContext<TRouter>>;
-export {};
-//# sourceMappingURL=types.d.ts.map
+type NodeHTTPCreateContextFn<TRouter extends AnyRouter, TRequest, TResponse> = (opts: NodeHTTPCreateContextFnOptions<TRequest, TResponse>) => MaybePromise<inferRouterContext<TRouter>>;
+
+interface NodeHTTPContentTypeHandler<TRequest extends NodeHTTPRequest, TResponse extends NodeHTTPResponse> extends BaseContentTypeHandler<NodeHTTPRequestHandlerOptions<AnyRouter, TRequest, TResponse> & {
+    query: URLSearchParams;
+}> {
+}
+
+declare const nodeHTTPJSONContentTypeHandler: <TRequest extends NodeHTTPRequest, TResponse extends NodeHTTPResponse>() => NodeHTTPContentTypeHandler<TRequest, TResponse>;
+
+export { nodeHTTPJSONContentTypeHandler };

package/dist/adapters/node-http/content-type/json/index.d.ts

@@ -1,2 +1,89 @@
-export declare const nodeHTTPJSONContentTypeHandler: <TRequest extends import("../..").NodeHTTPRequest, TResponse extends import("../..").NodeHTTPResponse>() => import("../../internals/contentType").NodeHTTPContentTypeHandler<TRequest, TResponse>;
-//# sourceMappingURL=index.d.ts.map
+import { AnyRouter, inferRouterContext } from '@trpc/server';
+import { HTTPBaseHandlerOptions, MaybePromise, TRPCRequestInfo, BaseContentTypeHandler } from '@trpc/core';
+import { IncomingMessage, ServerResponse } from 'http';
+
+/**
+ * If you're making an adapter for tRPC and looking at this file for reference, you should import types and functions from `@trpc/server` and `@trpc/server/http`
+ *
+ * Do **not** import from `@trpc/core`
+ * @example
+ * ```ts
+ * import type { AnyTRPCRouter } from '@trpc/server'
+ * import type { HTTPBaseHandlerOptions } from '@trpc/server/http'
+ * ```
+ */
+
+interface ParsedQs {
+    [key: string]: ParsedQs | ParsedQs[] | string[] | string | undefined;
+}
+type NodeHTTPRequest = IncomingMessage & {
+    query?: ParsedQs;
+    body?: unknown;
+};
+type NodeHTTPResponse = ServerResponse & {
+    /**
+     * Force the partially-compressed response to be flushed to the client.
+     *
+     * Added by compression middleware
+     * (depending on the environment,
+     * e.g. Next <= 12,
+     * e.g. Express w/ `compression()`)
+     */
+    flush?: () => void;
+};
+type NodeHTTPCreateContextOption<TRouter extends AnyRouter, TRequest, TResponse> = object extends inferRouterContext<TRouter> ? {
+    /**
+     * @link https://trpc.io/docs/v11/context
+     **/
+    createContext?: NodeHTTPCreateContextFn<TRouter, TRequest, TResponse>;
+} : {
+    /**
+     * @link https://trpc.io/docs/v11/context
+     **/
+    createContext: NodeHTTPCreateContextFn<TRouter, TRequest, TResponse>;
+};
+/**
+ * @internal
+ */
+type ConnectMiddleware<TRequest extends NodeHTTPRequest = NodeHTTPRequest, TResponse extends NodeHTTPResponse = NodeHTTPResponse> = (req: TRequest, res: TResponse, next: (err?: any) => any) => void;
+type NodeHTTPHandlerOptions<TRouter extends AnyRouter, TRequest extends NodeHTTPRequest, TResponse extends NodeHTTPResponse> = HTTPBaseHandlerOptions<TRouter, TRequest> & NodeHTTPCreateContextOption<TRouter, TRequest, TResponse> & {
+    /**
+     * By default, http `OPTIONS` requests are not handled, and CORS headers are not returned.
+     *
+     * This can be used to handle them manually or via the `cors` npm package: https://www.npmjs.com/package/cors
+     *
+     * ```ts
+     * import cors from 'cors'
+     *
+     * nodeHTTPRequestHandler({
+     *   cors: cors()
+     * })
+     * ```
+     *
+     * You can also use it for other needs which a connect/node.js compatible middleware can solve,
+     *  though you might wish to consider an alternative solution like the Express adapter if your needs are complex.
+     */
+    middleware?: ConnectMiddleware;
+    maxBodySize?: number;
+    experimental_contentTypeHandlers?: NodeHTTPContentTypeHandler<TRequest, TResponse>[];
+};
+type NodeHTTPRequestHandlerOptions<TRouter extends AnyRouter, TRequest extends NodeHTTPRequest, TResponse extends NodeHTTPResponse> = {
+    req: TRequest;
+    res: TResponse;
+    path: string;
+} & NodeHTTPHandlerOptions<TRouter, TRequest, TResponse>;
+type NodeHTTPCreateContextFnOptions<TRequest, TResponse> = {
+    req: TRequest;
+    res: TResponse;
+    info: TRPCRequestInfo;
+};
+type NodeHTTPCreateContextFn<TRouter extends AnyRouter, TRequest, TResponse> = (opts: NodeHTTPCreateContextFnOptions<TRequest, TResponse>) => MaybePromise<inferRouterContext<TRouter>>;
+
+interface NodeHTTPContentTypeHandler<TRequest extends NodeHTTPRequest, TResponse extends NodeHTTPResponse> extends BaseContentTypeHandler<NodeHTTPRequestHandlerOptions<AnyRouter, TRequest, TResponse> & {
+    query: URLSearchParams;
+}> {
+}
+
+declare const nodeHTTPJSONContentTypeHandler: <TRequest extends NodeHTTPRequest, TResponse extends NodeHTTPResponse>() => NodeHTTPContentTypeHandler<TRequest, TResponse>;
+
+export { nodeHTTPJSONContentTypeHandler };

package/dist/adapters/node-http/content-type/json/index.js

@@ -1,17 +1,56 @@
-'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
 
-require('../../../../unstable-core-do-not-import/rpc/codes.js');
-require('../../../../unstable-core-do-not-import/rootConfig.js');
-var contentType$1 = require('../../../../unstable-core-do-not-import/http/contentType.js');
-var contentType = require('../../internals/contentType.js');
-var getPostBody = require('./getPostBody.js');
+var http = require('@trpc/server/http');
+var server = require('@trpc/server');
 
-const nodeHTTPJSONContentTypeHandler = contentType.createNodeHTTPContentTypeHandler({
+// @trpc/server
+function createNodeHTTPContentTypeHandler(contentTypeHandler) {
+    return ()=>contentTypeHandler;
+}
+
+// @trpc/server
+async function getPostBody(opts) {
+    const { req, maxBodySize = Infinity } = opts;
+    return new Promise((resolve)=>{
+        if ('body' in req) {
+            resolve({
+                ok: true,
+                data: req.body,
+                // If the request headers specifies a content-type, we assume that the body has been preprocessed
+                preprocessed: !!req.headers['content-type']?.startsWith('application/json')
+            });
+            return;
+        }
+        let body = '';
+        let hasBody = false;
+        req.on('data', function(data) {
+            body += data;
+            hasBody = true;
+            if (body.length > maxBodySize) {
+                resolve({
+                    ok: false,
+                    error: new server.TRPCError({
+                        code: 'PAYLOAD_TOO_LARGE'
+                    })
+                });
+            }
+        });
+        req.on('end', ()=>{
+            resolve({
+                ok: true,
+                data: hasBody ? body : undefined,
+                preprocessed: false
+            });
+        });
+    });
+}
+
+const nodeHTTPJSONContentTypeHandler = createNodeHTTPContentTypeHandler({
     isMatch (opts) {
         return !!opts.req.headers['content-type']?.startsWith('application/json');
     },
-    getBody: getPostBody.getPostBody,
-    getInputs: contentType$1.getJsonContentTypeInputs
+    getBody: getPostBody,
+    getInputs: http.getJsonContentTypeInputs
 });
 
 exports.nodeHTTPJSONContentTypeHandler = nodeHTTPJSONContentTypeHandler;

package/dist/adapters/node-http/content-type/json/index.mjs

@@ -1,8 +1,47 @@
-import '../../../../unstable-core-do-not-import/rpc/codes.mjs';
-import '../../../../unstable-core-do-not-import/rootConfig.mjs';
-import { getJsonContentTypeInputs } from '../../../../unstable-core-do-not-import/http/contentType.mjs';
-import { createNodeHTTPContentTypeHandler } from '../../internals/contentType.mjs';
-import { getPostBody } from './getPostBody.mjs';
+import { getJsonContentTypeInputs } from '@trpc/server/http';
+import { TRPCError } from '@trpc/server';
+
+// @trpc/server
+function createNodeHTTPContentTypeHandler(contentTypeHandler) {
+    return ()=>contentTypeHandler;
+}
+
+// @trpc/server
+async function getPostBody(opts) {
+    const { req, maxBodySize = Infinity } = opts;
+    return new Promise((resolve)=>{
+        if ('body' in req) {
+            resolve({
+                ok: true,
+                data: req.body,
+                // If the request headers specifies a content-type, we assume that the body has been preprocessed
+                preprocessed: !!req.headers['content-type']?.startsWith('application/json')
+            });
+            return;
+        }
+        let body = '';
+        let hasBody = false;
+        req.on('data', function(data) {
+            body += data;
+            hasBody = true;
+            if (body.length > maxBodySize) {
+                resolve({
+                    ok: false,
+                    error: new TRPCError({
+                        code: 'PAYLOAD_TOO_LARGE'
+                    })
+                });
+            }
+        });
+        req.on('end', ()=>{
+            resolve({
+                ok: true,
+                data: hasBody ? body : undefined,
+                preprocessed: false
+            });
+        });
+    });
+}
 
 const nodeHTTPJSONContentTypeHandler = createNodeHTTPContentTypeHandler({
     isMatch (opts) {

package/dist/adapters/node-http/index.d.mts

@@ -0,0 +1,100 @@
+import { AnyRouter, inferRouterContext } from '@trpc/server';
+import { IncomingMessage, ServerResponse } from 'http';
+import { BaseContentTypeHandler, HTTPBaseHandlerOptions, TRPCRequestInfo, MaybePromise } from '@trpc/core';
+
+interface NodeHTTPContentTypeHandler<TRequest extends NodeHTTPRequest, TResponse extends NodeHTTPResponse> extends BaseContentTypeHandler<NodeHTTPRequestHandlerOptions<AnyRouter, TRequest, TResponse> & {
+    query: URLSearchParams;
+}> {
+}
+
+/**
+ * If you're making an adapter for tRPC and looking at this file for reference, you should import types and functions from `@trpc/server` and `@trpc/server/http`
+ *
+ * Do **not** import from `@trpc/core`
+ * @example
+ * ```ts
+ * import type { AnyTRPCRouter } from '@trpc/server'
+ * import type { HTTPBaseHandlerOptions } from '@trpc/server/http'
+ * ```
+ */
+
+interface ParsedQs {
+    [key: string]: ParsedQs | ParsedQs[] | string[] | string | undefined;
+}
+type NodeHTTPRequest = IncomingMessage & {
+    query?: ParsedQs;
+    body?: unknown;
+};
+type NodeHTTPResponse = ServerResponse & {
+    /**
+     * Force the partially-compressed response to be flushed to the client.
+     *
+     * Added by compression middleware
+     * (depending on the environment,
+     * e.g. Next <= 12,
+     * e.g. Express w/ `compression()`)
+     */
+    flush?: () => void;
+};
+type NodeHTTPCreateContextOption<TRouter extends AnyRouter, TRequest, TResponse> = object extends inferRouterContext<TRouter> ? {
+    /**
+     * @link https://trpc.io/docs/v11/context
+     **/
+    createContext?: NodeHTTPCreateContextFn<TRouter, TRequest, TResponse>;
+} : {
+    /**
+     * @link https://trpc.io/docs/v11/context
+     **/
+    createContext: NodeHTTPCreateContextFn<TRouter, TRequest, TResponse>;
+};
+/**
+ * @internal
+ */
+type ConnectMiddleware<TRequest extends NodeHTTPRequest = NodeHTTPRequest, TResponse extends NodeHTTPResponse = NodeHTTPResponse> = (req: TRequest, res: TResponse, next: (err?: any) => any) => void;
+type NodeHTTPHandlerOptions<TRouter extends AnyRouter, TRequest extends NodeHTTPRequest, TResponse extends NodeHTTPResponse> = HTTPBaseHandlerOptions<TRouter, TRequest> & NodeHTTPCreateContextOption<TRouter, TRequest, TResponse> & {
+    /**
+     * By default, http `OPTIONS` requests are not handled, and CORS headers are not returned.
+     *
+     * This can be used to handle them manually or via the `cors` npm package: https://www.npmjs.com/package/cors
+     *
+     * ```ts
+     * import cors from 'cors'
+     *
+     * nodeHTTPRequestHandler({
+     *   cors: cors()
+     * })
+     * ```
+     *
+     * You can also use it for other needs which a connect/node.js compatible middleware can solve,
+     *  though you might wish to consider an alternative solution like the Express adapter if your needs are complex.
+     */
+    middleware?: ConnectMiddleware;
+    maxBodySize?: number;
+    experimental_contentTypeHandlers?: NodeHTTPContentTypeHandler<TRequest, TResponse>[];
+};
+type NodeHTTPRequestHandlerOptions<TRouter extends AnyRouter, TRequest extends NodeHTTPRequest, TResponse extends NodeHTTPResponse> = {
+    req: TRequest;
+    res: TResponse;
+    path: string;
+} & NodeHTTPHandlerOptions<TRouter, TRequest, TResponse>;
+type NodeHTTPCreateContextFnOptions<TRequest, TResponse> = {
+    req: TRequest;
+    res: TResponse;
+    info: TRPCRequestInfo;
+};
+type NodeHTTPCreateContextFn<TRouter extends AnyRouter, TRequest, TResponse> = (opts: NodeHTTPCreateContextFnOptions<TRequest, TResponse>) => MaybePromise<inferRouterContext<TRouter>>;
+
+/**
+ * If you're making an adapter for tRPC and looking at this file for reference, you should import types and functions from `@trpc/server` and `@trpc/server/http`
+ *
+ * Do **not** import from `@trpc/core`
+ * @example
+ * ```ts
+ * import type { AnyTRPCRouter } from '@trpc/server'
+ * import type { HTTPBaseHandlerOptions } from '@trpc/server/http'
+ * ```
+ */
+
+declare function nodeHTTPRequestHandler<TRouter extends AnyRouter, TRequest extends NodeHTTPRequest, TResponse extends NodeHTTPResponse>(opts: NodeHTTPRequestHandlerOptions<TRouter, TRequest, TResponse>): Promise<void>;
+
+export { type NodeHTTPCreateContextFn, type NodeHTTPCreateContextFnOptions, type NodeHTTPCreateContextOption, type NodeHTTPHandlerOptions, type NodeHTTPRequest, type NodeHTTPRequestHandlerOptions, type NodeHTTPResponse, nodeHTTPRequestHandler };

package/dist/adapters/node-http/index.d.ts

@@ -1,3 +1,100 @@
-export * from './nodeHTTPRequestHandler';
-export * from './types';
-//# sourceMappingURL=index.d.ts.map
+import { AnyRouter, inferRouterContext } from '@trpc/server';
+import { IncomingMessage, ServerResponse } from 'http';
+import { BaseContentTypeHandler, HTTPBaseHandlerOptions, TRPCRequestInfo, MaybePromise } from '@trpc/core';
+
+interface NodeHTTPContentTypeHandler<TRequest extends NodeHTTPRequest, TResponse extends NodeHTTPResponse> extends BaseContentTypeHandler<NodeHTTPRequestHandlerOptions<AnyRouter, TRequest, TResponse> & {
+    query: URLSearchParams;
+}> {
+}
+
+/**
+ * If you're making an adapter for tRPC and looking at this file for reference, you should import types and functions from `@trpc/server` and `@trpc/server/http`
+ *
+ * Do **not** import from `@trpc/core`
+ * @example
+ * ```ts
+ * import type { AnyTRPCRouter } from '@trpc/server'
+ * import type { HTTPBaseHandlerOptions } from '@trpc/server/http'
+ * ```
+ */
+
+interface ParsedQs {
+    [key: string]: ParsedQs | ParsedQs[] | string[] | string | undefined;
+}
+type NodeHTTPRequest = IncomingMessage & {
+    query?: ParsedQs;
+    body?: unknown;
+};
+type NodeHTTPResponse = ServerResponse & {
+    /**
+     * Force the partially-compressed response to be flushed to the client.
+     *
+     * Added by compression middleware
+     * (depending on the environment,
+     * e.g. Next <= 12,
+     * e.g. Express w/ `compression()`)
+     */
+    flush?: () => void;
+};
+type NodeHTTPCreateContextOption<TRouter extends AnyRouter, TRequest, TResponse> = object extends inferRouterContext<TRouter> ? {
+    /**
+     * @link https://trpc.io/docs/v11/context
+     **/
+    createContext?: NodeHTTPCreateContextFn<TRouter, TRequest, TResponse>;
+} : {
+    /**
+     * @link https://trpc.io/docs/v11/context
+     **/
+    createContext: NodeHTTPCreateContextFn<TRouter, TRequest, TResponse>;
+};
+/**
+ * @internal
+ */
+type ConnectMiddleware<TRequest extends NodeHTTPRequest = NodeHTTPRequest, TResponse extends NodeHTTPResponse = NodeHTTPResponse> = (req: TRequest, res: TResponse, next: (err?: any) => any) => void;
+type NodeHTTPHandlerOptions<TRouter extends AnyRouter, TRequest extends NodeHTTPRequest, TResponse extends NodeHTTPResponse> = HTTPBaseHandlerOptions<TRouter, TRequest> & NodeHTTPCreateContextOption<TRouter, TRequest, TResponse> & {
+    /**
+     * By default, http `OPTIONS` requests are not handled, and CORS headers are not returned.
+     *
+     * This can be used to handle them manually or via the `cors` npm package: https://www.npmjs.com/package/cors
+     *
+     * ```ts
+     * import cors from 'cors'
+     *
+     * nodeHTTPRequestHandler({
+     *   cors: cors()
+     * })
+     * ```
+     *
+     * You can also use it for other needs which a connect/node.js compatible middleware can solve,
+     *  though you might wish to consider an alternative solution like the Express adapter if your needs are complex.
+     */
+    middleware?: ConnectMiddleware;
+    maxBodySize?: number;
+    experimental_contentTypeHandlers?: NodeHTTPContentTypeHandler<TRequest, TResponse>[];
+};
+type NodeHTTPRequestHandlerOptions<TRouter extends AnyRouter, TRequest extends NodeHTTPRequest, TResponse extends NodeHTTPResponse> = {
+    req: TRequest;
+    res: TResponse;
+    path: string;
+} & NodeHTTPHandlerOptions<TRouter, TRequest, TResponse>;
+type NodeHTTPCreateContextFnOptions<TRequest, TResponse> = {
+    req: TRequest;
+    res: TResponse;
+    info: TRPCRequestInfo;
+};
+type NodeHTTPCreateContextFn<TRouter extends AnyRouter, TRequest, TResponse> = (opts: NodeHTTPCreateContextFnOptions<TRequest, TResponse>) => MaybePromise<inferRouterContext<TRouter>>;
+
+/**
+ * If you're making an adapter for tRPC and looking at this file for reference, you should import types and functions from `@trpc/server` and `@trpc/server/http`
+ *
+ * Do **not** import from `@trpc/core`
+ * @example
+ * ```ts
+ * import type { AnyTRPCRouter } from '@trpc/server'
+ * import type { HTTPBaseHandlerOptions } from '@trpc/server/http'
+ * ```
+ */
+
+declare function nodeHTTPRequestHandler<TRouter extends AnyRouter, TRequest extends NodeHTTPRequest, TResponse extends NodeHTTPResponse>(opts: NodeHTTPRequestHandlerOptions<TRouter, TRequest, TResponse>): Promise<void>;
+
+export { type NodeHTTPCreateContextFn, type NodeHTTPCreateContextFnOptions, type NodeHTTPCreateContextOption, type NodeHTTPHandlerOptions, type NodeHTTPRequest, type NodeHTTPRequestHandlerOptions, type NodeHTTPResponse, nodeHTTPRequestHandler };

package/dist/adapters/node-http/index.js

@@ -1,7 +1,109 @@
-'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
 
-var nodeHTTPRequestHandler = require('./nodeHTTPRequestHandler.js');
+var http = require('@trpc/server/http');
+var json = require('@trpc/server/adapters/node-http/content-type/json');
 
+/**
+ * If you're making an adapter for tRPC and looking at this file for reference, you should import types and functions from `@trpc/server` and `@trpc/server/http`
+ *
+ * Do **not** import from `@trpc/core`
+ * @example
+ * ```ts
+ * import type { AnyTRPCRouter } from '@trpc/server'
+ * import type { HTTPBaseHandlerOptions } from '@trpc/server/http'
+ * ```
+ */ /* eslint-disable @typescript-eslint/no-non-null-assertion */ // @trpc/server
+const defaultJSONContentTypeHandler = json.nodeHTTPJSONContentTypeHandler();
+async function nodeHTTPRequestHandler(opts) {
+    const handleViaMiddleware = opts.middleware ?? ((_req, _res, next)=>next());
+    return handleViaMiddleware(opts.req, opts.res, async (err)=>{
+        if (err) throw err;
+        //
+        // Build tRPC dependencies
+        const createContext = async (innerOpts)=>{
+            return await opts.createContext?.({
+                ...opts,
+                ...innerOpts
+            });
+        };
+        const query = opts.req.query ? new URLSearchParams(opts.req.query) : new URLSearchParams(opts.req.url.split('?')[1]);
+        const jsonContentTypeHandler = defaultJSONContentTypeHandler;
+        const contentTypeHandlers = opts.experimental_contentTypeHandlers ?? [
+            jsonContentTypeHandler
+        ];
+        const contentTypeHandler = contentTypeHandlers.find((handler)=>handler.isMatch({
+                ...opts,
+                query
+            })) ?? // fallback to json
+        jsonContentTypeHandler;
+        const bodyResult = await contentTypeHandler.getBody({
+            ...opts,
+            query
+        });
+        const req = {
+            method: opts.req.method,
+            headers: opts.req.headers,
+            query,
+            body: bodyResult.ok ? bodyResult.data : undefined
+        };
+        let isStream = false;
+        let formatter;
+        const unstable_onHead = (head, isStreaming)=>{
+            if ('status' in head && (!opts.res.statusCode || opts.res.statusCode === 200)) {
+                opts.res.statusCode = head.status;
+            }
+            for (const [key, value] of Object.entries(head.headers ?? {})){
+                /* istanbul ignore if -- @preserve */ if (typeof value === 'undefined') {
+                    continue;
+                }
+                opts.res.setHeader(key, value);
+            }
+            if (isStreaming) {
+                opts.res.setHeader('Transfer-Encoding', 'chunked');
+                const vary = opts.res.getHeader('Vary');
+                opts.res.setHeader('Vary', vary ? 'trpc-batch-mode, ' + vary : 'trpc-batch-mode');
+                isStream = true;
+                formatter = http.getBatchStreamFormatter();
+                opts.res.flushHeaders();
+            }
+        };
+        const unstable_onChunk = ([index, string])=>{
+            if (index === -1) {
+                /**
+         * Full response, no streaming. This can happen
+         * - if the response is an error
+         * - if response is empty (HEAD request)
+         */ opts.res.end(string);
+            } else {
+                opts.res.write(formatter(index, string));
+                opts.res.flush?.();
+            }
+        };
+        await http.resolveHTTPResponse({
+            batching: opts.batching,
+            responseMeta: opts.responseMeta,
+            path: opts.path,
+            createContext,
+            router: opts.router,
+            req,
+            error: bodyResult.ok ? null : bodyResult.error,
+            preprocessedBody: bodyResult.ok ? bodyResult.preprocessed : false,
+            onError (o) {
+                opts?.onError?.({
+                    ...o,
+                    req: opts.req
+                });
+            },
+            contentTypeHandler,
+            unstable_onHead,
+            unstable_onChunk
+        });
+        if (isStream) {
+            opts.res.write(formatter.end());
+            opts.res.end();
+        }
+        return opts.res;
+    });
+}
 
-
-exports.nodeHTTPRequestHandler = nodeHTTPRequestHandler.nodeHTTPRequestHandler;
+exports.nodeHTTPRequestHandler = nodeHTTPRequestHandler;