@trpc/server 10.0.0-alpha.23 → 10.0.0-alpha.26

package/src/core/internals/config.ts

@@ -0,0 +1,44 @@
+import { DefaultErrorShape, ErrorFormatter } from '../../error/formatter';
+import {
+  CombinedDataTransformer,
+  DataTransformerOptions,
+} from '../../transformer';
+
+/**
+ * The initial generics that are used in the init function
+ * @internal
+ */
+export interface InitGenerics {
+  ctx: Record<string, unknown>;
+  meta: Record<string, unknown>;
+}
+/**
+ * The initial params that are used and actually represents real values underneath
+ * @internal
+ */
+export interface InitOptions<T extends InitGenerics> {
+  transformer: DataTransformerOptions;
+  errorFormatter: ErrorFormatter<T['ctx'], any>;
+}
+
+/**
+ * @internal
+ */
+export type CreateInitGenerics<T extends InitGenerics> = T;
+
+/**
+ * The config that is resolved after both calls of `initTRPC()` has been called
+ * Combination of `InitTOptions` + `InitGenerics`
+ * @internal
+ */
+export interface RootConfig {
+  ctx: Record<string, unknown>;
+  meta: Record<string, unknown>;
+  transformer: CombinedDataTransformer;
+  errorShape: DefaultErrorShape;
+}
+
+/**
+ * @internal
+ */
+export type CreateRootConfig<T extends RootConfig> = T;

package/src/core/internals/getParseFn.ts

