@trpc/server 10.0.0-proxy-alpha.76 → 10.0.0-proxy-alpha.78

package/dist/{router-6b03ff5f.mjs → resolveHTTPResponse-3955937e.mjs}

@@ -1,15 +1,76 @@
-import { a as assertNotBrowser, g as getHTTPStatusCodeFromError } from './resolveHTTPResponse-1b339cff.mjs';
-import { T as TRPCError, a as getCauseFromUnknown, g as getTRPCErrorFromUnknown } from './TRPCError-281ac25a.mjs';
+import { T as TRPCError, g as getCauseFromUnknown, a as getTRPCErrorFromUnknown } from './TRPCError-e99e7cbe.mjs';
 import { T as TRPC_ERROR_CODES_BY_KEY } from './codes-aaa7d554.mjs';
 import { c as createProxy } from './index-47817162.mjs';
+import { t as transformTRPCResponse } from './transformTRPCResponse-c8138d5f.mjs';
 
-assertNotBrowser();
+/* istanbul ignore file */ function assertNotBrowser() {
+    if (typeof window !== 'undefined' && !('Deno' in window) && process.env.NODE_ENV !== 'test' && process.env.JEST_WORKER_ID === undefined) {
+        throw new Error('Imported server-only code in the browser');
+    }
+}
+
+const defaultFormatter = ({ shape  })=>{
+    return shape;
+};
+
+function invert(obj) {
+    const newObj = Object.create(null);
+    for(const key in obj){
+        const v = obj[key];
+        newObj[v] = key;
+    }
+    return newObj;
+}
+
+const TRPC_ERROR_CODES_BY_NUMBER = invert(TRPC_ERROR_CODES_BY_KEY);
+const JSONRPC2_TO_HTTP_CODE = {
+    PARSE_ERROR: 400,
+    BAD_REQUEST: 400,
+    NOT_FOUND: 404,
+    INTERNAL_SERVER_ERROR: 500,
+    UNAUTHORIZED: 401,
+    FORBIDDEN: 403,
+    TIMEOUT: 408,
+    CONFLICT: 409,
+    CLIENT_CLOSED_REQUEST: 499,
+    PRECONDITION_FAILED: 412,
+    PAYLOAD_TOO_LARGE: 413,
+    METHOD_NOT_SUPPORTED: 405
+};
+function getStatusCodeFromKey(code) {
+    return JSONRPC2_TO_HTTP_CODE[code] ?? 500;
+}
+function getHTTPStatusCode(json) {
+    const arr = Array.isArray(json) ? json : [
+        json
+    ];
+    const httpStatuses = new Set(arr.map((res)=>{
+        if ('error' in res) {
+            const data = res.error.data;
+            if (typeof data.httpStatus === 'number') {
+                return data.httpStatus;
+            }
+            const code = TRPC_ERROR_CODES_BY_NUMBER[res.error.code];
+            return getStatusCodeFromKey(code);
+        }
+        return 200;
+    }));
+    if (httpStatuses.size !== 1) {
+        return 207;
+    }
+    const httpStatus = httpStatuses.values().next().value;
+    return httpStatus;
+}
+function getHTTPStatusCodeFromError(error) {
+    const { code  } = error;
+    return getStatusCodeFromKey(code);
+}
 
 /* eslint-disable @typescript-eslint/no-explicit-any */ /**
  * @public
  */ /**
  * @internal
- */ function getDataTransformer$1(transformer) {
+ */ function getDataTransformer(transformer) {
     if ('input' in transformer) {
         return transformer;
     }
@@ -32,232 +93,161 @@ assertNotBrowser();
     }
 };
 
-const defaultFormatter = ({ shape  })=>{
-    return shape;
-};
+/**
+ * Ensures there are no duplicate keys when building a procedure.
+ */ function mergeWithoutOverrides(obj1, ...objs) {
+    const newObj = Object.assign(Object.create(null), obj1);
+    for (const overrides of objs){
+        for(const key in overrides){
+            if (key in newObj && newObj[key] !== overrides[key]) {
+                throw new Error(`Duplicate key ${key}`);
+            }
+            newObj[key] = overrides[key];
+        }
+    }
+    return newObj;
+}
 
 /**
- * @deprecated
- */ const middlewareMarker$1 = 'middlewareMarker';
+ * Create an object without inheriting anything from `Object.prototype`
+ * @internal
+ */ function omitPrototype(obj1) {
+    return Object.assign(Object.create(null), obj1);
+}
 
