@trpc/server 10.0.0-alpha.24 → 10.0.0-alpha.27

package/dist/index.js

@@ -2,19 +2,93 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var resolveHTTPResponse = require('./resolveHTTPResponse-ec3dccaa.js');
-var envelopes = require('./envelopes-a953b930.js');
-var TRPCError = require('./TRPCError-ddec3395.js');
-require('./transformTRPCResponse-333bed6c.js');
+var resolveHTTPResponse = require('./resolveHTTPResponse-fcc8f644.js');
+var envelopes = require('./envelopes-b6dd0367.js');
+var TRPCError = require('./TRPCError-9050a68d.js');
+require('./transformTRPCResponse-0c261655.js');
 
 resolveHTTPResponse.assertNotBrowser();
 
-const middlewareMarker = 'middlewareMarker';
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+
+/**
+ * @internal
+ */
+function getDataTransformer$1(transformer) {
+  if ('input' in transformer) {
+    return transformer;
+  }
+
+  return {
+    input: transformer,
+    output: transformer
+  };
+}
+/**
+ * @internal
+ */
+
+/**
+ * @internal
+ */
+const defaultTransformer = {
+  _default: true,
+  input: {
+    serialize: obj => obj,
+    deserialize: obj => obj
+  },
+  output: {
+    serialize: obj => obj,
+    deserialize: obj => obj
+  }
+};
+
+/**
+ * @internal
+ */
+
+/**
+ * @internal
+ */
+
+/**
+ * @internal
+ */
+const defaultFormatter = ({
+  shape
+}) => {
+  return shape;
+};
+
+/**
+ * @deprecated
+ */
+const middlewareMarker$1 = 'middlewareMarker';
 
 /* eslint-disable @typescript-eslint/no-explicit-any */
 resolveHTTPResponse.assertNotBrowser();
 