@@ -0,0 +1,47 @@
+import { Parser } from '../parser';
+
+export type ParseFn<T> = (value: unknown) => T | Promise<T>;
+
+export function getParseFn<T>(procedureParser: Parser): ParseFn<T> {
+  const parser = procedureParser as any;
+
+  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
+ */
+export function getParseFnOrPassThrough<T>(
+  procedureParser: Parser | undefined,
+): ParseFn<T> {
+  if (!procedureParser) {
+    return (v) => v as T;
+  }
+  return getParseFn(procedureParser);
+}

package/src/core/internals/internalProcedure.ts

@@ -0,0 +1,265 @@
+/**
+ * This is the actual internal representation of a builder
+ * FIXME - I want to get rid of this and use the public API instead
+ */
+import { TRPCError } from '../../TRPCError';
+import { getCauseFromUnknown } from '../../error/utils';
+import { getErrorFromUnknown } from '../../internals/errors';
+import { MaybePromise } from '../../types';
+import { MiddlewareFunction, MiddlewareResult } from '../middleware';
+import { Parser } from '../parser';
+import { ProcedureType } from '../types';
+import { ParseFn, getParseFn } from './getParseFn';
+import { mergeWithoutOverrides } from './mergeWithoutOverrides';
+import { ResolveOptions, middlewareMarker } from './utils';
+
+export interface InternalProcedureCallOptions {
+  ctx: unknown;
+  rawInput: unknown;
+  input?: unknown;
+  path: string;
+  type: ProcedureType;
+}
+export interface InternalProcedure {
+  _def: ProcedureBuilderInternal['_def'];
+  /**
+   * @deprecated use `._def.meta` instead
+   */
+  meta: ProcedureBuilderInternal['_def']['meta'];
+  (opts: InternalProcedureCallOptions): Promise<unknown>;
+}
+
+type ProcedureBuilderInternalResolver = (
+  opts: ResolveOptions<any>,
+) => Promise<unknown>;
+
+export type ProcedureBuilderInternalMiddleware = MiddlewareFunction<any, any>;
+interface ProcedureBuilderInternal {
+  _def: {
+    input?: Parser;
+    output?: Parser;
+    meta?: Record<string, unknown>;
+    resolver?: ProcedureBuilderInternalResolver;
+    middlewares: ProcedureBuilderInternalMiddleware[];
+  };
+  // FIXME
+  // _call: (opts: ResolveOptions<any>) => Promise<unknown>;
+  /**
+   * @internal
+   */
+  input: (parser: Parser) => ProcedureBuilderInternal;
+  /**
+   * @internal
+   */
+  output: (parser: Parser) => ProcedureBuilderInternal;
+  /**
+   * @internal
+   */
+  concat: (proc: ProcedureBuilderInternal) => ProcedureBuilderInternal;
+  /**
+   * @internal
+   */
+  use: (fn: MiddlewareFunction<any, any>) => ProcedureBuilderInternal;
+  /**
+   * @internal
+   */
+  meta: (meta: Record<string, unknown>) => ProcedureBuilderInternal;
+  /**
+   * @internal
+   */
+  resolve: (
+    resolver: (opts: ResolveOptions<any>) => MaybePromise<any>,
+  ) => InternalProcedure;
+}
+function createNewInternalBuilder(
+  def1: ProcedureBuilderInternal['_def'],
+  def2: Partial<ProcedureBuilderInternal['_def']>,
+): ProcedureBuilderInternal {
+  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 = `
+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: InternalProcedure['_def'],
+): InternalProcedure {
+  const procedure = async function resolve(opts: InternalProcedureCallOptions) {
+    if (!opts || !('rawInput' in opts)) {
+      throw new Error(codeblock);
+    }
+
+    // run the middlewares recursively with the resolver as the last one
+    const callRecursive = async (
+      callOpts: { ctx: any; index: number; input?: unknown } = {
+        index: 0,
+        ctx: opts.ctx,
+      },
+    ): Promise<MiddlewareResult<any>> => {
+      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?: { ctx: any; input?: any }) => {
+            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: 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({
+        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;
+}
+
+export function createInputMiddleware<T>(
+  parse: ParseFn<T>,
+): ProcedureBuilderInternalMiddleware {
+  return async function inputMiddleware({ next, rawInput }) {
+    let input: ReturnType<typeof parse>;
+    try {
+      input = await parse(rawInput);
+    } catch (cause) {
+      throw new TRPCError({
+        code: 'BAD_REQUEST',
+        cause: getCauseFromUnknown(cause),
+      });
+    }
+    // TODO fix this typing?
+    return next({ input } as any);
+  };
+}
+
+export function createOutputMiddleware<T>(
+  parse: ParseFn<T>,
+): ProcedureBuilderInternalMiddleware {
+  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({
+        message: 'Output validation failed',
+        code: 'INTERNAL_SERVER_ERROR',
+        cause: getCauseFromUnknown(cause),
+      });
+    }
+  };
+}
+
+export function createInternalBuilder(
+  initDef?: ProcedureBuilderInternal['_def'],
+): ProcedureBuilderInternal {
+  const _def: ProcedureBuilderInternal['_def'] = initDef || {
+    middlewares: [],
+  };
+
+  return {
+    _def,
+    // _call: createProcedureCaller(_def),
+    input(input: Parser) {
+      const parser = getParseFn(input);
+      return createNewInternalBuilder(_def, {
+        input,
+        middlewares: [createInputMiddleware(parser)],
+      });
+    },
+    output(output: Parser) {
+      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,
+            } as const;
+          },
+        ],
+      });
+
+      return createProcedureCaller(finalBuilder._def);
+    },
+    concat(builder) {
+      return createNewInternalBuilder(_def, builder._def);
+    },
+    use(middleware) {
+      return createNewInternalBuilder(_def, {
+        middlewares: [middleware],
+      });
+    },
+  };
+}

package/src/core/internals/mergeRouters.ts

@@ -0,0 +1,57 @@
+import { defaultFormatter } from '../../error/formatter';
+import { CombinedDataTransformer, defaultTransformer } from '../../transformer';
+import { AnyRouter, createRouterFactory } from '../router';
+import { mergeWithoutOverrides } from './mergeWithoutOverrides';
+
+export function mergeRouters(...routerList: AnyRouter[]): AnyRouter {
+  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 as CombinedDataTransformer);
+
+  const router = createRouterFactory({
+    errorFormatter,
+    transformer,
+  })({
+    queries,
+    mutations,
+    subscriptions,
+  });
+  return router;
+}

package/src/core/internals/mergeWithoutOverrides.ts

@@ -0,0 +1,19 @@
+/**
+ * Ensures there are no duplicate keys when building a procedure.
+ */
+export function mergeWithoutOverrides<T extends Record<string, unknown>>(
+  obj1: T,
+  ...objs: Partial<T>[]
+): T {
+  const newObj: T = 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 as keyof T] = overrides[key] as T[keyof T];
+    }
+  }
+  return newObj;
+}

package/src/core/internals/omitPrototype.ts

@@ -0,0 +1,9 @@
+/**
+ * Create an object without inheriting anything from `Object.prototype`
+ * @internal
+ */
+export function omitPrototype<TObj1 extends Record<string, unknown>>(
+  obj1: TObj1,
+): TObj1 {
+  return Object.assign(Object.create(null), obj1);
+}

package/src/core/internals/procedureBuilder.ts

@@ -0,0 +1,100 @@
+import { MaybePromise } from '../../types';
+import { MiddlewareFunction } from '../middleware';
+import { Parser, inferParser } from '../parser';
+import { Procedure, ProcedureParams } from '../procedure';
+import { createInternalBuilder } from './internalProcedure';
+import { ResolveOptions } from './utils';
+import { DefaultValue as FallbackValue, Overwrite, UnsetMarker } from './utils';
+
+type CreateProcedureReturnInput<
+  TPrev extends ProcedureParams,
+  TNext extends ProcedureParams,
+> = ProcedureBuilder<{
+  _meta: TPrev['_meta'];
+  _ctx_in: TPrev['_ctx_in'];
+  _ctx_out: Overwrite<TPrev['_ctx_out'], TNext['_ctx_out']>;
+  _input_out: FallbackValue<TNext['_input_out'], TPrev['_input_out']>;
+  _input_in: FallbackValue<TNext['_input_in'], TPrev['_input_in']>;
+  _output_in: FallbackValue<TNext['_output_in'], TPrev['_output_in']>;
+  _output_out: FallbackValue<TNext['_output_out'], TPrev['_output_out']>;
+}>;
+
+export interface ProcedureBuilder<TParams extends ProcedureParams> {
+  /**
+   * Add an input parser to the procedure.
+   */
+  input<$TParser extends Parser>(
+    schema: $TParser,
+  ): ProcedureBuilder<{
+    _meta: TParams['_meta'];
+    _ctx_in: TParams['_ctx_in'];
+    _ctx_out: TParams['_ctx_out'];
+    _output_in: TParams['_output_in'];
+    _output_out: TParams['_output_out'];
+    _input_in: inferParser<$TParser>['in'];
+    _input_out: inferParser<$TParser>['out'];
+  }>;
+  /**
+   * Add an output parser to the procedure.
+   */
+  output<$TParser extends Parser>(
+    schema: $TParser,
+  ): ProcedureBuilder<{
+    _meta: TParams['_meta'];
+    _ctx_in: TParams['_ctx_in'];
+    _ctx_out: TParams['_ctx_out'];
+    _input_in: TParams['_input_in'];
+    _input_out: TParams['_input_out'];
+    _output_in: inferParser<$TParser>['in'];
+    _output_out: inferParser<$TParser>['out'];
+  }>;
+  /**
+   * Add a meta data to the procedure.
+   */
+  meta(meta: TParams['_meta']): ProcedureBuilder<TParams>;
+  /**
+   * Add a middleware to the procedure.
+   */
+  use<$TParams extends ProcedureParams>(
+    fn: MiddlewareFunction<TParams, $TParams>,
+  ): CreateProcedureReturnInput<TParams, $TParams>;
+  /**
+   * Extend the procedure with another procedure
+   */
+  concat<$ProcedureReturnInput extends ProcedureBuilder<any>>(
+    proc: $ProcedureReturnInput,
+  ): $ProcedureReturnInput extends ProcedureBuilder<infer $TParams>
+    ? CreateProcedureReturnInput<TParams, $TParams>
+    : never;
+  /**
+   * Resolve the procedure
+   */
+  resolve<$TOutput>(
+    resolver: (
+      opts: ResolveOptions<TParams>,
+    ) => MaybePromise<FallbackValue<TParams['_output_in'], $TOutput>>,
+  ): UnsetMarker extends TParams['_output_out']
+    ? Procedure<
+        Overwrite<
+          TParams,
+          {
+            _output_in: $TOutput;
+            _output_out: $TOutput;
+          }
+        >
+      >
+    : Procedure<TParams>;
+}
+
+// TODO make this into a callbag?
+export function createBuilder<TContext, TMeta>(): ProcedureBuilder<{
+  _ctx_in: TContext;
+  _ctx_out: TContext;
+  _input_out: UnsetMarker;
+  _input_in: UnsetMarker;
+  _output_in: UnsetMarker;
+  _output_out: UnsetMarker;
+  _meta: TMeta;
+}> {
+  return createInternalBuilder() as any;
+}

package/src/core/internals/utils.ts

@@ -0,0 +1,64 @@
+import { ProcedureParams } from '../procedure';
+
+/**
+ * @internal
+ */
+export type Overwrite<T, U> = Omit<T, keyof U> & U;
+/**
+ * @internal
+ */
+export type DefaultValue<TValue, TFallback> = UnsetMarker extends TValue
+  ? TFallback
+  : TValue;
+
+/**
+ * @internal
+ */
+export const middlewareMarker = 'middlewareMarker' as 'middlewareMarker' & {
+  __brand: 'middlewareMarker';
+};
+
+/**
+ * @internal
+ */
+export type MiddlewareMarker = typeof middlewareMarker;
+
+/**
+ * @internal
+ */
+export const unsetMarker = Symbol('unsetMarker');
+/**
+ * @internal
+ */
+export type UnsetMarker = typeof unsetMarker;
+
+/**
+ * @internal
+ */
+export interface ResolveOptions<TParams extends ProcedureParams> {
+  ctx: TParams['_ctx_out'];
+  input: TParams['_input_out'];
+}
+
+/**
+ * @internal
+ */
+export type ValidateShape<TActualShape, TExpectedShape> =
+  TActualShape extends TExpectedShape
+    ? Exclude<keyof TActualShape, keyof TExpectedShape> extends never
+      ? TActualShape
+      : TExpectedShape
+    : never;
+
+/**
+ * @internal
+ */
+export type PickFirstDefined<T, K> = undefined extends T
+  ? undefined extends K
+    ? never
+    : K
+  : T;
+
+export type EnsureRecord<T> = T extends Record<string, any>
+  ? T
+  : Record<string, never>;

package/src/core/middleware.ts

@@ -0,0 +1,93 @@
+import { MiddlewareMarker } from './internals/utils';
+import { ProcedureParams } from './procedure';
+import { ProcedureType } from './types';
+
+/**
+ * @internal
+ */
+interface MiddlewareResultBase {
+  /**
+   * All middlewares should pass through their `next()`'s output.
+   * Requiring this marker makes sure that can't be forgotten at compile-time.
+   */
+  readonly marker: MiddlewareMarker;
+}
+
+/**
+ * @internal
+ */
+interface MiddlewareOKResult<_TParams extends ProcedureParams>
+  extends MiddlewareResultBase {
+  ok: true;
+  data: unknown;
+  // this could be extended with `input`/`rawInput` later
+}
+
+/**
+ * @internal
+ */
+interface MiddlewareErrorResult<_TParams extends ProcedureParams>
+  extends MiddlewareResultBase {
+  ok: false;
+  error: Error;
+  // we could guarantee it's always of this type
+}
+
+/**
+ * @internal
+ */
+export type MiddlewareResult<TParams extends ProcedureParams> =
+  | MiddlewareOKResult<TParams>
+  | MiddlewareErrorResult<TParams>;
+
+/**
+ * @internal
+ */
+export type MiddlewareFunction<
+  TParams extends ProcedureParams,
+  TParamsAfter extends ProcedureParams,
+> = (opts: {
+  ctx: TParams['_ctx_out'];
+  type: ProcedureType;
+  path: string;
+  input: TParams['_input_out'];
+  rawInput: unknown;
+  meta: TParams['_meta'];
+  next: {
+    (): Promise<MiddlewareResult<TParams>>;
+    <$TContext>(opts: { ctx: $TContext }): Promise<
+      MiddlewareResult<{
+        _ctx_in: TParams['_ctx_in'];
+        _ctx_out: $TContext;
+        _input_in: TParams['_input_in'];
+        _input_out: TParams['_input_out'];
+        _output_in: TParams['_output_in'];
+        _output_out: TParams['_output_out'];
+        _meta: TParams['_meta'];
+      }>
+    >;
+  };
+}) => Promise<MiddlewareResult<TParamsAfter>>;
+
+/**
+ * @internal
+ */
+// FIXME this should use RootConfig
+export function createMiddlewareFactory<TContext, TMeta>() {
+  return function createMiddleware<$TNewParams extends ProcedureParams>(
+    fn: MiddlewareFunction<
+      {
+        _ctx_in: TContext;
+        _ctx_out: TContext;
+        _input_out: unknown;
+        _input_in: unknown;
+        _output_in: unknown;
+        _output_out: unknown;
+        _meta: TMeta;
+      },
+      $TNewParams
+    >,
+  ) {
+    return fn;
+  };
+}