@trpc/server 10.0.0-alpha.38 → 10.0.0-alpha.39

package/dist/index.js

@@ -5,6 +5,7 @@ Object.defineProperty(exports, '__esModule', { value: true });
 var resolveHTTPResponse = require('./resolveHTTPResponse-fcc8f644.js');
 var envelopes = require('./envelopes-b6dd0367.js');
 var TRPCError = require('./TRPCError-9050a68d.js');
+var index = require('./index-1a25ccbd.js');
 require('./transformTRPCResponse-0c261655.js');
 
 resolveHTTPResponse.assertNotBrowser();
@@ -363,97 +364,82 @@ const middlewareMarker = 'middlewareMarker';
  * @internal
  */
 
-/**
- * This is the actual internal representation of a builder
- * FIXME - I want to get rid of this and use the public API instead
- */
-
-function createNewInternalBuilder(def1, def2) {
+function createNewBuilder(def1, def2) {
   const {
     middlewares = [],
     ...rest
   } = def2; // TODO: maybe have a fn here to warn about calls
 
-  return createInternalBuilder({ ...mergeWithoutOverrides(def1, rest),
+  return createBuilder({ ...mergeWithoutOverrides(def1, rest),
     middlewares: [...def1.middlewares, ...middlewares]
   });
 }
 
-const codeblock = /*#__PURE__*/`
-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 */
-});
+function createBuilder(initDef) {
+  const _def = initDef || {
+    middlewares: []
+  };
 
-const result = await caller.call('myProcedure', input);
-`.trim();
+  return {
+    _def,
 
-function createProcedureCaller(_def) {
-  const procedure = async function resolve(opts) {
-    if (!opts || !('rawInput' in opts)) {
-      throw new Error(codeblock);
-    } // run the middlewares recursively with the resolver as the last one
+    input(input) {
+      const parser = getParseFn(input);
+      return createNewBuilder(_def, {
+        input,
+        middlewares: [createInputMiddleware(parser)]
+      });
+    },
 
+    output(output) {
+      const parseOutput = getParseFn(output);
+      return createNewBuilder(_def, {
+        output,
+        middlewares: [createOutputMiddleware(parseOutput)]
+      });
+    },
 
-    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.getErrorFromUnknown(cause),
-          marker: middlewareMarker
-        };
-      }
-    }; // there's always at least one "next" since we wrap this.resolver in a middleware
+    meta(meta) {
+      return createNewBuilder(_def, {
+        meta: meta
+      });
+    },
 
+    /** @deprecated **/
+    resolve(resolver) {
+      return createResolver(_def, resolver);
+    },
 
-    const result = await callRecursive();
+    unstable_concat(builder) {
+      return createNewBuilder(_def, builder._def);
+    },
 
-    if (!result) {
-      throw new TRPCError.TRPCError({
-        code: 'INTERNAL_SERVER_ERROR',
-        message: 'No result from middlewares - did you forget to `return next()`?'
+    use(middleware) {
+      return createNewBuilder(_def, {
+        middlewares: [middleware]
       });
-    }
+    },
 
-    if (!result.ok) {
-      // re-throw original error
-      throw result.error;
+    query(resolver) {
+      return createResolver({ ..._def,
+        query: true
+      }, resolver);
+    },
+
+    mutation(resolver) {
+      return createResolver({ ..._def,
+        mutation: true
+      }, resolver);
+    },
+
+    subscription(resolver) {
+      return createResolver({ ..._def,
+        subscription: true
+      }, resolver);
     }
 
-    return result.data;
   };
-
-  procedure._def = _def;
-  procedure.meta = _def.meta;
-  return procedure;
 }
-
 function createInputMiddleware(parse) {
   return async function inputMiddleware({
     next,
@@ -503,7 +489,7 @@ function createOutputMiddleware(parse) {
 }
 
 function createResolver(_def, resolver) {
-  const finalBuilder = createNewInternalBuilder(_def, {
+  const finalBuilder = createNewBuilder(_def, {
     resolver,
     middlewares: [async function resolveMiddleware(opts) {
       const data = await resolver(opts);
@@ -517,72 +503,85 @@ function createResolver(_def, resolver) {
   });
   return createProcedureCaller(finalBuilder._def);
 }
+/**
+ * @internal
+ */
 
-function createInternalBuilder(initDef) {
-  const _def = initDef || {
-    middlewares: []
-  };
 
-  return {
-    _def,
+const codeblock = /*#__PURE__*/`
+If you want to call this function on the server, you do the following:
+This is a client-only function.
 
-    // _call: createProcedureCaller(_def),
-    input(input) {
-      const parser = getParseFn(input);
-      return createNewInternalBuilder(_def, {
-        input,
-        middlewares: [createInputMiddleware(parser)]
-      });
-    },
+const caller = appRouter.createCaller({
+  /* ... your context */
+});
 
-    output(output) {
-      const parseOutput = getParseFn(output);
-      return createNewInternalBuilder(_def, {
-        output,
-        middlewares: [createOutputMiddleware(parseOutput)]
-      });
-    },
+const result = await caller.call('myProcedure', input);
+`.trim();
 
-    meta(meta) {
-      return createNewInternalBuilder(_def, {
-        meta
-      });
-    },
+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
 
-    /** @deprecated **/
-    resolve(resolver) {
-      return createResolver(_def, resolver);
-    },
 
-    unstable_concat(builder) {
-      return createNewInternalBuilder(_def, builder._def);
-    },
+    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.getErrorFromUnknown(cause),
+          marker: middlewareMarker
+        };
+      }
+    }; // there's always at least one "next" since we wrap this.resolver in a middleware
 
-    use(middleware) {
-      return createNewInternalBuilder(_def, {
-        middlewares: [middleware]
-      });
-    },
 
-    query(resolver) {
-      return createResolver({ ..._def,
-        query: true
-      }, resolver);
-    },
+    const result = await callRecursive();
 
-    mutation(resolver) {
-      return createResolver({ ..._def,
-        mutation: true
-      }, resolver);
-    },
+    if (!result) {
+      throw new TRPCError.TRPCError({
+        code: 'INTERNAL_SERVER_ERROR',
+        message: 'No result from middlewares - did you forget to `return next()`?'
+      });
+    }
 
-    subscription(resolver) {
-      return createResolver({ ..._def,
-        subscription: true
-      }, resolver);
+    if (!result.ok) {
+      // re-throw original error
+      throw result.error;
     }
 
+    return result.data;
   };
+
+  procedure._def = _def;
+  procedure.meta = _def.meta;
+  return procedure;
 }
 
 /**
@@ -593,15 +592,15 @@ function omitPrototype(obj1) {
   return Object.assign(Object.create(null), obj1);
 }
 
-/* eslint-disable @typescript-eslint/ban-types */
+const procedureTypes = ['query', 'mutation', 'subscription'];
+/**
+ * @public
+ */
 
-function createRouterProxy(callback) {
-  return new Proxy({}, {
-    get(_, path) {
-      return (...args) => callback(path, ...args);
-    }
+/* eslint-disable @typescript-eslint/ban-types */
 
-  });
+function isRouter(procedureOrRouter) {
+  return 'router' in procedureOrRouter._def;
 }
 
 const emptyRouter = {
@@ -629,9 +628,8 @@ function createRouterFactory(defaults) {
       for (const [key, procedureOrRouter] of Object.entries(procedures !== null && procedures !== void 0 ? procedures : {})) {
         const newPath = `${path}${key}`;
 
-        if (typeof procedureOrRouter === 'object') {
-          const router = procedureOrRouter;
-          recursiveGetPaths(router._def.procedures, `${newPath}.`);
+        if (isRouter(procedureOrRouter)) {
+          recursiveGetPaths(procedureOrRouter._def.procedures, `${newPath}.`);
           continue;
         }
 
@@ -665,68 +663,45 @@ function createRouterFactory(defaults) {
         [key]: val
       }), {})
     };
-
-    function callProcedure(opts) {
-      const {
-        type,
-        path
-      } = opts;
-
-      if (!(path in _def.procedures) || !_def.procedures[path]['_def'][type]) {
-        throw new TRPCError.TRPCError({
-          code: 'NOT_FOUND',
-          message: `No "${type}"-procedure on path "${path}"`
-        });
-      }
-
-      const procedure = _def.procedures[path];
-      return procedure(opts);
-    }
-
     const router = { ...opts,
       _def,
       transformer: _def.transformer,
       errorFormatter: _def.errorFormatter,
 
       createCaller(ctx) {
-        return {
-          query: (path, ...args) => callProcedure({
-            path,
-            rawInput: args[0],
-            ctx,
-            type: 'query'
-          }),
-          mutation: (path, ...args) => callProcedure({
-            path,
-            rawInput: args[0],
-            ctx,
-            type: 'mutation'
-          }),
-          subscription: (path, ...args) => callProcedure({
-            path,
+        const proxy = index.createProxy(({
+          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: 'subscription'
-          }),
-          queries: createRouterProxy((path, rawInput) => callProcedure({
-            path,
-            rawInput,
-            ctx,
-            type: 'query'
-          })),
-          mutations: createRouterProxy((path, rawInput) => callProcedure({
-            path,
-            rawInput,
-            ctx,
-            type: 'mutation'
-          })),
-          subscriptions: createRouterProxy((path, rawInput) => callProcedure({
-            path,
-            rawInput,
-            ctx,
-            type: 'subscription'
-          }))
-        };
+            type
+          });
+        });
+        return proxy;
       },
 
       getErrorShape(opts) {
@@ -763,6 +738,28 @@ function createRouterFactory(defaults) {
     return router;
   };
 }
+/**
+ * @internal
+ */
+
+function callProcedure(opts) {
+  var _opts$procedures$path;
+
+  const {
+    type,
+    path
+  } = opts;
+
+  if (!(path in opts.procedures) || !((_opts$procedures$path = opts.procedures[path]) !== null && _opts$procedures$path !== void 0 && _opts$procedures$path._def[type])) {
+    throw new TRPCError.TRPCError({
+      code: 'NOT_FOUND',
+      message: `No "${type}"-procedure on path "${path}"`
+    });
+  }
+
+  const procedure = opts.procedures[path];
+  return procedure(opts);
+}
 
 function migrateProcedure(oldProc, type) {
   const def = oldProc._def();
@@ -770,7 +767,7 @@ function migrateProcedure(oldProc, type) {
   const inputParser = getParseFnOrPassThrough(def.inputParser);
   const outputParser = getParseFnOrPassThrough(def.outputParser);
   const inputMiddleware = createInputMiddleware(inputParser);
-  const builder = createInternalBuilder({
+  const builder = createBuilder({
     input: def.inputParser,
     middlewares: [...def.middlewares, inputMiddleware, createOutputMiddleware(outputParser)],
     meta: def.meta,
@@ -1138,10 +1135,6 @@ function mergeRoutersGeneric(...args) {
   return mergeRouters(...args);
 }
 
-function createBuilder() {
-  return createInternalBuilder();
-}
-
 /**
  * @internal
  */
@@ -1221,7 +1214,9 @@ function initTRPC() {
 exports.assertNotBrowser = resolveHTTPResponse.assertNotBrowser;
 exports.resolveHTTPResponse = resolveHTTPResponse.resolveHTTPResponse;
 exports.TRPCError = TRPCError.TRPCError;
+exports.callProcedure = callProcedure;
 exports.defaultTransformer = defaultTransformer;
 exports.getDataTransformer = getDataTransformer$1;
 exports.initTRPC = initTRPC;
+exports.procedureTypes = procedureTypes;
 exports.router = router;