@trpc/server 10.27.3 → 10.28.1

package/dist/{config-91ab0b1d.js → config-54786004.js}

@@ -1,206 +1,182 @@
-import { T as TRPCError } from './TRPCError-61026c9a.js';
-import { a as createRecursiveProxy, g as getHTTPStatusCodeFromError } from './index-cddfa242.js';
-import { T as TRPC_ERROR_CODES_BY_KEY } from './codes-b3c262d8.js';
+import { T as TRPCError } from './TRPCError-7c3909ea.js';
+import { a as createRecursiveProxy, g as getHTTPStatusCodeFromError } from './index-ca9a128e.js';
+import { T as TRPC_ERROR_CODES_BY_KEY } from './codes-1c9ad84e.js';
 
-/**
- * @internal
- */
-function getDataTransformer(transformer) {
-    if ('input' in transformer) {
-        return transformer;
-    }
-    return { input: transformer, output: transformer };
-}
-/**
- * @internal
- */
-const defaultTransformer = {
-    _default: true,
-    input: { serialize: (obj) => obj, deserialize: (obj) => obj },
-    output: { serialize: (obj) => obj, deserialize: (obj) => obj },
+/**
+ * @internal
+ */
+function getDataTransformer(transformer) {
+    if ('input' in transformer) {
+        return transformer;
+    }
+    return { input: transformer, output: transformer };
+}
+/**
+ * @internal
+ */
+const defaultTransformer = {
+    _default: true,
+    input: { serialize: (obj) => obj, deserialize: (obj) => obj },
+    output: { serialize: (obj) => obj, deserialize: (obj) => obj },
 };
 
-const defaultFormatter = ({ shape, }) => {
-    return shape;
+const defaultFormatter = ({ shape, }) => {
+    return shape;
 };
 
-/**
- * Create an object without inheriting anything from `Object.prototype`
- * @internal
- */
-function omitPrototype(obj) {
-    return Object.assign(Object.create(null), obj);
+/**
+ * Create an object without inheriting anything from `Object.prototype`
+ * @internal
+ */
+function omitPrototype(obj) {
+    return Object.assign(Object.create(null), obj);
 }
 
 const procedureTypes = ['query', 'mutation', 'subscription'];
 
-function isRouter(procedureOrRouter) {
-    return 'router' in procedureOrRouter._def;
-}
-function isNestedRouter(procedureOrRouter) {
-    return !('_def' in procedureOrRouter);
-}
-const emptyRouter = {
-    _ctx: null,
-    _errorShape: null,
-    _meta: null,
-    queries: {},
-    mutations: {},
-    subscriptions: {},
-    errorFormatter: defaultFormatter,
-    transformer: defaultTransformer,
-};
-/**
- * Reserved words that can't be used as router or procedure names
- */
-const reservedWords = [
-    /**
-     * Then is a reserved word because otherwise we can't return a promise that returns a Proxy
-     * since JS will think that `.then` is something that exists
-     */
-    'then',
-    /**
-     * `_def` is a reserved word because it's used internally a lot
-     */
-    '_def',
-];
-/**
- * @internal
- */
-function createRouterFactory(config) {
-    return function createRouterInner(procedures) {
-        const reservedWordsUsed = new Set(Object.keys(procedures).filter((v) => reservedWords.includes(v)));
-        if (reservedWordsUsed.size > 0) {
-            throw new Error('Reserved words used in `router({})` call: ' +
-                Array.from(reservedWordsUsed).join(', '));
-        }
-        const newProcedures = {};
-        for (const [key, procedureOrRouter] of Object.entries(procedures ?? {})) {
-            const value = procedures[key] ?? {};
-            if (isNestedRouter(value)) {
-                newProcedures[key] = createRouterInner(value);
-                continue;
-            }
-            if (isRouter(value)) {
-                newProcedures[key] = procedureOrRouter;
-                continue;
-            }
-            newProcedures[key] = procedureOrRouter;
-        }
-        const routerProcedures = omitPrototype({});
-        function recursiveGetPaths(procedures, path = '') {
-            for (const [key, procedureOrRouter] of Object.entries(procedures ?? {})) {
-                const newPath = `${path}${key}`;
-                if (isNestedRouter(procedureOrRouter)) {
-                    recursiveGetPaths(procedureOrRouter, `${newPath}.`);
-                    continue;
-                }
-                if (isRouter(procedureOrRouter)) {
-                    recursiveGetPaths(procedureOrRouter._def.procedures, `${newPath}.`);
-                    continue;
-                }
-                if (routerProcedures[newPath]) {
-                    throw new Error(`Duplicate key: ${newPath}`);
-                }
-                routerProcedures[newPath] = procedureOrRouter;
-            }
-        }
-        recursiveGetPaths(newProcedures);
-        const _def = {
-            _config: config,
-            router: true,
-            procedures: routerProcedures,
-            ...emptyRouter,
-            record: newProcedures,
-            queries: Object.entries(routerProcedures)
-                .filter((pair) => pair[1]._def.query)
-                .reduce((acc, [key, val]) => ({ ...acc, [key]: val }), {}),
-            mutations: Object.entries(routerProcedures)
-                .filter((pair) => pair[1]._def.mutation)
-                .reduce((acc, [key, val]) => ({ ...acc, [key]: val }), {}),
-            subscriptions: Object.entries(routerProcedures)
-                .filter((pair) => pair[1]._def.subscription)
-                .reduce((acc, [key, val]) => ({ ...acc, [key]: val }), {}),
-        };
-        const router = {
-            ...newProcedures,
-            _def,
-            createCaller(ctx) {
-                const proxy = createRecursiveProxy(({ path, args }) => {
-                    // interop mode
-                    if (path.length === 1 &&
-                        procedureTypes.includes(path[0])) {
-                        return callProcedure({
-                            procedures: _def.procedures,
-                            path: args[0],
-                            rawInput: args[1],
-                            ctx,
-                            type: path[0],
-                        });
-                    }
-                    const fullPath = path.join('.');
-                    const procedure = _def.procedures[fullPath];
-                    let type = 'query';
-                    if (procedure._def.mutation) {
-                        type = 'mutation';
-                    }
-                    else if (procedure._def.subscription) {
-                        type = 'subscription';
-                    }
-                    return procedure({
-                        path: fullPath,
-                        rawInput: args[0],
-                        ctx,
-                        type,
-                    });
-                });
-                return proxy;
-            },
-            getErrorShape(opts) {
-                const { path, error } = opts;
-                const { code } = opts.error;
-                const shape = {
-                    message: error.message,
-                    code: TRPC_ERROR_CODES_BY_KEY[code],
-                    data: {
-                        code,
-                        httpStatus: getHTTPStatusCodeFromError(error),
-                    },
-                };
-                if (config.isDev && typeof opts.error.stack === 'string') {
-                    shape.data.stack = opts.error.stack;
-                }
-                if (typeof path === 'string') {
-                    shape.data.path = path;
-                }
-                return this._def._config.errorFormatter({ ...opts, shape });
-            },
-        };
-        return router;
-    };
-}
-/**
- * @internal
- */
-function callProcedure(opts) {
-    const { type, path } = opts;
-    if (!(path in opts.procedures) || !opts.procedures[path]?._def[type]) {
-        throw new TRPCError({
-            code: 'NOT_FOUND',
-            message: `No "${type}"-procedure on path "${path}"`,
-        });
-    }
-    const procedure = opts.procedures[path];
-    return procedure(opts);
+function isRouter(procedureOrRouter) {
+    return 'router' in procedureOrRouter._def;
+}
+const emptyRouter = {
+    _ctx: null,
+    _errorShape: null,
+    _meta: null,
+    queries: {},
+    mutations: {},
+    subscriptions: {},
+    errorFormatter: defaultFormatter,
+    transformer: defaultTransformer,
+};
+/**
+ * Reserved words that can't be used as router or procedure names
+ */
+const reservedWords = [
+    /**
+     * Then is a reserved word because otherwise we can't return a promise that returns a Proxy
+     * since JS will think that `.then` is something that exists
+     */
+    'then',
+];
+/**
+ * @internal
+ */
+function createRouterFactory(config) {
+    return function createRouterInner(procedures) {
+        const reservedWordsUsed = new Set(Object.keys(procedures).filter((v) => reservedWords.includes(v)));
+        if (reservedWordsUsed.size > 0) {
+            throw new Error('Reserved words used in `router({})` call: ' +
+                Array.from(reservedWordsUsed).join(', '));
+        }
+        const routerProcedures = omitPrototype({});
+        function recursiveGetPaths(procedures, path = '') {
+            for (const [key, procedureOrRouter] of Object.entries(procedures ?? {})) {
+                const newPath = `${path}${key}`;
+                if (isRouter(procedureOrRouter)) {
+                    recursiveGetPaths(procedureOrRouter._def.procedures, `${newPath}.`);
+                    continue;
+                }
+                if (routerProcedures[newPath]) {
+                    throw new Error(`Duplicate key: ${newPath}`);
+                }
+                routerProcedures[newPath] = procedureOrRouter;
+            }
+        }
+        recursiveGetPaths(procedures);
+        const _def = {
+            _config: config,
+            router: true,
+            procedures: routerProcedures,
+            ...emptyRouter,
+            record: procedures,
+            queries: Object.entries(routerProcedures)
+                .filter((pair) => pair[1]._def.query)
+                .reduce((acc, [key, val]) => ({ ...acc, [key]: val }), {}),
+            mutations: Object.entries(routerProcedures)
+                .filter((pair) => pair[1]._def.mutation)
+                .reduce((acc, [key, val]) => ({ ...acc, [key]: val }), {}),
+            subscriptions: Object.entries(routerProcedures)
+                .filter((pair) => pair[1]._def.subscription)
+                .reduce((acc, [key, val]) => ({ ...acc, [key]: val }), {}),
+        };
+        const router = {
+            ...procedures,
+            _def,
+            createCaller(ctx) {
+                const proxy = createRecursiveProxy(({ path, args }) => {
+                    // interop mode
+                    if (path.length === 1 &&
+                        procedureTypes.includes(path[0])) {
+                        return callProcedure({
+                            procedures: _def.procedures,
+                            path: args[0],
+                            rawInput: args[1],
+                            ctx,
+                            type: path[0],
+                        });
+                    }
+                    const fullPath = path.join('.');
+                    const procedure = _def.procedures[fullPath];
+                    let type = 'query';
+                    if (procedure._def.mutation) {
+                        type = 'mutation';
+                    }
+                    else if (procedure._def.subscription) {
+                        type = 'subscription';
+                    }
+                    return procedure({
+                        path: fullPath,
+                        rawInput: args[0],
+                        ctx,
+                        type,
+                    });
+                });
+                return proxy;
+            },
+            getErrorShape(opts) {
+                const { path, error } = opts;
+                const { code } = opts.error;
+                const shape = {
+                    message: error.message,
+                    code: TRPC_ERROR_CODES_BY_KEY[code],
+                    data: {
+                        code,
+                        httpStatus: getHTTPStatusCodeFromError(error),
+                    },
+                };
+                if (config.isDev && typeof opts.error.stack === 'string') {
+                    shape.data.stack = opts.error.stack;
+                }
+                if (typeof path === 'string') {
+                    shape.data.path = path;
+                }
+                return this._def._config.errorFormatter({ ...opts, shape });
+            },
+        };
+        return router;
+    };
+}
+/**
+ * @internal
+ */
+function callProcedure(opts) {
+    const { type, path } = opts;
+    if (!(path in opts.procedures) || !opts.procedures[path]?._def[type]) {
+        throw new TRPCError({
+            code: 'NOT_FOUND',
+            message: `No "${type}"-procedure on path "${path}"`,
+        });
+    }
+    const procedure = opts.procedures[path];
+    return procedure(opts);
 }
 
-/**
- * The default check to see if we're in a server
- */
-const isServerDefault = typeof window === 'undefined' ||
-    'Deno' in window ||
-    globalThis.process?.env?.NODE_ENV === 'test' ||
-    !!globalThis.process?.env?.JEST_WORKER_ID ||
+/**
+ * The default check to see if we're in a server
+ */
+const isServerDefault = typeof window === 'undefined' ||
+    'Deno' in window ||
+    globalThis.process?.env?.NODE_ENV === 'test' ||
+    !!globalThis.process?.env?.JEST_WORKER_ID ||
     !!globalThis.process?.env?.VITEST_WORKER_ID;
 
 export { defaultTransformer as a, callProcedure as b, createRouterFactory as c, defaultFormatter as d, getDataTransformer as g, isServerDefault as i, procedureTypes as p };

package/dist/{config-d1cf9de0.mjs → config-65c5b6d1.mjs}

@@ -1,5 +1,5 @@
 import { T as TRPCError } from './TRPCError-2b10c8d2.mjs';
-import { a as createRecursiveProxy, g as getHTTPStatusCodeFromError } from './index-315a9f08.mjs';
+import { a as createRecursiveProxy, g as getHTTPStatusCodeFromError } from './index-044a193b.mjs';
 import { T as TRPC_ERROR_CODES_BY_KEY } from './codes-24aa1ce1.mjs';
 
 /**
@@ -49,9 +49,6 @@ const procedureTypes = [
 function isRouter(procedureOrRouter) {
     return 'router' in procedureOrRouter._def;
 }
-function isNestedRouter(procedureOrRouter) {
-    return !('_def' in procedureOrRouter);
-}
 const emptyRouter = {
     _ctx: null,
     _errorShape: null,
@@ -68,10 +65,7 @@ const emptyRouter = {
     /**
    * Then is a reserved word because otherwise we can't return a promise that returns a Proxy
    * since JS will think that `.then` is something that exists
-   */ 'then',
-    /**
-   * `_def` is a reserved word because it's used internally a lot
-   */ '_def'
+   */ 'then'
 ];
 /**
  * @internal
@@ -81,27 +75,10 @@ const emptyRouter = {
         if (reservedWordsUsed.size > 0) {
             throw new Error('Reserved words used in `router({})` call: ' + Array.from(reservedWordsUsed).join(', '));
         }
-        const newProcedures = {};
-        for (const [key, procedureOrRouter] of Object.entries(procedures ?? {})){
-            const value = procedures[key] ?? {};
-            if (isNestedRouter(value)) {
-                newProcedures[key] = createRouterInner(value);
-                continue;
-            }
-            if (isRouter(value)) {
-                newProcedures[key] = procedureOrRouter;
-                continue;
-            }
-            newProcedures[key] = procedureOrRouter;
-        }
         const routerProcedures = omitPrototype({});
         function recursiveGetPaths(procedures, path = '') {
             for (const [key, procedureOrRouter] of Object.entries(procedures ?? {})){
                 const newPath = `${path}${key}`;
-                if (isNestedRouter(procedureOrRouter)) {
-                    recursiveGetPaths(procedureOrRouter, `${newPath}.`);
-                    continue;
-                }
                 if (isRouter(procedureOrRouter)) {
                     recursiveGetPaths(procedureOrRouter._def.procedures, `${newPath}.`);
                     continue;
@@ -112,13 +89,13 @@ const emptyRouter = {
                 routerProcedures[newPath] = procedureOrRouter;
             }
         }
-        recursiveGetPaths(newProcedures);
+        recursiveGetPaths(procedures);
         const _def = {
             _config: config,
             router: true,
             procedures: routerProcedures,
             ...emptyRouter,
-            record: newProcedures,
+            record: procedures,
             queries: Object.entries(routerProcedures).filter((pair)=>pair[1]._def.query).reduce((acc, [key, val])=>({
                     ...acc,
                     [key]: val
@@ -133,7 +110,7 @@ const emptyRouter = {
                 }), {})
         };
         const router = {
-            ...newProcedures,
+            ...procedures,
             _def,
             createCaller (ctx) {
                 const proxy = createRecursiveProxy(({ path , args  })=>{

package/dist/{config-f355c4d8.js → config-f3ce0144.js}

@@ -1,7 +1,7 @@
 'use strict';
 
 var TRPCError = require('./TRPCError-16b2e52d.js');
-var index = require('./index-8e243a74.js');
+var index = require('./index-4a823936.js');
 var codes = require('./codes-0eeb600d.js');
 
 /**
@@ -51,9 +51,6 @@ const procedureTypes = [
 function isRouter(procedureOrRouter) {
     return 'router' in procedureOrRouter._def;
 }
-function isNestedRouter(procedureOrRouter) {
-    return !('_def' in procedureOrRouter);
-}
 const emptyRouter = {
     _ctx: null,
     _errorShape: null,
@@ -70,10 +67,7 @@ const emptyRouter = {
     /**
    * Then is a reserved word because otherwise we can't return a promise that returns a Proxy
    * since JS will think that `.then` is something that exists
-   */ 'then',
-    /**
-   * `_def` is a reserved word because it's used internally a lot
-   */ '_def'
+   */ 'then'
 ];
 /**
  * @internal
@@ -83,27 +77,10 @@ const emptyRouter = {
         if (reservedWordsUsed.size > 0) {
             throw new Error('Reserved words used in `router({})` call: ' + Array.from(reservedWordsUsed).join(', '));
         }
-        const newProcedures = {};
-        for (const [key, procedureOrRouter] of Object.entries(procedures ?? {})){
-            const value = procedures[key] ?? {};
-            if (isNestedRouter(value)) {
-                newProcedures[key] = createRouterInner(value);
-                continue;
-            }
-            if (isRouter(value)) {
-                newProcedures[key] = procedureOrRouter;
-                continue;
-            }
-            newProcedures[key] = procedureOrRouter;
-        }
         const routerProcedures = omitPrototype({});
         function recursiveGetPaths(procedures, path = '') {
             for (const [key, procedureOrRouter] of Object.entries(procedures ?? {})){
                 const newPath = `${path}${key}`;
-                if (isNestedRouter(procedureOrRouter)) {
-                    recursiveGetPaths(procedureOrRouter, `${newPath}.`);
-                    continue;
-                }
                 if (isRouter(procedureOrRouter)) {
                     recursiveGetPaths(procedureOrRouter._def.procedures, `${newPath}.`);
                     continue;
@@ -114,13 +91,13 @@ const emptyRouter = {
                 routerProcedures[newPath] = procedureOrRouter;
             }
         }
-        recursiveGetPaths(newProcedures);
+        recursiveGetPaths(procedures);
         const _def = {
             _config: config,
             router: true,
             procedures: routerProcedures,
             ...emptyRouter,
-            record: newProcedures,
+            record: procedures,
             queries: Object.entries(routerProcedures).filter((pair)=>pair[1]._def.query).reduce((acc, [key, val])=>({
                     ...acc,
                     [key]: val
@@ -135,7 +112,7 @@ const emptyRouter = {
                 }), {})
         };
         const router = {
-            ...newProcedures,
+            ...procedures,
             _def,
             createCaller (ctx) {
                 const proxy = index.createRecursiveProxy(({ path , args  })=>{

package/dist/{contentType-f27e4bfc.js → contentType-24c44bba.js}

@@ -1,5 +1,5 @@
-function createNodeHTTPContentTypeHandler(contentTypeHandler) {
-    return () => contentTypeHandler;
+function createNodeHTTPContentTypeHandler(contentTypeHandler) {
+    return () => contentTypeHandler;
 }
 
 export { createNodeHTTPContentTypeHandler as c };

package/dist/{contentType-a75c990c.js → contentType-7354963c.js}

@@ -1,58 +1,58 @@
-import { T as TRPCError, g as getCauseFromUnknown } from './TRPCError-61026c9a.js';
+import { T as TRPCError, g as getCauseFromUnknown } from './TRPCError-7c3909ea.js';
 
-function getRawProcedureInputOrThrow(opts) {
-    const { req } = opts;
-    try {
-        if (req.method === 'GET') {
-            if (!req.query.has('input')) {
-                return undefined;
-            }
-            const raw = req.query.get('input');
-            return JSON.parse(raw);
-        }
-        if (!opts.preprocessedBody && typeof req.body === 'string') {
-            // A mutation with no inputs will have req.body === ''
-            return req.body.length === 0 ? undefined : JSON.parse(req.body);
-        }
-        return req.body;
-    }
-    catch (err) {
-        throw new TRPCError({
-            code: 'PARSE_ERROR',
-            cause: getCauseFromUnknown(err),
-        });
-    }
-}
-const deserializeInputValue = (rawValue, transformer) => {
-    return typeof rawValue !== 'undefined'
-        ? transformer.input.deserialize(rawValue)
-        : rawValue;
-};
-const getJsonContentTypeInputs = (opts) => {
-    const rawInput = getRawProcedureInputOrThrow(opts);
-    const transformer = opts.router._def._config.transformer;
-    if (!opts.isBatchCall) {
-        return {
-            0: deserializeInputValue(rawInput, transformer),
-        };
-    }
-    /* istanbul ignore if  */
-    if (rawInput == null ||
-        typeof rawInput !== 'object' ||
-        Array.isArray(rawInput)) {
-        throw new TRPCError({
-            code: 'BAD_REQUEST',
-            message: '"input" needs to be an object when doing a batch call',
-        });
-    }
-    const input = {};
-    for (const key in rawInput) {
-        const k = key;
-        const rawValue = rawInput[k];
-        const value = deserializeInputValue(rawValue, transformer);
-        input[k] = value;
-    }
-    return input;
+function getRawProcedureInputOrThrow(opts) {
+    const { req } = opts;
+    try {
+        if (req.method === 'GET') {
+            if (!req.query.has('input')) {
+                return undefined;
+            }
+            const raw = req.query.get('input');
+            return JSON.parse(raw);
+        }
+        if (!opts.preprocessedBody && typeof req.body === 'string') {
+            // A mutation with no inputs will have req.body === ''
+            return req.body.length === 0 ? undefined : JSON.parse(req.body);
+        }
+        return req.body;
+    }
+    catch (err) {
+        throw new TRPCError({
+            code: 'PARSE_ERROR',
+            cause: getCauseFromUnknown(err),
+        });
+    }
+}
+const deserializeInputValue = (rawValue, transformer) => {
+    return typeof rawValue !== 'undefined'
+        ? transformer.input.deserialize(rawValue)
+        : rawValue;
+};
+const getJsonContentTypeInputs = (opts) => {
+    const rawInput = getRawProcedureInputOrThrow(opts);
+    const transformer = opts.router._def._config.transformer;
+    if (!opts.isBatchCall) {
+        return {
+            0: deserializeInputValue(rawInput, transformer),
+        };
+    }
+    /* istanbul ignore if  */
+    if (rawInput == null ||
+        typeof rawInput !== 'object' ||
+        Array.isArray(rawInput)) {
+        throw new TRPCError({
+            code: 'BAD_REQUEST',
+            message: '"input" needs to be an object when doing a batch call',
+        });
+    }
+    const input = {};
+    for (const key in rawInput) {
+        const k = key;
+        const rawValue = rawInput[k];
+        const value = deserializeInputValue(rawValue, transformer);
+        input[k] = value;
+    }
+    return input;
 };
 
 export { getJsonContentTypeInputs as g };