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

package/dist/{router-da6086c3.js → resolveHTTPResponse-9a70b9b2.js}

@@ -1,17 +1,78 @@
 'use strict';
 
-var resolveHTTPResponse = require('./resolveHTTPResponse-d7a8a210.js');
 var TRPCError = require('./TRPCError-fe9113e5.js');
 var codes = require('./codes-1c24d919.js');
 var index = require('./index-9d687d33.js');
+var transformTRPCResponse = require('./transformTRPCResponse-11ac69cc.js');
 
-resolveHTTPResponse.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(codes.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;
     }
@@ -34,232 +95,161 @@ resolveHTTPResponse.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);
+}
 
-resolveHTTPResponse.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.TRPCError({
-                code: 'BAD_REQUEST',
-                cause: TRPCError.getCauseFromUnknown(cause)
-            });
-        }
-    }
-    async parseOutput(rawOutput) {
-        try {
-            return await this.parseOutputFn(rawOutput);
-        } catch (cause) {
-            throw new TRPCError.TRPCError({
-                code: 'INTERNAL_SERVER_ERROR',
-                cause: TRPCError.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 = index.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: TRPCError.getTRPCErrorFromUnknown(cause),
-                    marker: middlewareMarker$1
+                return proxy;
+            },
+            getErrorShape (opts) {
+                const { path , error  } = opts;
+                const { code  } = opts.error;
+                const shape = {
+                    message: error.message,
+                    code: codes.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.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.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.TRPCError({
+            code: 'NOT_FOUND',
+            message: `No "${type}"-procedure on path "${path}"`
+        });
     }
-    return newObj;
+    const procedure = opts.procedures[path];
+    return procedure(opts);
 }
 
 /**
@@ -327,6 +317,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';
@@ -495,421 +519,208 @@ 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 = index.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: codes.TRPC_ERROR_CODES_BY_KEY[code],
-                    data: {
-                        code,
-                        httpStatus: resolveHTTPResponse.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.TRPCError({
-            code: 'NOT_FOUND',
-            message: `No "${type}"-procedure on path "${path}"`
+            code: 'PARSE_ERROR',
+            cause: TRPCError.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;
-}
-
-resolveHTTPResponse.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.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.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.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.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 = TRPCError.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: codes.TRPC_ERROR_CODES_BY_KEY[code],
-            data: {
-                code,
-                httpStatus: resolveHTTPResponse.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 = TRPCError.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();
 }
 
+exports.assertNotBrowser = assertNotBrowser;
 exports.callProcedure = callProcedure;
 exports.createBuilder = createBuilder;
 exports.createInputMiddleware = createInputMiddleware;
@@ -918,7 +729,9 @@ exports.createOutputMiddleware = createOutputMiddleware;
 exports.createRouterFactory = createRouterFactory;
 exports.defaultFormatter = defaultFormatter;
 exports.defaultTransformer = defaultTransformer;
-exports.getDataTransformer = getDataTransformer$1;
+exports.getDataTransformer = getDataTransformer;
+exports.getHTTPStatusCodeFromError = getHTTPStatusCodeFromError;
+exports.getParseFnOrPassThrough = getParseFnOrPassThrough;
 exports.mergeWithoutOverrides = mergeWithoutOverrides;
 exports.procedureTypes = procedureTypes;
-exports.router = router;
+exports.resolveHTTPResponse = resolveHTTPResponse;