@trpc/server 10.0.0-proxy-beta.24 → 10.0.0-proxy-beta.26

package/dist/index.js

@@ -2,126 +2,14 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var resolveHTTPResponse = require('./resolveHTTPResponse-92daf326.js');
-var transformTRPCResponse = require('./transformTRPCResponse-92c79c47.js');
+var config = require('./config-8ef987c1.js');
 var TRPCError = require('./TRPCError-fe9113e5.js');
 var codes = require('./codes-76c38a34.js');
 var index = require('./index-62d46c97.js');
 
 /**
- * @internal
- */ // FIXME this should use RootConfig
-function createMiddlewareFactory() {
-    return function createMiddleware(fn) {
-        return fn;
-    };
-}
-function isPlainObject(obj) {
-    return obj && typeof obj === 'object' && !Array.isArray(obj);
-}
-/**
- * @internal
- * Please note, `trpc-openapi` uses this function.
- */ function createInputMiddleware(parse) {
-    const inputMiddleware = async ({ next , rawInput , input ,  })=>{
-        let parsedInput;
-        try {
-            parsedInput = await parse(rawInput);
-        } catch (cause) {
-            throw new TRPCError.TRPCError({
-                code: 'BAD_REQUEST',
-                cause: TRPCError.getCauseFromUnknown(cause)
-            });
-        }
-        // Multiple input parsers
-        const combinedInput = isPlainObject(input) && isPlainObject(parsedInput) ? {
-            ...input,
-            ...parsedInput
-        } : parsedInput;
-        // TODO fix this typing?
-        return next({
-            input: combinedInput
-        });
-    };
-    inputMiddleware._type = 'input';
-    return inputMiddleware;
-}
-/**
- * @internal
- */ function createOutputMiddleware(parse) {
-    const outputMiddleware = async ({ 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)
-            });
-        }
-    };
-    outputMiddleware._type = 'output';
-    return outputMiddleware;
-}
-
-/**
- * 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;
-}
-
-function mergeRouters(...routerList) {
-    const record = mergeWithoutOverrides({}, ...routerList.map((r)=>r._def.record));
-    const errorFormatter = routerList.reduce((currentErrorFormatter, nextRouter)=>{
-        if (nextRouter._def._config.errorFormatter && nextRouter._def._config.errorFormatter !== transformTRPCResponse.defaultFormatter) {
-            if (currentErrorFormatter !== transformTRPCResponse.defaultFormatter && currentErrorFormatter !== nextRouter._def._config.errorFormatter) {
-                throw new Error('You seem to have several error formatters');
-            }
-            return nextRouter._def._config.errorFormatter;
-        }
-        return currentErrorFormatter;
-    }, transformTRPCResponse.defaultFormatter);
-    const transformer = routerList.reduce((prev, current)=>{
-        if (current._def._config.transformer && current._def._config.transformer !== transformTRPCResponse.defaultTransformer) {
-            if (prev !== transformTRPCResponse.defaultTransformer && prev !== current._def._config.transformer) {
-                throw new Error('You seem to have several transformers');
-            }
-            return current._def._config.transformer;
-        }
-        return prev;
-    }, transformTRPCResponse.defaultTransformer);
-    const router = transformTRPCResponse.createRouterFactory({
-        errorFormatter,
-        transformer,
-        isDev: routerList.some((r)=>r._def._config.isDev),
-        allowOutsideOfServer: routerList.some((r)=>r._def._config.allowOutsideOfServer),
-        isServer: routerList.some((r)=>r._def._config.isServer),
-        $types: routerList[0]?._def._config.$types
-    })(record);
-    return router;
-}
-
-function mergeRoutersGeneric(...args) {
-    return mergeRouters(...args);
-}
+ * @deprecated
+ */ const middlewareMarker$1 = 'middlewareMarker';
 
 function getParseFn$1(procedureParser) {
     const parser = procedureParser;
@@ -148,129 +36,61 @@ function getParseFn$1(procedureParser) {
     throw new Error('Could not find a validator fn');
 }
 /**
- * @deprecated only for backwards compat
  * @internal
- */ function getParseFnOrPassThrough(procedureParser) {
-    if (!procedureParser) {
-        return (v)=>v;
+ * @deprecated
+ */ class Procedure {
+    _def() {
+        return {
+            middlewares: this.middlewares,
+            resolver: this.resolver,
+            inputParser: this.inputParser,
+            outputParser: this.outputParser,
+            meta: this.meta
+        };
     }
-    return getParseFn$1(procedureParser);
-}
-
-/**
- * @internal
- */ const middlewareMarker$1 = 'middlewareMarker';
-
-function createNewBuilder(def1, def2) {
-    const { middlewares =[] , inputs , ...rest } = def2;
-    // TODO: maybe have a fn here to warn about calls
-    return createBuilder({
-        ...mergeWithoutOverrides(def1, rest),
-        inputs: [
-            ...def1.inputs,
-            ...inputs ?? []
-        ],
-        middlewares: [
-            ...def1.middlewares,
-            ...middlewares
-        ]
-    });
-}
-function createBuilder(initDef) {
-    const _def = initDef || {
-        inputs: [],
-        middlewares: []
-    };
-    return {
-        _def,
-        input (input) {
-            const parser = getParseFn$1(input);
-            return createNewBuilder(_def, {
-                inputs: [
-                    input
-                ],
-                middlewares: [
-                    createInputMiddleware(parser)
-                ]
-            });
-        },
-        output (output) {
-            const parseOutput = getParseFn$1(output);
-            return createNewBuilder(_def, {
-                output,
-                middlewares: [
-                    createOutputMiddleware(parseOutput)
-                ]
-            });
-        },
-        meta (meta) {
-            return createNewBuilder(_def, {
-                meta: meta
+    async parseInput(rawInput) {
+        try {
+            return await this.parseInputFn(rawInput);
+        } catch (cause) {
+            throw new TRPCError.TRPCError({
+                code: 'BAD_REQUEST',
+                cause: TRPCError.getCauseFromUnknown(cause)
             });
-        },
-        unstable_concat (builder) {
-            return createNewBuilder(_def, builder._def);
-        },
-        use (middleware) {
-            return createNewBuilder(_def, {
-                middlewares: [
-                    middleware
-                ]
+        }
+    }
+    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'
             });
-        },
-        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 createResolver(_def, resolver) {
-    const finalBuilder = createNewBuilder(_def, {
-        resolver,
-        middlewares: [
-            async function resolveMiddleware(opts) {
-                const data = await resolver(opts);
+    }
+    /**
+   * 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: opts.ctx
+                    ctx
                 };
             }
-        ]
-    });
-    return createProcedureCaller(finalBuilder._def);
-}
-const codeblock = `
-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,
@@ -278,28 +98,23 @@ function createProcedureCaller(_def) {
         })=>{
             try {
                 // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                const middleware = _def.middlewares[callOpts.index];
-                const result = await middleware({
+                const result = await middlewaresWithResolver[callOpts.index]({
                     ctx: callOpts.ctx,
                     type: opts.type,
                     path: opts.path,
                     rawInput: opts.rawInput,
-                    meta: _def.meta,
-                    input: callOpts.input,
+                    meta: this.meta,
                     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
+                            ctx: nextOpts ? nextOpts.ctx : callOpts.ctx
                         });
                     }
                 });
                 return result;
             } catch (cause) {
                 return {
+                    ctx: callOpts.ctx,
                     ok: false,
                     error: TRPCError.getTRPCErrorFromUnknown(cause),
                     marker: middlewareMarker$1
@@ -319,79 +134,54 @@ function createProcedureCaller(_def) {
             throw result.error;
         }
         return result.data;
-    };
-    procedure._def = _def;
-    procedure.meta = _def.meta;
-    return procedure;
-}
-
-/**
- * TODO: This can be improved:
- * - We should be able to chain `.meta()`/`.context()` only once
- * - Simplify typings
- * - Doesn't need to be a class but it doesn't really hurt either
- */ class TRPCBuilder {
-    context() {
-        return new TRPCBuilder();
     }
-    meta() {
-        return new TRPCBuilder();
+    /**
+   * 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;
     }
-    create(options) {
-        return createTRPCInner()(options);
+    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;
     }
 }
-/**
- * Initialize tRPC - be done exactly once per backend
- */ const initTRPC = new TRPCBuilder();
-function createTRPCInner() {
-    return function initTRPCInner(runtime) {
-        const errorFormatter = runtime?.errorFormatter ?? transformTRPCResponse.defaultFormatter;
-        const transformer = transformTRPCResponse.getDataTransformer(runtime?.transformer ?? transformTRPCResponse.defaultTransformer);
-        const config = {
-            transformer,
-            isDev: runtime?.isDev ?? process.env.NODE_ENV !== 'production',
-            allowOutsideOfServer: runtime?.allowOutsideOfServer ?? false,
-            errorFormatter,
-            isServer: runtime?.isServer ?? transformTRPCResponse.isServerDefault,
-            /**
-       * @internal
-       */ $types: index.createFlatProxy((key)=>{
-                throw new Error(`Tried to access "$types.${key}" which is not available at runtime`);
-            })
-        };
-        {
-            // Server check
-            const isServer = runtime?.isServer ?? transformTRPCResponse.isServerDefault;
-            if (!isServer && runtime?.allowOutsideOfServer !== true) {
-                throw new Error(`You're trying to use @trpc/server in a non-server environment. This is not supported by default.`);
-            }
+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 {
-            /**
-       * These are just types, they can't be used
-       * @internal
-       */ _config: config,
-            /**
-       * Builder object for creating procedures
-       */ procedure: createBuilder(),
-            /**
-       * Create reusable middlewares
-       */ middleware: createMiddlewareFactory(),
-            /**
-       * Create a router
-       */ router: transformTRPCResponse.createRouterFactory(config),
-            /**
-       * Merge Routers
-       */ mergeRouters: mergeRoutersGeneric
-        };
+        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
+    });
 }
 
-/**
- * @deprecated
- */ const middlewareMarker = 'middlewareMarker';
-
 function getParseFn(procedureParser) {
     const parser = procedureParser;
     if (typeof parser === 'function') {
@@ -417,61 +207,209 @@ function getParseFn(procedureParser) {
     throw new Error('Could not find a validator fn');
 }
 /**
+ * @deprecated only for backwards compat
  * @internal
- * @deprecated
- */ class Procedure {
-    _def() {
-        return {
-            middlewares: this.middlewares,
-            resolver: this.resolver,
-            inputParser: this.inputParser,
-            outputParser: this.outputParser,
-            meta: this.meta
-        };
+ */ function getParseFnOrPassThrough(procedureParser) {
+    if (!procedureParser) {
+        return (v)=>v;
     }
-    async parseInput(rawInput) {
+    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
+ */ // FIXME this should use RootConfig
+function createMiddlewareFactory() {
+    return function createMiddleware(fn) {
+        return fn;
+    };
+}
+function isPlainObject(obj) {
+    return obj && typeof obj === 'object' && !Array.isArray(obj);
+}
+/**
+ * @internal
+ * Please note, `trpc-openapi` uses this function.
+ */ function createInputMiddleware(parse) {
+    const inputMiddleware = async ({ next , rawInput , input ,  })=>{
+        let parsedInput;
         try {
-            return await this.parseInputFn(rawInput);
+            parsedInput = await parse(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'
+        }
+        // Multiple input parsers
+        const combinedInput = isPlainObject(input) && isPlainObject(parsedInput) ? {
+            ...input,
+            ...parsedInput
+        } : parsedInput;
+        // TODO fix this typing?
+        return next({
+            input: combinedInput
+        });
+    };
+    inputMiddleware._type = 'input';
+    return inputMiddleware;
+}
+/**
+ * @internal
+ */ function createOutputMiddleware(parse) {
+    const outputMiddleware = async ({ 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)
+            });
+        }
+    };
+    outputMiddleware._type = 'output';
+    return outputMiddleware;
+}
+
+/**
+ * @internal
+ */ const middlewareMarker = 'middlewareMarker';
+
+function createNewBuilder(def1, def2) {
+    const { middlewares =[] , inputs , ...rest } = def2;
+    // TODO: maybe have a fn here to warn about calls
+    return createBuilder({
+        ...mergeWithoutOverrides(def1, rest),
+        inputs: [
+            ...def1.inputs,
+            ...inputs ?? []
+        ],
+        middlewares: [
+            ...def1.middlewares,
+            ...middlewares
+        ]
+    });
+}
+function createBuilder(initDef) {
+    const _def = initDef || {
+        inputs: [],
+        middlewares: []
+    };
+    return {
+        _def,
+        input (input) {
+            const parser = getParseFn(input);
+            return createNewBuilder(_def, {
+                inputs: [
+                    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);
         }
-    }
-    /**
-   * 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);
+    };
+}
+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
+                    ctx: opts.ctx
                 };
             }
-        ]);
+        ]
+    });
+    return createProcedureCaller(finalBuilder._def);
+}
+const codeblock = `
+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,
@@ -479,23 +417,28 @@ function getParseFn(procedureParser) {
         })=>{
             try {
                 // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                const result = await middlewaresWithResolver[callOpts.index]({
+                const middleware = _def.middlewares[callOpts.index];
+                const result = await middleware({
                     ctx: callOpts.ctx,
                     type: opts.type,
                     path: opts.path,
                     rawInput: opts.rawInput,
-                    meta: this.meta,
+                    meta: _def.meta,
+                    input: callOpts.input,
                     next: async (nextOpts)=>{
                         return await callRecursive({
                             index: callOpts.index + 1,
-                            ctx: nextOpts ? nextOpts.ctx : callOpts.ctx
+                            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 {
-                    ctx: callOpts.ctx,
                     ok: false,
                     error: TRPCError.getTRPCErrorFromUnknown(cause),
                     marker: middlewareMarker
@@ -515,52 +458,10 @@ function getParseFn(procedureParser) {
             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(this.inputParser);
-        this.outputParser = opts.outputParser;
-        this.parseOutputFn = getParseFn(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;
     };
-    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
-    });
+    procedure._def = _def;
+    procedure.meta = _def.meta;
+    return procedure;
 }
 
 function migrateProcedure(oldProc, type) {
@@ -602,7 +503,7 @@ function migrateRouter(oldRouter) {
         subscriptions[name2] = migrateProcedure(procedure2, 'subscription');
     }
     const procedures = mergeWithoutOverrides(queries, mutations, subscriptions);
-    const newRouter = transformTRPCResponse.createRouterFactory({
+    const newRouter = config.createRouterFactory({
         transformer,
         errorFormatter,
         isDev: process.env.NODE_ENV !== 'production'
@@ -758,7 +659,7 @@ function safeObject(...args) {
    * Format errors
    * @link https://trpc.io/docs/error-formatting
    */ formatError(errorFormatter) {
-        if (this._def.errorFormatter !== transformTRPCResponse.defaultFormatter) {
+        if (this._def.errorFormatter !== config.defaultFormatter) {
             throw new Error('You seem to have double `formatError()`-calls in your router tree');
         }
         return new Router({
@@ -774,10 +675,10 @@ function safeObject(...args) {
             code: codes.TRPC_ERROR_CODES_BY_KEY[code],
             data: {
                 code,
-                httpStatus: transformTRPCResponse.getHTTPStatusCodeFromError(error)
+                httpStatus: config.getHTTPStatusCodeFromError(error)
             }
         };
-        if (process.env.NODE_ENV !== 'production' && typeof opts.error.stack === 'string') {
+        if (globalThis.process?.env?.NODE_ENV !== 'production' && typeof opts.error.stack === 'string') {
             shape.data.stack = opts.error.stack;
         }
         if (typeof path === 'string') {
@@ -793,7 +694,7 @@ function safeObject(...args) {
    * @link https://trpc.io/docs/data-transformers
    */ transformer(_transformer) {
         const transformer = getDataTransformer(_transformer);
-        if (this._def.transformer !== transformTRPCResponse.defaultTransformer) {
+        if (this._def.transformer !== config.defaultTransformer) {
             throw new Error('You seem to have double `transformer()`-calls in your router tree');
         }
         return new Router({
@@ -820,8 +721,8 @@ function safeObject(...args) {
             mutations: def?.mutations ?? safeObject(),
             subscriptions: def?.subscriptions ?? safeObject(),
             middlewares: def?.middlewares ?? [],
-            errorFormatter: def?.errorFormatter ?? transformTRPCResponse.defaultFormatter,
-            transformer: def?.transformer ?? transformTRPCResponse.defaultTransformer
+            errorFormatter: def?.errorFormatter ?? config.defaultFormatter,
+            transformer: def?.transformer ?? config.defaultTransformer
         };
     }
 }
@@ -831,11 +732,108 @@ function safeObject(...args) {
     return new Router();
 }
 
-exports.resolveHTTPResponse = resolveHTTPResponse.resolveHTTPResponse;
-exports.callProcedure = transformTRPCResponse.callProcedure;
-exports.defaultTransformer = transformTRPCResponse.defaultTransformer;
-exports.getDataTransformer = transformTRPCResponse.getDataTransformer;
-exports.procedureTypes = transformTRPCResponse.procedureTypes;
+function mergeRouters(...routerList) {
+    const record = mergeWithoutOverrides({}, ...routerList.map((r)=>r._def.record));
+    const errorFormatter = routerList.reduce((currentErrorFormatter, nextRouter)=>{
+        if (nextRouter._def._config.errorFormatter && nextRouter._def._config.errorFormatter !== config.defaultFormatter) {
+            if (currentErrorFormatter !== config.defaultFormatter && currentErrorFormatter !== nextRouter._def._config.errorFormatter) {
+                throw new Error('You seem to have several error formatters');
+            }
+            return nextRouter._def._config.errorFormatter;
+        }
+        return currentErrorFormatter;
+    }, config.defaultFormatter);
+    const transformer = routerList.reduce((prev, current)=>{
+        if (current._def._config.transformer && current._def._config.transformer !== config.defaultTransformer) {
+            if (prev !== config.defaultTransformer && prev !== current._def._config.transformer) {
+                throw new Error('You seem to have several transformers');
+            }
+            return current._def._config.transformer;
+        }
+        return prev;
+    }, config.defaultTransformer);
+    const router = config.createRouterFactory({
+        errorFormatter,
+        transformer,
+        isDev: routerList.some((r)=>r._def._config.isDev),
+        allowOutsideOfServer: routerList.some((r)=>r._def._config.allowOutsideOfServer),
+        isServer: routerList.some((r)=>r._def._config.isServer),
+        $types: routerList[0]?._def._config.$types
+    })(record);
+    return router;
+}
+
+function mergeRoutersGeneric(...args) {
+    return mergeRouters(...args);
+}
+
+/**
+ * TODO: This can be improved:
+ * - We should be able to chain `.meta()`/`.context()` only once
+ * - Simplify typings
+ * - Doesn't need to be a class but it doesn't really hurt either
+ */ class TRPCBuilder {
+    context() {
+        return new TRPCBuilder();
+    }
+    meta() {
+        return new TRPCBuilder();
+    }
+    create(options) {
+        return createTRPCInner()(options);
+    }
+}
+/**
+ * Initialize tRPC - be done exactly once per backend
+ */ const initTRPC = new TRPCBuilder();
+function createTRPCInner() {
+    return function initTRPCInner(runtime) {
+        const errorFormatter = runtime?.errorFormatter ?? config.defaultFormatter;
+        const transformer = config.getDataTransformer(runtime?.transformer ?? config.defaultTransformer);
+        const config$1 = {
+            transformer,
+            isDev: runtime?.isDev ?? globalThis.process?.env?.NODE_ENV !== 'production',
+            allowOutsideOfServer: runtime?.allowOutsideOfServer ?? false,
+            errorFormatter,
+            isServer: runtime?.isServer ?? config.isServerDefault,
+            /**
+       * @internal
+       */ $types: index.createFlatProxy((key)=>{
+                throw new Error(`Tried to access "$types.${key}" which is not available at runtime`);
+            })
+        };
+        {
+            // Server check
+            const isServer = runtime?.isServer ?? config.isServerDefault;
+            if (!isServer && runtime?.allowOutsideOfServer !== true) {
+                throw new Error(`You're trying to use @trpc/server in a non-server environment. This is not supported by default.`);
+            }
+        }
+        return {
+            /**
+       * These are just types, they can't be used
+       * @internal
+       */ _config: config$1,
+            /**
+       * Builder object for creating procedures
+       */ procedure: createBuilder(),
+            /**
+       * Create reusable middlewares
+       */ middleware: createMiddlewareFactory(),
+            /**
+       * Create a router
+       */ router: config.createRouterFactory(config$1),
+            /**
+       * Merge Routers
+       */ mergeRouters: mergeRoutersGeneric
+        };
+    };
+}
+
+exports.callProcedure = config.callProcedure;
+exports.defaultTransformer = config.defaultTransformer;
+exports.getDataTransformer = config.getDataTransformer;
+exports.procedureTypes = config.procedureTypes;
 exports.TRPCError = TRPCError.TRPCError;
 exports.createInputMiddleware = createInputMiddleware;
 exports.createOutputMiddleware = createOutputMiddleware;