-assertNotBrowser();
-function getParseFn$1(procedureParser) {
-    const parser = procedureParser;
-    if (typeof parser === 'function') {
-        // ProcedureParserCustomValidatorEsque
-        return parser;
-    }
-    if (typeof parser.parseAsync === 'function') {
-        // ProcedureParserZodEsque
-        return parser.parseAsync.bind(parser);
-    }
-    if (typeof parser.parse === 'function') {
-        // ProcedureParserZodEsque
-        return parser.parse.bind(parser);
-    }
-    if (typeof parser.validateSync === 'function') {
-        // ProcedureParserYupEsque
-        return parser.validateSync.bind(parser);
-    }
-    if (typeof parser.create === 'function') {
-        // ProcedureParserSuperstructEsque
-        return parser.create.bind(parser);
-    }
-    throw new Error('Could not find a validator fn');
+const procedureTypes = [
+    'query',
+    'mutation',
+    'subscription'
+];
+
+function isRouter(procedureOrRouter) {
+    return 'router' in procedureOrRouter._def;
 }
+const emptyRouter = {
+    _ctx: null,
+    _errorShape: null,
+    _meta: null,
+    queries: {},
+    mutations: {},
+    subscriptions: {},
+    errorFormatter: defaultFormatter,
+    transformer: defaultTransformer
+};
 /**
+ *
  * @internal
- * @deprecated
- */ class Procedure {
-    _def() {
-        return {
-            middlewares: this.middlewares,
-            resolver: this.resolver,
-            inputParser: this.inputParser,
-            outputParser: this.outputParser,
-            meta: this.meta
-        };
-    }
-    async parseInput(rawInput) {
-        try {
-            return await this.parseInputFn(rawInput);
-        } catch (cause) {
-            throw new TRPCError({
-                code: 'BAD_REQUEST',
-                cause: getCauseFromUnknown(cause)
-            });
-        }
-    }
-    async parseOutput(rawOutput) {
-        try {
-            return await this.parseOutputFn(rawOutput);
-        } catch (cause) {
-            throw new TRPCError({
-                code: 'INTERNAL_SERVER_ERROR',
-                cause: getCauseFromUnknown(cause),
-                message: 'Output validation failed'
-            });
+ */ function createRouterFactory(defaults) {
+    return function createRouterInner(opts) {
+        const routerProcedures = omitPrototype({});
+        function recursiveGetPaths(procedures, path = '') {
+            for (const [key, procedureOrRouter] of Object.entries(procedures ?? {})){
+                const newPath = `${path}${key}`;
+                if (isRouter(procedureOrRouter)) {
+                    recursiveGetPaths(procedureOrRouter._def.procedures, `${newPath}.`);
+                    continue;
+                }
+                routerProcedures[newPath] = procedureOrRouter;
+            }
         }
-    }
-    /**
-   * Trigger middlewares in order, parse raw input, call resolver & parse raw output
-   * @internal
-   */ async call(opts) {
-        // wrap the actual resolver and treat as the last "middleware"
-        const middlewaresWithResolver = this.middlewares.concat([
-            async ({ ctx  })=>{
-                const input = await this.parseInput(opts.rawInput);
-                const rawOutput = await this.resolver({
-                    ...opts,
-                    ctx,
-                    input
-                });
-                const data = await this.parseOutput(rawOutput);
-                return {
-                    marker: middlewareMarker$1,
-                    ok: true,
-                    data,
-                    ctx
-                };
-            }, 
-        ]);
-        // run the middlewares recursively with the resolver as the last one
-        const callRecursive = async (callOpts = {
-            index: 0,
-            ctx: opts.ctx
-        })=>{
-            try {
-                const result = await middlewaresWithResolver[callOpts.index]({
-                    ctx: callOpts.ctx,
-                    type: opts.type,
-                    path: opts.path,
-                    rawInput: opts.rawInput,
-                    meta: this.meta,
-                    next: async (nextOpts)=>{
-                        return await callRecursive({
-                            index: callOpts.index + 1,
-                            ctx: nextOpts ? nextOpts.ctx : callOpts.ctx
+        recursiveGetPaths(opts);
+        const result = mergeWithoutOverrides({
+            transformer: defaults?.transformer ?? defaultTransformer,
+            errorFormatter: defaults?.errorFormatter ?? defaultFormatter
+        }, {
+            procedures: routerProcedures
+        });
+        const _def = {
+            router: true,
+            procedures: {},
+            ...emptyRouter,
+            ...result,
+            record: opts,
+            queries: Object.entries(result.procedures || {}).filter((pair)=>pair[1]._def.query).reduce((acc, [key, val])=>({
+                    ...acc,
+                    [key]: val
+                }), {}),
+            mutations: Object.entries(result.procedures || {}).filter((pair)=>pair[1]._def.mutation).reduce((acc, [key, val])=>({
+                    ...acc,
+                    [key]: val
+                }), {}),
+            subscriptions: Object.entries(result.procedures || {}).filter((pair)=>pair[1]._def.subscription).reduce((acc, [key, val])=>({
+                    ...acc,
+                    [key]: val
+                }), {})
+        };
+        const router = {
+            ...opts,
+            _def,
+            transformer: _def.transformer,
+            errorFormatter: _def.errorFormatter,
+            createCaller (ctx) {
+                const proxy = createProxy(({ path , args  })=>{
+                    // interop mode
+                    if (path.length === 1 && procedureTypes.includes(path[0])) {
+                        return callProcedure({
+                            procedures: _def.procedures,
+                            path: args[0],
+                            rawInput: args[1],
+                            ctx,
+                            type: path[0]
                         });
                     }
+                    const fullPath = path.join('.');
+                    const procedure = _def.procedures[fullPath];
+                    let type = 'query';
+                    if (procedure._def.mutation) {
+                        type = 'mutation';
+                    } else if (procedure._def.subscription) {
+                        type = 'subscription';
+                    }
+                    return procedure({
+                        path: fullPath,
+                        rawInput: args[0],
+                        ctx,
+                        type
+                    });
                 });
-                return result;
-            } catch (cause) {
-                return {
-                    ctx: callOpts.ctx,
-                    ok: false,
-                    error: getTRPCErrorFromUnknown(cause),
-                    marker: middlewareMarker$1
+                return proxy;
+            },
+            getErrorShape (opts) {
+                const { path , error  } = opts;
+                const { code  } = opts.error;
+                const shape = {
+                    message: error.message,
+                    code: TRPC_ERROR_CODES_BY_KEY[code],
+                    data: {
+                        code,
+                        httpStatus: getHTTPStatusCodeFromError(error)
+                    }
                 };
+                if (process.env.NODE_ENV !== 'production' && typeof opts.error.stack === 'string') {
+                    shape.data.stack = opts.error.stack;
+                }
+                if (typeof path === 'string') {
+                    shape.data.path = path;
+                }
+                return this._def.errorFormatter({
+                    ...opts,
+                    shape
+                });
             }
         };
-        // there's always at least one "next" since we wrap this.resolver in a middleware
-        const result = await callRecursive();
-        if (!result) {
-            throw new TRPCError({
-                code: 'INTERNAL_SERVER_ERROR',
-                message: 'No result from middlewares - did you forget to `return next()`?'
-            });
-        }
-        if (!result.ok) {
-            // re-throw original error
-            throw result.error;
-        }
-        return result.data;
-    }
-    /**
-   * Create new procedure with passed middlewares
-   * @param middlewares
-   */ inheritMiddlewares(middlewares) {
-        const Constructor = this.constructor;
-        const instance = new Constructor({
-            middlewares: [
-                ...middlewares,
-                ...this.middlewares
-            ],
-            resolver: this.resolver,
-            inputParser: this.inputParser,
-            outputParser: this.outputParser,
-            meta: this.meta
-        });
-        return instance;
-    }
-    constructor(opts){
-        this.middlewares = opts.middlewares;
-        this.resolver = opts.resolver;
-        this.inputParser = opts.inputParser;
-        this.parseInputFn = getParseFn$1(this.inputParser);
-        this.outputParser = opts.outputParser;
-        this.parseOutputFn = getParseFn$1(this.outputParser);
-        this.meta = opts.meta;
-    }
-}
-function createProcedure(opts) {
-    const inputParser = 'input' in opts ? opts.input : (input)=>{
-        if (input != null) {
-            throw new TRPCError({
-                code: 'BAD_REQUEST',
-                message: 'No input expected'
-            });
-        }
-        return undefined;
+        return router;
     };
-    const outputParser = 'output' in opts && opts.output ? opts.output : (output)=>output;
-    return new Procedure({
-        inputParser: inputParser,
-        resolver: opts.resolve,
-        middlewares: [],
-        outputParser: outputParser,
-        meta: opts.meta
-    });
-}
-
-function getParseFn(procedureParser) {
-    const parser = procedureParser;
-    if (typeof parser === 'function') {
-        // ProcedureParserCustomValidatorEsque
-        return parser;
-    }
-    if (typeof parser.parseAsync === 'function') {
-        // ProcedureParserZodEsque
-        return parser.parseAsync.bind(parser);
-    }
-    if (typeof parser.parse === 'function') {
-        // ProcedureParserZodEsque
-        return parser.parse.bind(parser);
-    }
-    if (typeof parser.validateSync === 'function') {
-        // ProcedureParserYupEsque
-        return parser.validateSync.bind(parser);
-    }
-    if (typeof parser.create === 'function') {
-        // ProcedureParserSuperstructEsque
-        return parser.create.bind(parser);
-    }
-    throw new Error('Could not find a validator fn');
 }
 /**
- * @deprecated only for backwards compat
  * @internal
- */ function getParseFnOrPassThrough(procedureParser) {
-    if (!procedureParser) {
-        return (v)=>v;
-    }
-    return getParseFn(procedureParser);
-}
-
-/**
- * Ensures there are no duplicate keys when building a procedure.
- */ function mergeWithoutOverrides(obj1, ...objs) {
-    const newObj = Object.assign(Object.create(null), obj1);
-    for (const overrides of objs){
-        for(const key in overrides){
-            if (key in newObj && newObj[key] !== overrides[key]) {
-                throw new Error(`Duplicate key ${key}`);
-            }
-            newObj[key] = overrides[key];
-        }
+ */ function callProcedure(opts) {
+    const { type , path  } = opts;
+    if (!(path in opts.procedures) || !opts.procedures[path]?._def[type]) {
+        throw new TRPCError({
+            code: 'NOT_FOUND',
+            message: `No "${type}"-procedure on path "${path}"`
+        });
     }
-    return newObj;
+    const procedure = opts.procedures[path];
+    return procedure(opts);
 }
 
 /**
@@ -325,6 +315,40 @@ function isPlainObject(obj) {
     return outputMiddleware;
 }
 
+function getParseFn(procedureParser) {
+    const parser = procedureParser;
+    if (typeof parser === 'function') {
+        // ProcedureParserCustomValidatorEsque
+        return parser;
+    }
+    if (typeof parser.parseAsync === 'function') {
+        // ProcedureParserZodEsque
+        return parser.parseAsync.bind(parser);
+    }
+    if (typeof parser.parse === 'function') {
+        // ProcedureParserZodEsque
+        return parser.parse.bind(parser);
+    }
+    if (typeof parser.validateSync === 'function') {
+        // ProcedureParserYupEsque
+        return parser.validateSync.bind(parser);
+    }
+    if (typeof parser.create === 'function') {
+        // ProcedureParserSuperstructEsque
+        return parser.create.bind(parser);
+    }
+    throw new Error('Could not find a validator fn');
+}
+/**
+ * @deprecated only for backwards compat
+ * @internal
+ */ function getParseFnOrPassThrough(procedureParser) {
+    if (!procedureParser) {
+        return (v)=>v;
+    }
+    return getParseFn(procedureParser);
+}
+
 /**
  * @internal
  */ const middlewareMarker = 'middlewareMarker';
@@ -493,419 +517,205 @@ function createProcedureCaller(_def) {
     return procedure;
 }
 
-/**
- * Create an object without inheriting anything from `Object.prototype`
- * @internal
- */ function omitPrototype(obj1) {
-    return Object.assign(Object.create(null), obj1);
-}
-
-const procedureTypes = [
-    'query',
-    'mutation',
-    'subscription'
-];
-
-function isRouter(procedureOrRouter) {
-    return 'router' in procedureOrRouter._def;
-}
-const emptyRouter = {
-    _ctx: null,
-    _errorShape: null,
-    _meta: null,
-    queries: {},
-    mutations: {},
-    subscriptions: {},
-    errorFormatter: defaultFormatter,
-    transformer: defaultTransformer
+const HTTP_METHOD_PROCEDURE_TYPE_MAP = {
+    GET: 'query',
+    POST: 'mutation'
 };
-/**
- *
- * @internal
- */ function createRouterFactory(defaults) {
-    return function createRouterInner(opts) {
-        const routerProcedures = omitPrototype({});
-        function recursiveGetPaths(procedures, path = '') {
-            for (const [key, procedureOrRouter] of Object.entries(procedures ?? {})){
-                const newPath = `${path}${key}`;
-                if (isRouter(procedureOrRouter)) {
-                    recursiveGetPaths(procedureOrRouter._def.procedures, `${newPath}.`);
-                    continue;
-                }
-                routerProcedures[newPath] = procedureOrRouter;
+function getRawProcedureInputOrThrow(req) {
+    try {
+        if (req.method === 'GET') {
+            if (!req.query.has('input')) {
+                return undefined;
             }
+            const raw = req.query.get('input');
+            return JSON.parse(raw);
         }
-        recursiveGetPaths(opts);
-        const result = mergeWithoutOverrides({
-            transformer: defaults?.transformer ?? defaultTransformer,
-            errorFormatter: defaults?.errorFormatter ?? defaultFormatter
-        }, {
-            procedures: routerProcedures
-        });
-        const _def = {
-            router: true,
-            legacy: {},
-            procedures: {},
-            ...emptyRouter,
-            ...result,
-            record: opts,
-            queries: Object.entries(result.procedures || {}).filter((pair)=>pair[1]._def.query).reduce((acc, [key, val])=>({
-                    ...acc,
-                    [key]: val
-                }), {}),
-            mutations: Object.entries(result.procedures || {}).filter((pair)=>pair[1]._def.mutation).reduce((acc, [key, val])=>({
-                    ...acc,
-                    [key]: val
-                }), {}),
-            subscriptions: Object.entries(result.procedures || {}).filter((pair)=>pair[1]._def.subscription).reduce((acc, [key, val])=>({
-                    ...acc,
-                    [key]: val
-                }), {}),
-            routers: Object.entries(result.procedures || {}).filter((pair)=>pair[1]._def._router).reduce((acc, [key, val])=>({
-                    ...acc,
-                    [key]: val
-                }), {})
-        };
-        const router = {
-            ...opts,
-            _def,
-            transformer: _def.transformer,
-            errorFormatter: _def.errorFormatter,
-            createCaller (ctx) {
-                const proxy = createProxy(({ path , args  })=>{
-                    // interop mode
-                    if (path.length === 1 && procedureTypes.includes(path[0])) {
-                        return callProcedure({
-                            procedures: _def.procedures,
-                            path: args[0],
-                            rawInput: args[1],
-                            ctx,
-                            type: path[0]
-                        });
-                    }
-                    const fullPath = path.join('.');
-                    const procedure = _def.procedures[fullPath];
-                    let type = 'query';
-                    if (procedure._def.mutation) {
-                        type = 'mutation';
-                    } else if (procedure._def.subscription) {
-                        type = 'subscription';
-                    }
-                    return procedure({
-                        path: fullPath,
-                        rawInput: args[0],
-                        ctx,
-                        type
-                    });
-                });
-                return proxy;
-            },
-            getErrorShape (opts) {
-                const { path , error  } = opts;
-                const { code  } = opts.error;
-                const shape = {
-                    message: error.message,
-                    code: TRPC_ERROR_CODES_BY_KEY[code],
-                    data: {
-                        code,
-                        httpStatus: getHTTPStatusCodeFromError(error)
-                    }
-                };
-                if (process.env.NODE_ENV !== 'production' && typeof opts.error.stack === 'string') {
-                    shape.data.stack = opts.error.stack;
-                }
-                if (typeof path === 'string') {
-                    shape.data.path = path;
-                }
-                return this._def.errorFormatter({
-                    ...opts,
-                    shape
-                });
-            }
-        };
-        return router;
-    };
-}
-/**
- * @internal
- */ function callProcedure(opts) {
-    const { type , path  } = opts;
-    if (!(path in opts.procedures) || !opts.procedures[path]?._def[type]) {
+        if (typeof req.body === 'string') {
+            // A mutation with no inputs will have req.body === ''
+            return req.body.length === 0 ? undefined : JSON.parse(req.body);
+        }
+        return req.body;
+    } catch (err) {
         throw new TRPCError({
-            code: 'NOT_FOUND',
-            message: `No "${type}"-procedure on path "${path}"`
+            code: 'PARSE_ERROR',
+            cause: getCauseFromUnknown(err)
         });
     }
-    const procedure = opts.procedures[path];
-    return procedure(opts);
-}
-
-function migrateProcedure(oldProc, type) {
-    const def = oldProc._def();
-    const inputParser = getParseFnOrPassThrough(def.inputParser);
-    const outputParser = getParseFnOrPassThrough(def.outputParser);
-    const inputMiddleware = createInputMiddleware(inputParser);
-    const builder = createBuilder({
-        inputs: [
-            def.inputParser
-        ],
-        middlewares: [
-            ...def.middlewares,
-            inputMiddleware,
-            createOutputMiddleware(outputParser), 
-        ],
-        meta: def.meta,
-        output: def.outputParser,
-        mutation: type === 'mutation',
-        query: type === 'query',
-        subscription: type === 'subscription'
-    });
-    const proc = builder[type]((opts)=>def.resolver(opts));
-    return proc;
-}
-function migrateRouter(oldRouter) {
-    const errorFormatter = oldRouter._def.errorFormatter;
-    const transformer = oldRouter._def.transformer;
-    const queries = {};
-    const mutations = {};
-    const subscriptions = {};
-    for (const [name, procedure] of Object.entries(oldRouter._def.queries)){
-        queries[name] = migrateProcedure(procedure, 'query');
-    }
-    for (const [name1, procedure1] of Object.entries(oldRouter._def.mutations)){
-        mutations[name1] = migrateProcedure(procedure1, 'mutation');
-    }
-    for (const [name2, procedure2] of Object.entries(oldRouter._def.subscriptions)){
-        subscriptions[name2] = migrateProcedure(procedure2, 'subscription');
-    }
-    const procedures = mergeWithoutOverrides(queries, mutations, subscriptions);
-    const newRouter = createRouterFactory({
-        transformer,
-        errorFormatter
-    })(procedures);
-    return newRouter;
-}
-
-assertNotBrowser();
-function getDataTransformer(transformer) {
-    if ('input' in transformer) {
-        return transformer;
-    }
-    return {
-        input: transformer,
-        output: transformer
-    };
-}
-const PROCEDURE_DEFINITION_MAP = {
-    query: 'queries',
-    mutation: 'mutations',
-    subscription: 'subscriptions'
-};
-function safeObject(...args) {
-    return Object.assign(Object.create(null), ...args);
 }
-/**
- * @internal The type signature of this class may change without warning.
- * @deprecated
- */ class Router {
-    static prefixProcedures(procedures, prefix) {
-        const eps = safeObject();
-        for (const [key, procedure] of Object.entries(procedures)){
-            eps[prefix + key] = procedure;
-        }
-        return eps;
-    }
-    query(path, procedure) {
-        const router = new Router({
-            queries: safeObject({
-                [path]: createProcedure(procedure)
-            })
-        });
-        return this.merge(router);
-    }
-    mutation(path, procedure) {
-        const router = new Router({
-            mutations: safeObject({
-                [path]: createProcedure(procedure)
-            })
-        });
-        return this.merge(router);
-    }
-    subscription(path, procedure) {
-        const router = new Router({
-            subscriptions: safeObject({
-                [path]: createProcedure(procedure)
-            })
-        });
-        return this.merge(router);
+async function resolveHTTPResponse(opts) {
+    const { createContext , onError , router , req  } = opts;
+    const batchingEnabled = opts.batching?.enabled ?? true;
+    if (req.method === 'HEAD') {
+        // can be used for lambda warmup
+        return {
+            status: 204
+        };
     }
-    merge(prefixOrRouter, maybeRouter) {
-        let prefix = '';
-        let childRouter;
-        if (typeof prefixOrRouter === 'string' && maybeRouter instanceof Router) {
-            prefix = prefixOrRouter;
-            childRouter = maybeRouter;
-        } else if (prefixOrRouter instanceof Router) {
-            childRouter = prefixOrRouter;
-        } else {
-            throw new Error('Invalid args');
+    const type = HTTP_METHOD_PROCEDURE_TYPE_MAP[req.method] ?? 'unknown';
+    let ctx = undefined;
+    let paths = undefined;
+    const isBatchCall = !!req.query.get('batch');
+    function endResponse(untransformedJSON, errors) {
+        let status = getHTTPStatusCode(untransformedJSON);
+        const headers = {
+            'Content-Type': 'application/json'
+        };
+        const meta = opts.responseMeta?.({
+            ctx,
+            paths,
+            type,
+            data: Array.isArray(untransformedJSON) ? untransformedJSON : [
+                untransformedJSON
+            ],
+            errors
+        }) ?? {};
+        for (const [key, value] of Object.entries(meta.headers ?? {})){
+            headers[key] = value;
         }
-        const duplicateQueries = Object.keys(childRouter._def.queries).filter((key)=>!!this._def['queries'][prefix + key]);
-        const duplicateMutations = Object.keys(childRouter._def.mutations).filter((key)=>!!this._def['mutations'][prefix + key]);
-        const duplicateSubscriptions = Object.keys(childRouter._def.subscriptions).filter((key)=>!!this._def['subscriptions'][prefix + key]);
-        const duplicates = [
-            ...duplicateQueries,
-            ...duplicateMutations,
-            ...duplicateSubscriptions, 
-        ];
-        if (duplicates.length) {
-            throw new Error(`Duplicate endpoint(s): ${duplicates.join(', ')}`);
+        if (meta.status) {
+            status = meta.status;
         }
-        const mergeProcedures = (defs)=>{
-            const newDefs = safeObject();
-            for (const [key, procedure] of Object.entries(defs)){
-                const newProcedure = procedure.inheritMiddlewares(this._def.middlewares);
-                newDefs[key] = newProcedure;
-            }
-            return Router.prefixProcedures(newDefs, prefix);
+        const transformedJSON = transformTRPCResponse(router, untransformedJSON);
+        const body = JSON.stringify(transformedJSON);
+        return {
+            body,
+            status,
+            headers
         };
-        return new Router({
-            ...this._def,
-            queries: safeObject(this._def.queries, mergeProcedures(childRouter._def.queries)),
-            mutations: safeObject(this._def.mutations, mergeProcedures(childRouter._def.mutations)),
-            subscriptions: safeObject(this._def.subscriptions, mergeProcedures(childRouter._def.subscriptions))
-        });
     }
-    /**
-   * Invoke procedure. Only for internal use within library.
-   */ async call(opts) {
-        const { type , path  } = opts;
-        const defTarget = PROCEDURE_DEFINITION_MAP[type];
-        const defs = this._def[defTarget];
-        const procedure = defs[path];
-        if (!procedure) {
+    try {
+        if (opts.error) {
+            throw opts.error;
+        }
+        if (isBatchCall && !batchingEnabled) {
+            throw new Error(`Batching is not enabled on the server`);
+        }
+        if (type === 'subscription') {
             throw new TRPCError({
-                code: 'NOT_FOUND',
-                message: `No "${type}"-procedure on path "${path}"`
+                message: 'Subscriptions should use wsLink',
+                code: 'METHOD_NOT_SUPPORTED'
             });
         }
-        return procedure.call(opts);
-    }
-    createCaller(ctx) {
-        return {
-            query: (path, ...args)=>{
-                return this.call({
-                    type: 'query',
-                    ctx,
-                    path,
-                    rawInput: args[0]
+        if (type === 'unknown') {
+            throw new TRPCError({
+                message: `Unexpected request method ${req.method}`,
+                code: 'METHOD_NOT_SUPPORTED'
+            });
+        }
+        const rawInput = getRawProcedureInputOrThrow(req);
+        paths = isBatchCall ? opts.path.split(',') : [
+            opts.path
+        ];
+        ctx = await createContext();
+        const deserializeInputValue = (rawValue)=>{
+            return typeof rawValue !== 'undefined' ? router._def.transformer.input.deserialize(rawValue) : rawValue;
+        };
+        const getInputs = ()=>{
+            if (!isBatchCall) {
+                return {
+                    0: deserializeInputValue(rawInput)
+                };
+            }
+            if (rawInput == null || typeof rawInput !== 'object' || Array.isArray(rawInput)) {
+                throw new TRPCError({
+                    code: 'BAD_REQUEST',
+                    message: '"input" needs to be an object when doing a batch call'
                 });
-            },
-            mutation: (path, ...args)=>{
-                return this.call({
-                    type: 'mutation',
-                    ctx,
+            }
+            const input = {};
+            for(const key in rawInput){
+                const k = key;
+                const rawValue = rawInput[k];
+                const value = deserializeInputValue(rawValue);
+                input[k] = value;
+            }
+            return input;
+        };
+        const inputs = getInputs();
+        const rawResults = await Promise.all(paths.map(async (path, index)=>{
+            const input = inputs[index];
+            try {
+                const output = await callProcedure({
+                    procedures: router._def.procedures,
                     path,
-                    rawInput: args[0]
-                });
-            },
-            subscription: (path, ...args)=>{
-                return this.call({
-                    type: 'subscription',
+                    rawInput: input,
                     ctx,
+                    type
+                });
+                return {
+                    input,
+                    path,
+                    data: output
+                };
+            } catch (cause) {
+                const error = getTRPCErrorFromUnknown(cause);
+                onError?.({
+                    error,
                     path,
-                    rawInput: args[0]
+                    input,
+                    ctx,
+                    type: type,
+                    req
                 });
+                return {
+                    input,
+                    path,
+                    error
+                };
             }
-        };
-    }
-    /**
-   * Function to be called before any procedure is invoked
-   * @link https://trpc.io/docs/middlewares
-   */ middleware(middleware) {
-        return new Router({
-            ...this._def,
-            middlewares: [
-                ...this._def.middlewares,
-                middleware
-            ]
-        });
-    }
-    /**
-   * Format errors
-   * @link https://trpc.io/docs/error-formatting
-   */ formatError(errorFormatter) {
-        if (this._def.errorFormatter !== defaultFormatter) {
-            throw new Error('You seem to have double `formatError()`-calls in your router tree');
-        }
-        return new Router({
-            ...this._def,
-            errorFormatter: errorFormatter
-        });
-    }
-    getErrorShape(opts) {
-        const { path , error  } = opts;
-        const { code  } = opts.error;
-        const shape = {
-            message: error.message,
-            code: TRPC_ERROR_CODES_BY_KEY[code],
-            data: {
-                code,
-                httpStatus: getHTTPStatusCodeFromError(error)
+        }));
+        const errors = rawResults.flatMap((obj)=>obj.error ? [
+                obj.error
+            ] : []);
+        const resultEnvelopes = rawResults.map((obj)=>{
+            const { path , input  } = obj;
+            if (obj.error) {
+                return {
+                    error: router.getErrorShape({
+                        error: obj.error,
+                        type,
+                        path,
+                        input,
+                        ctx
+                    })
+                };
+            } else {
+                return {
+                    result: {
+                        data: obj.data
+                    }
+                };
             }
-        };
-        if (process.env.NODE_ENV !== 'production' && typeof opts.error.stack === 'string') {
-            shape.data.stack = opts.error.stack;
-        }
-        if (typeof path === 'string') {
-            shape.data.path = path;
-        }
-        return this._def.errorFormatter({
-            ...opts,
-            shape
         });
-    }
-    /**
-   * Add data transformer to serialize/deserialize input args + output
-   * @link https://trpc.io/docs/data-transformers
-   */ transformer(_transformer) {
-        const transformer = getDataTransformer(_transformer);
-        if (this._def.transformer !== defaultTransformer) {
-            throw new Error('You seem to have double `transformer()`-calls in your router tree');
-        }
-        return new Router({
-            ...this._def,
-            transformer
+        const result = isBatchCall ? resultEnvelopes : resultEnvelopes[0];
+        return endResponse(result, errors);
+    } catch (cause) {
+        // we get here if
+        // - batching is called when it's not enabled
+        // - `createContext()` throws
+        // - post body is too large
+        // - input deserialization fails
+        const error = getTRPCErrorFromUnknown(cause);
+        onError?.({
+            error,
+            path: undefined,
+            input: undefined,
+            ctx,
+            type: type,
+            req
         });
+        return endResponse({
+            error: router.getErrorShape({
+                error,
+                type,
+                path: undefined,
+                input: undefined,
+                ctx
+            })
+        }, [
+            error
+        ]);
     }
-    /**
-   * Flattens the generics of TQueries/TMutations/TSubscriptions.
-   * ⚠️ Experimental - might disappear. ⚠️
-   *
-   * @alpha
-   */ flat() {
-        return this;
-    }
-    /**
-   * Interop mode for v9.x -> v10.x
-   */ interop() {
-        return migrateRouter(this);
-    }
-    constructor(def){
-        this._def = {
-            queries: def?.queries ?? safeObject(),
-            mutations: def?.mutations ?? safeObject(),
-            subscriptions: def?.subscriptions ?? safeObject(),
-            middlewares: def?.middlewares ?? [],
-            errorFormatter: def?.errorFormatter ?? defaultFormatter,
-            transformer: def?.transformer ?? defaultTransformer
-        };
-    }
-}
-/**
- * @deprecated
- */ function router() {
-    return new Router();
 }
 
-export { defaultTransformer as a, createBuilder as b, createRouterFactory as c, defaultFormatter as d, createMiddlewareFactory as e, callProcedure as f, getDataTransformer$1 as g, createInputMiddleware as h, createOutputMiddleware as i, mergeWithoutOverrides as m, procedureTypes as p, router as r };
+export { defaultTransformer as a, createBuilder as b, createRouterFactory as c, defaultFormatter as d, createMiddlewareFactory as e, assertNotBrowser as f, getDataTransformer as g, callProcedure as h, createInputMiddleware as i, createOutputMiddleware as j, getParseFnOrPassThrough as k, getHTTPStatusCodeFromError as l, mergeWithoutOverrides as m, procedureTypes as p, resolveHTTPResponse as r };