-function getParseFn(procedureParser) {
+function getParseFn$1(procedureParser) {
   const parser = procedureParser;
 
   if (typeof parser === 'function') {
@@ -46,6 +120,7 @@ function getParseFn(procedureParser) {
 }
 /**
  * @internal
+ * @deprecated
  */
 
 
@@ -61,12 +136,22 @@ class Procedure {
     this.middlewares = opts.middlewares;
     this.resolver = opts.resolver;
     this.inputParser = opts.inputParser;
-    this.parseInputFn = getParseFn(this.inputParser);
+    this.parseInputFn = getParseFn$1(this.inputParser);
     this.outputParser = opts.outputParser;
-    this.parseOutputFn = getParseFn(this.outputParser);
+    this.parseOutputFn = getParseFn$1(this.outputParser);
     this.meta = opts.meta;
   }
 
+  _def() {
+    return {
+      middlewares: this.middlewares,
+      resolver: this.resolver,
+      inputParser: this.inputParser,
+      outputParser: this.outputParser,
+      meta: this.meta
+    };
+  }
+
   async parseInput(rawInput) {
     try {
       return await this.parseInputFn(rawInput);
@@ -107,7 +192,7 @@ class Procedure {
       });
       const data = await this.parseOutput(rawOutput);
       return {
-        marker: middlewareMarker,
+        marker: middlewareMarker$1,
         ok: true,
         data,
         ctx
@@ -138,7 +223,7 @@ class Procedure {
           ctx: callOpts.ctx,
           ok: false,
           error: TRPCError.getErrorFromUnknown(cause),
-          marker: middlewareMarker
+          marker: middlewareMarker$1
         };
       }
     }; // there's always at least one "next" since we wrap this.resolver in a middleware
@@ -200,12 +285,487 @@ function createProcedure(opts) {
   });
 }
 
+function getParseFn(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(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
+ */
+
+/**
+ * @internal
+ */
+
+/**
+ * @internal
+ */
+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) {
+  const {
+    middlewares = [],
+    ...rest
+  } = def2; // TODO: maybe have a fn here to warn about calls
+
+  return createInternalBuilder({ ...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 */
+});
+
+const result = await caller.call('myProcedure', input);
+`.trim();
+
+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
+
+
+    const callRecursive = async (callOpts = {
+      index: 0,
+      ctx: opts.ctx
+    }) => {
+      try {
+        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
+
+
+    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;
+}
+
+function createInputMiddleware(parse) {
+  return async function inputMiddleware({
+    next,
+    rawInput
+  }) {
+    let input;
+
+    try {
+      input = await parse(rawInput);
+    } catch (cause) {
+      throw new TRPCError.TRPCError({
+        code: 'BAD_REQUEST',
+        cause: TRPCError.getCauseFromUnknown(cause)
+      });
+    } // TODO fix this typing?
+
+
+    return next({
+      input
+    });
+  };
+}
+function createOutputMiddleware(parse) {
+  return async function outputMiddleware({
+    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)
+      });
+    }
+  };
+}
+function createInternalBuilder(initDef) {
+  const _def = initDef || {
+    middlewares: []
+  };
+
+  return {
+    _def,
+
+    // _call: createProcedureCaller(_def),
+    input(input) {
+      const parser = getParseFn(input);
+      return createNewInternalBuilder(_def, {
+        input,
+        middlewares: [createInputMiddleware(parser)]
+      });
+    },
+
+    output(output) {
+      const parseOutput = getParseFn(output);
+      return createNewInternalBuilder(_def, {
+        output,
+        middlewares: [createOutputMiddleware(parseOutput)]
+      });
+    },
+
+    meta(meta) {
+      return createNewInternalBuilder(_def, {
+        meta
+      });
+    },
+
+    resolve(resolver) {
+      const finalBuilder = createNewInternalBuilder(_def, {
+        resolver,
+        middlewares: [async function resolveMiddleware(opts) {
+          const data = await resolver(opts);
+          return {
+            marker: middlewareMarker,
+            ok: true,
+            data,
+            ctx: opts.ctx
+          };
+        }]
+      });
+      return createProcedureCaller(finalBuilder._def);
+    },
+
+    unstable_concat(builder) {
+      return createNewInternalBuilder(_def, builder._def);
+    },
+
+    use(middleware) {
+      return createNewInternalBuilder(_def, {
+        middlewares: [middleware]
+      });
+    }
+
+  };
+}
+
+/**
+ * Create an object without inheriting anything from `Object.prototype`
+ * @internal
+ */
+function omitPrototype(obj1) {
+  return Object.assign(Object.create(null), obj1);
+}
+
 /* eslint-disable @typescript-eslint/ban-types */
-resolveHTTPResponse.assertNotBrowser();
+
+function createRouterProxy(callback) {
+  return new Proxy({}, {
+    get(_, path) {
+      return (...args) => callback(path, ...args);
+    }
+
+  });
+}
+
+const emptyRouter = {
+  _ctx: null,
+  _errorShape: null,
+  _meta: null,
+  queries: {},
+  mutations: {},
+  subscriptions: {},
+  errorFormatter: defaultFormatter,
+  transformer: defaultTransformer
+}; // type EmptyRouter = typeof emptyRouter;
+
+const PROCEDURE_DEFINITION_MAP$1 = {
+  query: 'queries',
+  mutation: 'mutations',
+  subscription: 'subscriptions'
+};
 /**
- * @public
+ *
+ * @internal
  */
 
+function createRouterFactory(defaults) {
+  return function createRouterInner(procedures) {
+    var _defaults$transformer, _defaults$errorFormat;
+
+    const result = mergeWithoutOverrides({
+      transformer: (_defaults$transformer = defaults === null || defaults === void 0 ? void 0 : defaults.transformer) !== null && _defaults$transformer !== void 0 ? _defaults$transformer : defaultTransformer,
+      errorFormatter: (_defaults$errorFormat = defaults === null || defaults === void 0 ? void 0 : defaults.errorFormatter) !== null && _defaults$errorFormat !== void 0 ? _defaults$errorFormat : defaultFormatter
+    }, {
+      queries: omitPrototype(procedures.queries),
+      mutations: omitPrototype(procedures.mutations),
+      subscriptions: omitPrototype(procedures.subscriptions)
+    });
+    const _def = { ...emptyRouter,
+      ...result
+    };
+    const def = {
+      _def,
+      ..._def
+    };
+
+    function callProcedure(opts) {
+      const {
+        type,
+        path
+      } = opts;
+      const defTarget = PROCEDURE_DEFINITION_MAP$1[type];
+      const defs = def[defTarget];
+
+      if (!(path in defs)) {
+        throw new TRPCError.TRPCError({
+          code: 'NOT_FOUND',
+          message: `No "${type}"-procedure on path "${path}"`
+        });
+      }
+
+      const procedure = defs[path];
+      return procedure(opts);
+    }
+
+    const router = { ...def,
+
+      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,
+            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'
+          }))
+        };
+      },
+
+      getErrorShape(opts) {
+        const {
+          path,
+          error
+        } = opts;
+        const {
+          code
+        } = opts.error;
+        const shape = {
+          message: error.message,
+          code: envelopes.TRPC_ERROR_CODES_BY_KEY[code],
+          data: {
+            code,
+            httpStatus: resolveHTTPResponse.getHTTPStatusCodeFromError(error)
+          }
+        };
+
+        if (process.env.NODE_ENV !== 'production' && typeof opts.error.stack === 'string') {
+          shape.data.stack = opts.error.stack;
+        }
+
+        if (typeof path === 'string') {
+          shape.data.path = path;
+        }
+
+        return this._def.errorFormatter({ ...opts,
+          shape
+        });
+      }
+
+    };
+    return router;
+  };
+}
+
+function migrateProcedure(oldProc) {
+  const def = oldProc._def();
+
+  const inputParser = getParseFnOrPassThrough(def.inputParser);
+  const outputParser = getParseFnOrPassThrough(def.outputParser);
+  const inputMiddleware = createInputMiddleware(inputParser);
+  const builder = createInternalBuilder({
+    input: def.inputParser,
+    middlewares: [...def.middlewares, inputMiddleware, createOutputMiddleware(outputParser)],
+    meta: def.meta,
+    output: def.outputParser
+  });
+  const proc = builder.resolve(opts => def.resolver(opts));
+  return proc;
+}
+
+function migrateRouter(oldRouter) {
+  const errorFormatter = oldRouter._def.errorFormatter;
+  const transformer = oldRouter._def.transformer;
+  const queries = {};
+  const mutations = {};
+  const subscriptions = {};
+
+  for (const [name, procedure] of Object.entries(oldRouter._def.queries)) {
+    queries[name] = migrateProcedure(procedure);
+  }
+
+  for (const [name, procedure] of Object.entries(oldRouter._def.mutations)) {
+    mutations[name] = migrateProcedure(procedure);
+  }
+
+  for (const [name, procedure] of Object.entries(oldRouter._def.subscriptions)) {
+    subscriptions[name] = migrateProcedure(procedure);
+  }
+
+  const newRouter = createRouterFactory({
+    transformer,
+    errorFormatter
+  })({
+    mutations,
+    queries,
+    subscriptions
+  });
+  return newRouter;
+}
+
+/* eslint-disable @typescript-eslint/ban-types */
+resolveHTTPResponse.assertNotBrowser();
+
 function getDataTransformer(transformer) {
   if ('input' in transformer) {
     return transformer;
@@ -218,6 +778,7 @@ function getDataTransformer(transformer) {
 }
 /**
  * @internal
+ * @deprecated
  */
 
 
@@ -228,31 +789,16 @@ const PROCEDURE_DEFINITION_MAP = {
 };
 /**
  * @internal
+ * @deprecated
  */
 
 function safeObject(...args) {
   return Object.assign(Object.create(null), ...args);
 }
 
-const defaultFormatter = ({
-  shape
-}) => {
-  return shape;
-};
-
-const defaultTransformer = {
-  input: {
-    serialize: obj => obj,
-    deserialize: obj => obj
-  },
-  output: {
-    serialize: obj => obj,
-    deserialize: obj => obj
-  }
-};
-
 /**
  * @internal The type signature of this class may change without warning.
+ * @deprecated
  */
 class Router {
   constructor(def) {
@@ -493,14 +1039,149 @@ class Router {
   flat() {
     return this;
   }
+  /**
+   * Interop mode for v9.x -> v10.x
+   */
+
+
+  interop() {
+    return migrateRouter(this);
+  }
 
 }
+/**
+ * @deprecated
+ */
+
 function router() {
   return new Router();
 }
 
+function mergeRouters(...routerList) {
+  const queries = mergeWithoutOverrides({}, ...routerList.map(r => r.queries));
+  const mutations = mergeWithoutOverrides({}, ...routerList.map(r => r.mutations));
+  const subscriptions = mergeWithoutOverrides({}, ...routerList.map(r => r.subscriptions));
+  const errorFormatter = routerList.reduce((currentErrorFormatter, nextRouter) => {
+    if (nextRouter.errorFormatter && nextRouter.errorFormatter !== defaultFormatter) {
+      if (currentErrorFormatter !== defaultFormatter && currentErrorFormatter !== nextRouter.errorFormatter) {
+        throw new Error('You seem to have several error formatters');
+      }
+
+      return nextRouter.errorFormatter;
+    }
+
+    return currentErrorFormatter;
+  }, defaultFormatter);
+  const transformer = routerList.reduce((prev, current) => {
+    if (current.transformer && current.transformer !== defaultTransformer) {
+      if (prev !== defaultTransformer && prev !== current.transformer) {
+        throw new Error('You seem to have several transformers');
+      }
+
+      return current.transformer;
+    }
+
+    return prev;
+  }, defaultTransformer);
+  const router = createRouterFactory({
+    errorFormatter,
+    transformer
+  })({
+    queries,
+    mutations,
+    subscriptions
+  });
+  return router;
+}
+
+/**
+ * @deprecated Only keeping this for future reference if our testing was a false-positive
+ */
+
+function mergeRoutersGeneric(...args) {
+  return mergeRouters(...args);
+}
+
+// TODO make this into a callbag?
+function createBuilder() {
+  return createInternalBuilder();
+}
+
+/**
+ * @internal
+ */
+
+/**
+ * @internal
+ */
+
+/**
+ * @internal
+ */
+
+/**
+ * @internal
+ */
+
+/**
+ * @internal
+ */
+
+/**
+ * @internal
+ */
+// FIXME this should use RootConfig
+function createMiddlewareFactory() {
+  return function createMiddleware(fn) {
+    return fn;
+  };
+}
+
+/* eslint-disable @typescript-eslint/ban-types */
+function initTRPC() {
+  return function initTRPCInner(options) {
+    var _options$errorFormatt, _options$transformer;
+
+    const errorFormatter = (_options$errorFormatt = options === null || options === void 0 ? void 0 : options.errorFormatter) !== null && _options$errorFormatt !== void 0 ? _options$errorFormatt : defaultFormatter;
+    const transformer = getDataTransformer$1((_options$transformer = options === null || options === void 0 ? void 0 : options.transformer) !== null && _options$transformer !== void 0 ? _options$transformer : defaultTransformer);
+    return {
+      /**
+       * These are just types, they can't be used
+       * @internal
+       */
+      _config: null,
+
+      /**
+       * Builder object for creating procedures
+       */
+      procedure: createBuilder(),
+
+      /**
+       * Create reusable middlewares
+       */
+      middleware: createMiddlewareFactory(),
+
+      /**
+       * Create a router
+       * FIXME this should also use error formatter
+       */
+      router: createRouterFactory({
+        errorFormatter,
+        transformer
+      }),
+
+      /**
+       * Merge Routers
+       */
+      mergeRouters: mergeRoutersGeneric
+    };
+  };
+}
+
 exports.assertNotBrowser = resolveHTTPResponse.assertNotBrowser;
 exports.resolveHTTPResponse = resolveHTTPResponse.resolveHTTPResponse;
 exports.TRPCError = TRPCError.TRPCError;
-exports.Router = Router;
+exports.defaultTransformer = defaultTransformer;
+exports.getDataTransformer = getDataTransformer$1;
+exports.initTRPC = initTRPC;
 exports.router = router;