@trpc/server 10.0.0-proxy-beta.4 → 10.0.0-proxy-beta.6

package/dist/{router-a33b17a3.mjs → router-6e04fa44.mjs}

@@ -1,6 +1,273 @@
-import { f as assertNotBrowser, m as mergeWithoutOverrides, c as createRouterFactory, k as getParseFnOrPassThrough, i as createInputMiddleware, b as createBuilder, j as createOutputMiddleware, d as defaultFormatter, l as getHTTPStatusCodeFromError, a as defaultTransformer } from './resolveHTTPResponse-3c852af0.mjs';
-import { T as TRPC_ERROR_CODES_BY_KEY } from './codes-f164ac85.mjs';
-import { T as TRPCError, g as getCauseFromUnknown, a as getTRPCErrorFromUnknown } from './TRPCError-e99e7cbe.mjs';
+import { m as mergeWithoutOverrides, b as assertNotBrowser, c as createRouterFactory, d as defaultFormatter, f as getHTTPStatusCodeFromError, a as defaultTransformer } from './resolveHTTPResponse-24d99c94.mjs';
+import { T as TRPC_ERROR_CODES_BY_KEY } from './codes-7d21f749.mjs';
+import { T as TRPCError, a as getCauseFromUnknown, g as getTRPCErrorFromUnknown } from './TRPCError-281ac25a.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;
+}
+
+function getParseFn$1(procedureParser) {
+    const parser = procedureParser;
+    if (typeof parser === 'function') {
+        // ProcedureParserCustomValidatorEsque
+        return parser;
+    }
+    if (typeof parser.parseAsync === 'function') {
+        // ProcedureParserZodEsque
+        return parser.parseAsync.bind(parser);
+    }
+    if (typeof parser.parse === 'function') {
+        // ProcedureParserZodEsque
+        return parser.parse.bind(parser);
+    }
+    if (typeof parser.validateSync === 'function') {
+        // ProcedureParserYupEsque
+        return parser.validateSync.bind(parser);
+    }
+    if (typeof parser.create === 'function') {
+        // ProcedureParserSuperstructEsque
+        return parser.create.bind(parser);
+    }
+    throw new Error('Could not find a validator fn');
+}
+/**
+ * @deprecated only for backwards compat
+ * @internal
+ */ function getParseFnOrPassThrough(procedureParser) {
+    if (!procedureParser) {
+        return (v)=>v;
+    }
+    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
+            });
+        },
+        unstable_concat (builder) {
+            return createNewBuilder(_def, builder._def);
+        },
+        use (middleware) {
+            return createNewBuilder(_def, {
+                middlewares: [
+                    middleware
+                ]
+            });
+        },
+        query (resolver) {
+            return createResolver({
+                ..._def,
+                query: true
+            }, resolver);
+        },
+        mutation (resolver) {
+            return createResolver({
+                ..._def,
+                mutation: true
+            }, resolver);
+        },
+        subscription (resolver) {
+            return createResolver({
+                ..._def,
+                subscription: true
+            }, resolver);
+        }
+    };
+}
+function createResolver(_def, resolver) {
+    const finalBuilder = createNewBuilder(_def, {
+        resolver,
+        middlewares: [
+            async function resolveMiddleware(opts) {
+                const data = await resolver(opts);
+                return {
+                    marker: middlewareMarker$1,
+                    ok: true,
+                    data,
+                    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,
+            ctx: opts.ctx
+        })=>{
+            try {
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                const middleware = _def.middlewares[callOpts.index];
+                const result = await middleware({
+                    ctx: callOpts.ctx,
+                    type: opts.type,
+                    path: opts.path,
+                    rawInput: opts.rawInput,
+                    meta: _def.meta,
+                    input: callOpts.input,
+                    next: async (nextOpts)=>{
+                        return await callRecursive({
+                            index: callOpts.index + 1,
+                            ctx: nextOpts && 'ctx' in nextOpts ? {
+                                ...callOpts.ctx,
+                                ...nextOpts.ctx
+                            } : callOpts.ctx,
+                            input: nextOpts && 'input' in nextOpts ? nextOpts.input : callOpts.input
+                        });
+                    }
+                });
+                return result;
+            } catch (cause) {
+                return {
+                    ok: false,
+                    error: getTRPCErrorFromUnknown(cause),
+                    marker: middlewareMarker$1
+                };
+            }
+        };
+        // there's always at least one "next" since we wrap this.resolver in a middleware
+        const result = await callRecursive();
+        if (!result) {
+            throw new TRPCError({
+                code: 'INTERNAL_SERVER_ERROR',
+                message: 'No result from middlewares - did you forget to `return next()`?'
+            });
+        }
+        if (!result.ok) {
+            // re-throw original error
+            throw result.error;
+        }
+        return result.data;
+    };
+    procedure._def = _def;
+    procedure.meta = _def.meta;
+    return procedure;
+}
 
 assertNotBrowser();
 
@@ -87,7 +354,7 @@ function getParseFn(procedureParser) {
                     data,
                     ctx
                 };
-            }, 
+            }
         ]);
         // run the middlewares recursively with the resolver as the last one
         const callRecursive = async (callOpts = {
@@ -192,7 +459,7 @@ function migrateProcedure(oldProc, type) {
         middlewares: [
             ...def.middlewares,
             inputMiddleware,
-            createOutputMiddleware(outputParser), 
+            createOutputMiddleware(outputParser)
         ],
         meta: def.meta,
         output: def.outputParser,
@@ -296,7 +563,7 @@ function safeObject(...args) {
         const duplicates = [
             ...duplicateQueries,
             ...duplicateMutations,
-            ...duplicateSubscriptions, 
+            ...duplicateSubscriptions
         ];
         if (duplicates.length) {
             throw new Error(`Duplicate endpoint(s): ${duplicates.join(', ')}`);
@@ -448,4 +715,4 @@ function safeObject(...args) {
     return new Router();
 }
 
-export { router as r };
+export { createMiddlewareFactory as a, createInputMiddleware as b, createBuilder as c, createOutputMiddleware as d, router as r };

package/dist/{router-c87a28f9.js → router-bf52be2e.js}

@@ -1,9 +1,276 @@
 'use strict';
 
-var resolveHTTPResponse = require('./resolveHTTPResponse-a52a77cb.js');
-var codes = require('./codes-731f0a7c.js');
+var resolveHTTPResponse = require('./resolveHTTPResponse-0a8e47b8.js');
+var codes = require('./codes-76c38a34.js');
 var TRPCError = require('./TRPCError-fe9113e5.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;
+}
+
+function getParseFn$1(procedureParser) {
+    const parser = procedureParser;
+    if (typeof parser === 'function') {
+        // ProcedureParserCustomValidatorEsque
+        return parser;
+    }
+    if (typeof parser.parseAsync === 'function') {
+        // ProcedureParserZodEsque
+        return parser.parseAsync.bind(parser);
+    }
+    if (typeof parser.parse === 'function') {
+        // ProcedureParserZodEsque
+        return parser.parse.bind(parser);
+    }
+    if (typeof parser.validateSync === 'function') {
+        // ProcedureParserYupEsque
+        return parser.validateSync.bind(parser);
+    }
+    if (typeof parser.create === 'function') {
+        // ProcedureParserSuperstructEsque
+        return parser.create.bind(parser);
+    }
+    throw new Error('Could not find a validator fn');
+}
+/**
+ * @deprecated only for backwards compat
+ * @internal
+ */ function getParseFnOrPassThrough(procedureParser) {
+    if (!procedureParser) {
+        return (v)=>v;
+    }
+    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({
+        ...resolveHTTPResponse.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
+            });
+        },
+        unstable_concat (builder) {
+            return createNewBuilder(_def, builder._def);
+        },
+        use (middleware) {
+            return createNewBuilder(_def, {
+                middlewares: [
+                    middleware
+                ]
+            });
+        },
+        query (resolver) {
+            return createResolver({
+                ..._def,
+                query: true
+            }, resolver);
+        },
+        mutation (resolver) {
+            return createResolver({
+                ..._def,
+                mutation: true
+            }, resolver);
+        },
+        subscription (resolver) {
+            return createResolver({
+                ..._def,
+                subscription: true
+            }, resolver);
+        }
+    };
+}
+function createResolver(_def, resolver) {
+    const finalBuilder = createNewBuilder(_def, {
+        resolver,
+        middlewares: [
+            async function resolveMiddleware(opts) {
+                const data = await resolver(opts);
+                return {
+                    marker: middlewareMarker$1,
+                    ok: true,
+                    data,
+                    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,
+            ctx: opts.ctx
+        })=>{
+            try {
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                const middleware = _def.middlewares[callOpts.index];
+                const result = await middleware({
+                    ctx: callOpts.ctx,
+                    type: opts.type,
+                    path: opts.path,
+                    rawInput: opts.rawInput,
+                    meta: _def.meta,
+                    input: callOpts.input,
+                    next: async (nextOpts)=>{
+                        return await callRecursive({
+                            index: callOpts.index + 1,
+                            ctx: nextOpts && 'ctx' in nextOpts ? {
+                                ...callOpts.ctx,
+                                ...nextOpts.ctx
+                            } : callOpts.ctx,
+                            input: nextOpts && 'input' in nextOpts ? nextOpts.input : callOpts.input
+                        });
+                    }
+                });
+                return result;
+            } catch (cause) {
+                return {
+                    ok: false,
+                    error: TRPCError.getTRPCErrorFromUnknown(cause),
+                    marker: middlewareMarker$1
+                };
+            }
+        };
+        // there's always at least one "next" since we wrap this.resolver in a middleware
+        const result = await callRecursive();
+        if (!result) {
+            throw new TRPCError.TRPCError({
+                code: 'INTERNAL_SERVER_ERROR',
+                message: 'No result from middlewares - did you forget to `return next()`?'
+            });
+        }
+        if (!result.ok) {
+            // re-throw original error
+            throw result.error;
+        }
+        return result.data;
+    };
+    procedure._def = _def;
+    procedure.meta = _def.meta;
+    return procedure;
+}
+
 resolveHTTPResponse.assertNotBrowser();
 
 /**
@@ -89,7 +356,7 @@ function getParseFn(procedureParser) {
                     data,
                     ctx
                 };
-            }, 
+            }
         ]);
         // run the middlewares recursively with the resolver as the last one
         const callRecursive = async (callOpts = {
@@ -184,17 +451,17 @@ function createProcedure(opts) {
 
 function migrateProcedure(oldProc, type) {
     const def = oldProc._def();
-    const inputParser = resolveHTTPResponse.getParseFnOrPassThrough(def.inputParser);
-    const outputParser = resolveHTTPResponse.getParseFnOrPassThrough(def.outputParser);
-    const inputMiddleware = resolveHTTPResponse.createInputMiddleware(inputParser);
-    const builder = resolveHTTPResponse.createBuilder({
+    const inputParser = getParseFnOrPassThrough(def.inputParser);
+    const outputParser = getParseFnOrPassThrough(def.outputParser);
+    const inputMiddleware = createInputMiddleware(inputParser);
+    const builder = createBuilder({
         inputs: [
             def.inputParser
         ],
         middlewares: [
             ...def.middlewares,
             inputMiddleware,
-            resolveHTTPResponse.createOutputMiddleware(outputParser), 
+            createOutputMiddleware(outputParser)
         ],
         meta: def.meta,
         output: def.outputParser,
@@ -298,7 +565,7 @@ function safeObject(...args) {
         const duplicates = [
             ...duplicateQueries,
             ...duplicateMutations,
-            ...duplicateSubscriptions, 
+            ...duplicateSubscriptions
         ];
         if (duplicates.length) {
             throw new Error(`Duplicate endpoint(s): ${duplicates.join(', ')}`);
@@ -450,4 +717,8 @@ function safeObject(...args) {
     return new Router();
 }
 
+exports.createBuilder = createBuilder;
+exports.createInputMiddleware = createInputMiddleware;
+exports.createMiddlewareFactory = createMiddlewareFactory;
+exports.createOutputMiddleware = createOutputMiddleware;
 exports.router = router;

package/dist/rpc/codes.d.ts

@@ -26,6 +26,7 @@ export declare const TRPC_ERROR_CODES_BY_KEY: {
     readonly CONFLICT: -32009;
     readonly PRECONDITION_FAILED: -32012;
     readonly PAYLOAD_TOO_LARGE: -32013;
+    readonly TOO_MANY_REQUESTS: -32029;
     readonly CLIENT_CLOSED_REQUEST: -32099;
 };
 export declare const TRPC_ERROR_CODES_BY_NUMBER: {
@@ -40,6 +41,7 @@ export declare const TRPC_ERROR_CODES_BY_NUMBER: {
     [-32009]: "CONFLICT";
     [-32012]: "PRECONDITION_FAILED";
     [-32013]: "PAYLOAD_TOO_LARGE";
+    [-32029]: "TOO_MANY_REQUESTS";
     [-32099]: "CLIENT_CLOSED_REQUEST";
 };
 declare type ValueOf<TObj> = TObj[keyof TObj];

package/dist/rpc/codes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"codes.d.ts","sourceRoot":"","sources":["../../../../packages/server/src/rpc/codes.ts"],"names":[],"mappings":"AAIA;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB;IAClC;;;OAGG;;IAEH;;OAEG;;IAEH;;OAEG;;;;;;;;;;;CAYK,CAAC;AAEX,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;CAAkC,CAAC;AAC1E,aAAK,OAAO,CAAC,IAAI,IAAI,IAAI,CAAC,MAAM,IAAI,CAAC,CAAC;AAEtC,oBAAY,sBAAsB,GAAG,OAAO,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAC7E,oBAAY,mBAAmB,GAAG,MAAM,OAAO,uBAAuB,CAAC"}
+{"version":3,"file":"codes.d.ts","sourceRoot":"","sources":["../../../../packages/server/src/rpc/codes.ts"],"names":[],"mappings":"AAIA;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB;IAClC;;;OAGG;;IAEH;;OAEG;;IAEH;;OAEG;;;;;;;;;;;;CAaK,CAAC;AAEX,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;CAAkC,CAAC;AAC1E,aAAK,OAAO,CAAC,IAAI,IAAI,IAAI,CAAC,MAAM,IAAI,CAAC,CAAC;AAEtC,oBAAY,sBAAsB,GAAG,OAAO,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAC7E,oBAAY,mBAAmB,GAAG,MAAM,OAAO,uBAAuB,CAAC"}

package/dist/rpc/index.js

@@ -2,7 +2,7 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var codes = require('../codes-731f0a7c.js');
+var codes = require('../codes-76c38a34.js');
 
 
 

package/dist/rpc/index.mjs

@@ -1 +1 @@
-export { T as TRPC_ERROR_CODES_BY_KEY, a as TRPC_ERROR_CODES_BY_NUMBER } from '../codes-f164ac85.mjs';
+export { T as TRPC_ERROR_CODES_BY_KEY, a as TRPC_ERROR_CODES_BY_NUMBER } from '../codes-7d21f749.mjs';

package/dist/subscription.mjs

@@ -1,4 +1,4 @@
-import { a as getTRPCErrorFromUnknown } from './TRPCError-e99e7cbe.mjs';
+import { g as getTRPCErrorFromUnknown } from './TRPCError-281ac25a.mjs';
 import { o as observable } from './observable-e129ac9d.mjs';
 
 function subscriptionPullFactory(opts) {