@trpc/server 10.0.0-alpha.41 → 10.0.0-alpha.44

package/dist/router-4e50a6ac.js

@@ -0,0 +1,1104 @@
+'use strict';
+
+var resolveHTTPResponse = require('./resolveHTTPResponse-5d90abc5.js');
+var envelopes = require('./envelopes-2ae27c9f.js');
+var TRPCError = require('./TRPCError-9050a68d.js');
+var index = require('./index-1a25ccbd.js');
+
+resolveHTTPResponse.assertNotBrowser();
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+
+/**
+ * @internal
+ */
+function getDataTransformer$1(transformer) {
+  if ('input' in transformer) {
+    return transformer;
+  }
+
+  return {
+    input: transformer,
+    output: transformer
+  };
+}
+/**
+ * @internal
+ */
+
+/**
+ * @internal
+ */
+const defaultTransformer = {
+  _default: true,
+  input: {
+    serialize: obj => obj,
+    deserialize: obj => obj
+  },
+  output: {
+    serialize: obj => obj,
+    deserialize: obj => obj
+  }
+};
+
+/**
+ * @internal
+ */
+
+/**
+ * @internal
+ */
+
+/**
+ * @internal
+ */
+const defaultFormatter = ({
+  shape
+}) => {
+  return shape;
+};
+
+/**
+ * @deprecated
+ */
+const middlewareMarker$1 = 'middlewareMarker';
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+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');
+}
+/**
+ * @internal
+ * @deprecated
+ */
+
+
+class Procedure {
+  constructor(opts) {
+    this.middlewares = void 0;
+    this.resolver = void 0;
+    this.inputParser = void 0;
+    this.parseInputFn = void 0;
+    this.outputParser = void 0;
+    this.parseOutputFn = void 0;
+    this.meta = void 0;
+    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;
+  }
+
+  _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'
+      });
+    }
+  }
+  /**
+   * 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
+            });
+          }
+        });
+        return result;
+      } catch (cause) {
+        return {
+          ctx: callOpts.ctx,
+          ok: false,
+          error: TRPCError.getErrorFromUnknown(cause),
+          marker: middlewareMarker$1
+        };
+      }
+    }; // 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;
+  }
+
+}
+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;
+  };
+  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];
+    }
+  }
+
+  return newObj;
+}
+
+/**
+ * @internal
+ */
+
+/**
+ * @internal
+ */
+
+/**
+ * @internal
+ */
+const middlewareMarker = 'middlewareMarker';
+/**
+ * @internal
+ */
+
+function createNewBuilder(def1, def2) {
+  const {
+    middlewares = [],
+    ...rest
+  } = def2; // TODO: maybe have a fn here to warn about calls
+
+  return createBuilder({ ...mergeWithoutOverrides(def1, rest),
+    middlewares: [...def1.middlewares, ...middlewares]
+  });
+}
+
+function createBuilder(initDef) {
+  const _def = initDef || {
+    middlewares: []
+  };
+
+  return {
+    _def,
+
+    input(input) {
+      const parser = getParseFn(input);
+      return createNewBuilder(_def, {
+        input,
+        middlewares: [createInputMiddleware(parser)]
+      });
+    },
+
+    output(output) {
+      const parseOutput = getParseFn(output);
+      return createNewBuilder(_def, {
+        output,
+        middlewares: [createOutputMiddleware(parseOutput)]
+      });
+    },
+
+    meta(meta) {
+      return createNewBuilder(_def, {
+        meta: meta
+      });
+    },
+
+    unstable_concat(builder) {
+      return createNewBuilder(_def, builder._def);
+    },
+
+    use(middleware) {
+      return createNewBuilder(_def, {
+        middlewares: [middleware]
+      });
+    },
+
+    query(resolver) {
+      return createResolver({ ..._def,
+        query: true
+      }, resolver);
+    },
+
+    mutation(resolver) {
+      return createResolver({ ..._def,
+        mutation: true
+      }, resolver);
+    },
+
+    subscription(resolver) {
+      return createResolver({ ..._def,
+        subscription: true
+      }, resolver);
+    }
+
+  };
+}
+function createInputMiddleware(parse) {
+  return async function inputMiddleware({
+    next,
+    rawInput
+  }) {
+    let input;
+
+    try {
+      input = await parse(rawInput);
+    } catch (cause) {
+      throw new TRPCError.TRPCError({
+        code: 'BAD_REQUEST',
+        cause: TRPCError.getCauseFromUnknown(cause)
+      });
+    } // TODO fix this typing?
+
+
+    return next({
+      input
+    });
+  };
+}
+function createOutputMiddleware(parse) {
+  return async function outputMiddleware({
+    next
+  }) {
+    const result = await next();
+
+    if (!result.ok) {
+      // pass through failures without validating
+      return result;
+    }
+
+    try {
+      const data = await parse(result.data);
+      return { ...result,
+        data
+      };
+    } catch (cause) {
+      throw new TRPCError.TRPCError({
+        message: 'Output validation failed',
+        code: 'INTERNAL_SERVER_ERROR',
+        cause: TRPCError.getCauseFromUnknown(cause)
+      });
+    }
+  };
+}
+
+function createResolver(_def, resolver) {
+  const finalBuilder = createNewBuilder(_def, {
+    resolver,
+    middlewares: [async function resolveMiddleware(opts) {
+      const data = await resolver(opts);
+      return {
+        marker: middlewareMarker,
+        ok: true,
+        data,
+        ctx: opts.ctx
+      };
+    }]
+  });
+  return createProcedureCaller(finalBuilder._def);
+}
+/**
+ * @internal
+ */
+
+
+const codeblock = /*#__PURE__*/`
+If you want to call this function on the server, you do the following:
+This is a client-only function.
+
+const caller = appRouter.createCaller({
+  /* ... your context */
+});
+
+const result = await caller.call('myProcedure', input);
+`.trim();
+
+function createProcedureCaller(_def) {
+  const procedure = async function resolve(opts) {
+    // is direct server-side call
+    if (!opts || !('rawInput' in opts)) {
+      throw new Error(codeblock);
+    } // run the middlewares recursively with the resolver as the last one
+
+
+    const callRecursive = async (callOpts = {
+      index: 0,
+      ctx: opts.ctx
+    }) => {
+      try {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const middleware = _def.middlewares[callOpts.index];
+        const result = await middleware({
+          ctx: callOpts.ctx,
+          type: opts.type,
+          path: opts.path,
+          rawInput: opts.rawInput,
+          meta: _def.meta,
+          input: callOpts.input,
+          next: async nextOpts => {
+            return await callRecursive({
+              index: callOpts.index + 1,
+              ctx: nextOpts && 'ctx' in nextOpts ? { ...callOpts.ctx,
+                ...nextOpts.ctx
+              } : callOpts.ctx,
+              input: nextOpts && 'input' in nextOpts ? nextOpts.input : callOpts.input
+            });
+          }
+        });
+        return result;
+      } catch (cause) {
+        return {
+          ok: false,
+          error: TRPCError.getErrorFromUnknown(cause),
+          marker: middlewareMarker
+        };
+      }
+    }; // 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;
+  };
+
+  procedure._def = _def;
+  procedure.meta = _def.meta;
+  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'];
+/**
+ * @public
+ */
+
+/** @internal **/
+
+function isRouter(procedureOrRouter) {
+  return 'router' in procedureOrRouter._def;
+}
+
+const emptyRouter = {
+  _ctx: null,
+  _errorShape: null,
+  _meta: null,
+  queries: {},
+  mutations: {},
+  subscriptions: {},
+  errorFormatter: defaultFormatter,
+  transformer: defaultTransformer
+};
+/**
+ *
+ * @internal
+ */
+
+function createRouterFactory(defaults) {
+  return function createRouterInner(opts) {
+    var _defaults$transformer, _defaults$errorFormat;
+
+    const routerProcedures = omitPrototype({});
+
+    function recursiveGetPaths(procedures, path = '') {
+      for (const [key, procedureOrRouter] of Object.entries(procedures !== null && procedures !== void 0 ? procedures : {})) {
+        const newPath = `${path}${key}`;
+
+        if (isRouter(procedureOrRouter)) {
+          recursiveGetPaths(procedureOrRouter._def.procedures, `${newPath}.`);
+          continue;
+        }
+
+        routerProcedures[newPath] = procedureOrRouter;
+      }
+    }
+
+    recursiveGetPaths(opts);
+    const result = mergeWithoutOverrides({
+      transformer: (_defaults$transformer = defaults === null || defaults === void 0 ? void 0 : defaults.transformer) !== null && _defaults$transformer !== void 0 ? _defaults$transformer : defaultTransformer,
+      errorFormatter: (_defaults$errorFormat = defaults === null || defaults === void 0 ? void 0 : defaults.errorFormatter) !== null && _defaults$errorFormat !== void 0 ? _defaults$errorFormat : 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: envelopes.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) {
+  var _opts$procedures$path;
+
+  const {
+    type,
+    path
+  } = opts;
+
+  if (!(path in opts.procedures) || !((_opts$procedures$path = opts.procedures[path]) !== null && _opts$procedures$path !== void 0 && _opts$procedures$path._def[type])) {
+    throw new TRPCError.TRPCError({
+      code: 'NOT_FOUND',
+      message: `No "${type}"-procedure on path "${path}"`
+    });
+  }
+
+  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({
+    input: 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 [name, procedure] of Object.entries(oldRouter._def.mutations)) {
+    mutations[name] = migrateProcedure(procedure, 'mutation');
+  }
+
+  for (const [name, procedure] of Object.entries(oldRouter._def.subscriptions)) {
+    subscriptions[name] = migrateProcedure(procedure, 'subscription');
+  }
+
+  const procedures = mergeWithoutOverrides(queries, mutations, subscriptions);
+  const newRouter = createRouterFactory({
+    transformer,
+    errorFormatter
+  })(procedures);
+  return newRouter;
+}
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+resolveHTTPResponse.assertNotBrowser();
+
+function getDataTransformer(transformer) {
+  if ('input' in transformer) {
+    return transformer;
+  }
+
+  return {
+    input: transformer,
+    output: transformer
+  };
+}
+/**
+ * @internal
+ * @deprecated
+ */
+
+
+const PROCEDURE_DEFINITION_MAP = {
+  query: 'queries',
+  mutation: 'mutations',
+  subscription: 'subscriptions'
+};
+/**
+ * @internal
+ * @deprecated
+ */
+
+function safeObject(...args) {
+  return Object.assign(Object.create(null), ...args);
+}
+
+/**
+ * @internal The type signature of this class may change without warning.
+ * @deprecated
+ */
+class Router {
+  constructor(def) {
+    var _def$queries, _def$mutations, _def$subscriptions, _def$middlewares, _def$errorFormatter, _def$transformer;
+
+    this._def = void 0;
+    this._def = {
+      queries: (_def$queries = def === null || def === void 0 ? void 0 : def.queries) !== null && _def$queries !== void 0 ? _def$queries : safeObject(),
+      mutations: (_def$mutations = def === null || def === void 0 ? void 0 : def.mutations) !== null && _def$mutations !== void 0 ? _def$mutations : safeObject(),
+      subscriptions: (_def$subscriptions = def === null || def === void 0 ? void 0 : def.subscriptions) !== null && _def$subscriptions !== void 0 ? _def$subscriptions : safeObject(),
+      middlewares: (_def$middlewares = def === null || def === void 0 ? void 0 : def.middlewares) !== null && _def$middlewares !== void 0 ? _def$middlewares : [],
+      errorFormatter: (_def$errorFormatter = def === null || def === void 0 ? void 0 : def.errorFormatter) !== null && _def$errorFormatter !== void 0 ? _def$errorFormatter : defaultFormatter,
+      transformer: (_def$transformer = def === null || def === void 0 ? void 0 : def.transformer) !== null && _def$transformer !== void 0 ? _def$transformer : defaultTransformer
+    };
+  }
+
+  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);
+  }
+  /**
+   * @beta Might change without a major version bump
+   */
+
+
+  subscription(path, procedure) {
+    const router = new Router({
+      subscriptions: safeObject({
+        [path]: createProcedure(procedure)
+      })
+    });
+    return this.merge(router);
+  }
+  /**
+   * Merge router with other router
+   * @param router
+   */
+
+
+  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;
+    }
+    /* istanbul ignore next */
+    else {
+      throw new Error('Invalid args');
+    }
+
+    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(', ')}`);
+    }
+
+    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);
+    };
+
+    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) {
+      throw new TRPCError.TRPCError({
+        code: 'NOT_FOUND',
+        message: `No "${type}"-procedure on path "${path}"`
+      });
+    }
+
+    return procedure.call(opts);
+  }
+
+  createCaller(ctx) {
+    return {
+      query: (path, ...args) => {
+        return this.call({
+          type: 'query',
+          ctx,
+          path,
+          rawInput: args[0]
+        });
+      },
+      mutation: (path, ...args) => {
+        return this.call({
+          type: 'mutation',
+          ctx,
+          path,
+          rawInput: args[0]
+        });
+      },
+      subscription: (path, ...args) => {
+        return this.call({
+          type: 'subscription',
+          ctx,
+          path,
+          rawInput: args[0]
+        });
+      }
+    };
+  }
+  /**
+   * 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: envelopes.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
+    });
+  }
+  /**
+   * 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
+    });
+  }
+  /**
+   * 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);
+  }
+
+}
+/**
+ * @deprecated
+ */
+
+function router() {
+  return new Router();
+}
+
+exports.callProcedure = callProcedure;
+exports.createBuilder = createBuilder;
+exports.createRouterFactory = createRouterFactory;
+exports.defaultFormatter = defaultFormatter;
+exports.defaultTransformer = defaultTransformer;
+exports.getDataTransformer = getDataTransformer$1;
+exports.mergeWithoutOverrides = mergeWithoutOverrides;
+exports.procedureTypes = procedureTypes;
+exports.router = router;