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

package/dist/index.mjs

@@ -1,125 +1,13 @@
-export { r as resolveHTTPResponse } from './resolveHTTPResponse-9dff3dcc.mjs';
-import { d as defaultFormatter, a as defaultTransformer, c as createRouterFactory, g as getDataTransformer$1, i as isServerDefault, b as getHTTPStatusCodeFromError } from './transformTRPCResponse-23e99f82.mjs';
-export { e as callProcedure, a as defaultTransformer, g as getDataTransformer, p as procedureTypes } from './transformTRPCResponse-23e99f82.mjs';
+import { c as createRouterFactory, d as defaultFormatter, g as getHTTPStatusCodeFromError, a as defaultTransformer, b as getDataTransformer$1, i as isServerDefault } from './config-287b8ea5.mjs';
+export { e as callProcedure, a as defaultTransformer, b as getDataTransformer, p as procedureTypes } from './config-287b8ea5.mjs';
 import { T as TRPCError, g as getCauseFromUnknown, a as getTRPCErrorFromUnknown } from './TRPCError-e99e7cbe.mjs';
 export { T as TRPCError } from './TRPCError-e99e7cbe.mjs';
 import { T as TRPC_ERROR_CODES_BY_KEY } from './codes-7d21f749.mjs';
 import { c as createFlatProxy } from './index-0332d528.mjs';
 
 /**
- * @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({
-                code: 'BAD_REQUEST',
-                cause: 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({
-                message: 'Output validation failed',
-                code: 'INTERNAL_SERVER_ERROR',
-                cause: 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 !== defaultFormatter) {
-            if (currentErrorFormatter !== defaultFormatter && currentErrorFormatter !== nextRouter._def._config.errorFormatter) {
-                throw new Error('You seem to have several error formatters');
-            }
-            return nextRouter._def._config.errorFormatter;
-        }
-        return currentErrorFormatter;
-    }, defaultFormatter);
-    const transformer = routerList.reduce((prev, current)=>{
-        if (current._def._config.transformer && current._def._config.transformer !== defaultTransformer) {
-            if (prev !== defaultTransformer && prev !== current._def._config.transformer) {
-                throw new Error('You seem to have several transformers');
-            }
-            return current._def._config.transformer;
-        }
-        return prev;
-    }, defaultTransformer);
-    const router = 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;
@@ -146,129 +34,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({
+                code: 'BAD_REQUEST',
+                cause: 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({
+                code: 'INTERNAL_SERVER_ERROR',
+                cause: 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,
@@ -276,28 +96,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: getTRPCErrorFromUnknown(cause),
                     marker: middlewareMarker$1
@@ -317,79 +132,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 ?? defaultFormatter;
-        const transformer = getDataTransformer$1(runtime?.transformer ?? defaultTransformer);
-        const config = {
-            transformer,
-            isDev: runtime?.isDev ?? process.env.NODE_ENV !== 'production',
-            allowOutsideOfServer: runtime?.allowOutsideOfServer ?? false,
-            errorFormatter,
-            isServer: runtime?.isServer ?? isServerDefault,
-            /**
-       * @internal
-       */ $types: createFlatProxy((key)=>{
-                throw new Error(`Tried to access "$types.${key}" which is not available at runtime`);
-            })
-        };
-        {
-            // Server check
-            const isServer = runtime?.isServer ?? 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({
+                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: 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') {
@@ -415,61 +205,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({
                 code: 'BAD_REQUEST',
                 cause: getCauseFromUnknown(cause)
             });
-        }
-    }
-    async parseOutput(rawOutput) {
-        try {
-            return await this.parseOutputFn(rawOutput);
-        } catch (cause) {
-            throw new TRPCError({
-                code: 'INTERNAL_SERVER_ERROR',
-                cause: getCauseFromUnknown(cause),
-                message: 'Output validation failed'
+        }
+        // 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({
+                message: 'Output validation failed',
+                code: 'INTERNAL_SERVER_ERROR',
+                cause: 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,
@@ -477,23 +415,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: getTRPCErrorFromUnknown(cause),
                     marker: middlewareMarker
@@ -513,52 +456,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({
-                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) {
@@ -829,4 +730,102 @@ function safeObject(...args) {
     return new Router();
 }
 
+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 !== defaultFormatter) {
+            if (currentErrorFormatter !== defaultFormatter && currentErrorFormatter !== nextRouter._def._config.errorFormatter) {
+                throw new Error('You seem to have several error formatters');
+            }
+            return nextRouter._def._config.errorFormatter;
+        }
+        return currentErrorFormatter;
+    }, defaultFormatter);
+    const transformer = routerList.reduce((prev, current)=>{
+        if (current._def._config.transformer && current._def._config.transformer !== defaultTransformer) {
+            if (prev !== defaultTransformer && prev !== current._def._config.transformer) {
+                throw new Error('You seem to have several transformers');
+            }
+            return current._def._config.transformer;
+        }
+        return prev;
+    }, defaultTransformer);
+    const router = 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 ?? defaultFormatter;
+        const transformer = getDataTransformer$1(runtime?.transformer ?? defaultTransformer);
+        const config = {
+            transformer,
+            isDev: runtime?.isDev ?? process.env.NODE_ENV !== 'production',
+            allowOutsideOfServer: runtime?.allowOutsideOfServer ?? false,
+            errorFormatter,
+            isServer: runtime?.isServer ?? isServerDefault,
+            /**
+       * @internal
+       */ $types: createFlatProxy((key)=>{
+                throw new Error(`Tried to access "$types.${key}" which is not available at runtime`);
+            })
+        };
+        {
+            // Server check
+            const isServer = runtime?.isServer ?? 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,
+            /**
+       * Builder object for creating procedures
+       */ procedure: createBuilder(),
+            /**
+       * Create reusable middlewares
+       */ middleware: createMiddlewareFactory(),
+            /**
+       * Create a router
+       */ router: createRouterFactory(config),
+            /**
+       * Merge Routers
+       */ mergeRouters: mergeRoutersGeneric
+        };
+    };
+}
+
 export { createInputMiddleware, createOutputMiddleware, initTRPC, router };