@trpc/server 10.28.0 → 10.28.1

package/dist/{codes-b3c262d8.js → codes-1c9ad84e.js}

@@ -1,49 +1,49 @@
-/**
- * @internal
- */
-function invert(obj) {
-    const newObj = Object.create(null);
-    for (const key in obj) {
-        const v = obj[key];
-        newObj[v] = key;
-    }
-    return newObj;
+/**
+ * @internal
+ */
+function invert(obj) {
+    const newObj = Object.create(null);
+    for (const key in obj) {
+        const v = obj[key];
+        newObj[v] = key;
+    }
+    return newObj;
 }
 
-// reference: https://www.jsonrpc.org/specification
-/**
- * JSON-RPC 2.0 Error codes
- *
- * `-32000` to `-32099` are reserved for implementation-defined server-errors.
- * For tRPC we're copying the last digits of HTTP 4XX errors.
- */
-const TRPC_ERROR_CODES_BY_KEY = {
-    /**
-     * Invalid JSON was received by the server.
-     * An error occurred on the server while parsing the JSON text.
-     */
-    PARSE_ERROR: -32700,
-    /**
-     * The JSON sent is not a valid Request object.
-     */
-    BAD_REQUEST: -32600,
-    /**
-     * Internal JSON-RPC error.
-     */
-    INTERNAL_SERVER_ERROR: -32603,
-    // Implementation specific errors
-    UNAUTHORIZED: -32001,
-    FORBIDDEN: -32003,
-    NOT_FOUND: -32004,
-    METHOD_NOT_SUPPORTED: -32005,
-    TIMEOUT: -32008,
-    CONFLICT: -32009,
-    PRECONDITION_FAILED: -32012,
-    PAYLOAD_TOO_LARGE: -32013,
-    UNPROCESSABLE_CONTENT: -32022,
-    TOO_MANY_REQUESTS: -32029,
-    CLIENT_CLOSED_REQUEST: -32099, // 499
-};
+// reference: https://www.jsonrpc.org/specification
+/**
+ * JSON-RPC 2.0 Error codes
+ *
+ * `-32000` to `-32099` are reserved for implementation-defined server-errors.
+ * For tRPC we're copying the last digits of HTTP 4XX errors.
+ */
+const TRPC_ERROR_CODES_BY_KEY = {
+    /**
+     * Invalid JSON was received by the server.
+     * An error occurred on the server while parsing the JSON text.
+     */
+    PARSE_ERROR: -32700,
+    /**
+     * The JSON sent is not a valid Request object.
+     */
+    BAD_REQUEST: -32600,
+    /**
+     * Internal JSON-RPC error.
+     */
+    INTERNAL_SERVER_ERROR: -32603,
+    // Implementation specific errors
+    UNAUTHORIZED: -32001,
+    FORBIDDEN: -32003,
+    NOT_FOUND: -32004,
+    METHOD_NOT_SUPPORTED: -32005,
+    TIMEOUT: -32008,
+    CONFLICT: -32009,
+    PRECONDITION_FAILED: -32012,
+    PAYLOAD_TOO_LARGE: -32013,
+    UNPROCESSABLE_CONTENT: -32022,
+    TOO_MANY_REQUESTS: -32029,
+    CLIENT_CLOSED_REQUEST: -32099, // 499
+};
 const TRPC_ERROR_CODES_BY_NUMBER = invert(TRPC_ERROR_CODES_BY_KEY);
 
 export { TRPC_ERROR_CODES_BY_KEY as T, TRPC_ERROR_CODES_BY_NUMBER as a, invert as i };

package/dist/{config-1a5a494d.js → config-54786004.js}

@@ -1,182 +1,182 @@
-import { T as TRPCError } from './TRPCError-61026c9a.js';
-import { a as createRecursiveProxy, g as getHTTPStatusCodeFromError } from './index-6d5795e9.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;
-}
-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);
+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/{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 };

package/dist/core/index.d.ts

@@ -1,9 +1,9 @@
-export type { AnyRouter, ProcedureRecord, ProcedureRouterRecord, CreateRouterInner, Router, } from './router';
-export { callProcedure } from './router';
-export type { Procedure, AnyProcedure, AnyQueryProcedure, AnyMutationProcedure, AnySubscriptionProcedure, ProcedureParams, ProcedureArgs, ProcedureOptions, } from './procedure';
-export type { inferParser } from './parser';
-export { createInputMiddleware, createOutputMiddleware } from './middleware';
-export type { MiddlewareFunction, MiddlewareBuilder } from './middleware';
-export { initTRPC } from './initTRPC';
-export * from './types';
+export type { AnyRouter, ProcedureRecord, ProcedureRouterRecord, CreateRouterInner, Router, } from './router';
+export { callProcedure } from './router';
+export type { Procedure, AnyProcedure, AnyQueryProcedure, AnyMutationProcedure, AnySubscriptionProcedure, ProcedureParams, ProcedureArgs, ProcedureOptions, } from './procedure';
+export type { inferParser } from './parser';
+export { createInputMiddleware, createOutputMiddleware } from './middleware';
+export type { MiddlewareFunction, MiddlewareBuilder } from './middleware';
+export { initTRPC } from './initTRPC';
+export * from './types';
 //# sourceMappingURL=index.d.ts.map