@trpc/server 10.0.0-alpha.3 → 10.0.0-alpha.32

package/src/core/middleware.ts

@@ -0,0 +1,96 @@
+import { RootConfig } from './internals/config';
+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<{
+        _config: any;
+        _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<TConfig extends RootConfig>() {
+  return function createMiddleware<$TNewParams extends ProcedureParams>(
+    fn: MiddlewareFunction<
+      {
+        _config: TConfig;
+        _ctx_in: TConfig['ctx'];
+        _ctx_out: TConfig['ctx'];
+        _input_out: unknown;
+        _input_in: unknown;
+        _output_in: unknown;
+        _output_out: unknown;
+        _meta: TConfig['meta'];
+      },
+      $TNewParams
+    >,
+  ) {
+    return fn;
+  };
+}

package/src/core/parser.ts

@@ -0,0 +1,45 @@
+export type ParserZodEsque<TInput, TParsedInput> = {
+  _input: TInput;
+  _output: TParsedInput;
+};
+
+export type ParserMyZodEsque<TInput> = {
+  parse: (input: any) => TInput;
+};
+
+export type ParserSuperstructEsque<TInput> = {
+  create: (input: unknown) => TInput;
+};
+
+export type ParserCustomValidatorEsque<TInput> = (
+  input: unknown,
+) => TInput | Promise<TInput>;
+
+export type ParserYupEsque<TInput> = {
+  validateSync: (input: unknown) => TInput;
+};
+export type ParserWithoutInput<TInput> =
+  | ParserYupEsque<TInput>
+  | ParserSuperstructEsque<TInput>
+  | ParserCustomValidatorEsque<TInput>
+  | ParserMyZodEsque<TInput>;
+
+export type ParserWithInputOutput<TInput, TParsedInput> = ParserZodEsque<
+  TInput,
+  TParsedInput
+>;
+
+export type Parser = ParserWithoutInput<any> | ParserWithInputOutput<any, any>;
+
+export type inferParser<TParser extends Parser> =
+  TParser extends ParserWithInputOutput<infer $TIn, infer $TOut>
+    ? {
+        in: $TIn;
+        out: $TOut;
+      }
+    : TParser extends ParserWithoutInput<infer $InOut>
+    ? {
+        in: $InOut;
+        out: $InOut;
+      }
+    : never;

package/src/core/procedure.ts

@@ -0,0 +1,108 @@
+import { DefaultErrorShape } from '../error/formatter';
+import { CombinedDataTransformer } from '../transformer';
+import { RootConfig } from './internals/config';
+import { UnsetMarker } from './internals/utils';
+
+type ClientContext = Record<string, unknown>;
+export interface ProcedureOptions {
+  /**
+   * Client-side context
+   */
+  context?: ClientContext;
+}
+
+/**
+ * @internal
+ */
+export interface ProcedureParams<
+  TConfig extends RootConfig = {
+    transformer: CombinedDataTransformer;
+    errorShape: DefaultErrorShape;
+    ctx: Record<string, unknown>;
+    meta: Record<string, unknown>;
+  },
+  TContextIn = unknown,
+  TContextOut = unknown,
+  TInputIn = unknown,
+  TInputOut = unknown,
+  TOutputIn = unknown,
+  TOutputOut = unknown,
+  TMeta = unknown,
+> {
+  // FIXME make non-optional
+  _config: TConfig;
+  /**
+   * @internal
+   */
+  _meta: TMeta;
+  /**
+   * @internal
+   */
+  _ctx_in: TContextIn;
+  /**
+   * @internal
+   */
+  _ctx_out: TContextOut;
+  /**
+   * @internal
+   */
+  _output_in: TOutputIn;
+  /**
+   * @internal
+   */
+  _output_out: TOutputOut;
+  /**
+   * @internal
+   */
+  _input_in: TInputIn;
+  /**
+   * @internal
+   */
+  _input_out: TInputOut;
+}
+
+/**
+ * @internal
+ */
+export type ProcedureArgs<TParams extends ProcedureParams> =
+  TParams['_input_in'] extends UnsetMarker
+    ? [input?: undefined | void, opts?: ProcedureOptions]
+    : undefined extends TParams['_input_in']
+    ? [input?: TParams['_input_in'] | void, opts?: ProcedureOptions]
+    : [input: TParams['_input_in'], opts?: ProcedureOptions];
+
+/**
+ * @internal
+ */
+export interface ProcedureBase<TParams extends ProcedureParams> {
+  _def: TParams;
+  /**
+   * @deprecated use `._def.meta` instead
+   */
+  meta?: TParams['_meta'];
+  _procedure: true;
+}
+
+export interface QueryProcedure<TParams extends ProcedureParams>
+  extends ProcedureBase<TParams> {
+  _query: true;
+  query(...args: ProcedureArgs<TParams>): Promise<TParams['_output_out']>;
+}
+
+export interface MutationProcedure<TParams extends ProcedureParams>
+  extends ProcedureBase<TParams> {
+  _mutation: true;
+  mutate(...args: ProcedureArgs<TParams>): Promise<TParams['_output_out']>;
+}
+
+export interface SubscriptionProcedure<TParams extends ProcedureParams>
+  extends ProcedureBase<TParams> {
+  _subscription: true;
+  subscription(
+    ...args: ProcedureArgs<TParams>
+  ): Promise<TParams['_output_out']>;
+}
+export type Procedure<TParams extends ProcedureParams> =
+  | QueryProcedure<TParams>
+  | MutationProcedure<TParams>
+  | SubscriptionProcedure<TParams>;

package/src/core/router.ts

@@ -0,0 +1,365 @@
+/* eslint-disable @typescript-eslint/ban-types */
+import { inferProcedureOutput } from '.';
+import { Filter, Prefixer } from '..';
+import { TRPCError } from '../error/TRPCError';
+import {
+  DefaultErrorShape,
+  ErrorFormatter,
+  defaultFormatter,
+} from '../error/formatter';
+import { getHTTPStatusCodeFromError } from '../http/internals/getHTTPStatusCode';
+import { TRPCErrorShape, TRPC_ERROR_CODES_BY_KEY } from '../rpc';
+import { CombinedDataTransformer, defaultTransformer } from '../transformer';
+import { RootConfig } from './internals/config';
+import {
+  InternalProcedure,
+  InternalProcedureCallOptions,
+} from './internals/internalProcedure';
+import { mergeWithoutOverrides } from './internals/mergeWithoutOverrides';
+import { omitPrototype } from './internals/omitPrototype';
+import {
+  MutationProcedure,
+  Procedure,
+  QueryProcedure,
+  SubscriptionProcedure,
+} from './procedure';
+import { ProcedureType } from './types';
+
+type ProcedureRecord = Record<string, Procedure<any>>;
+
+export type ProcedureRouterRecord = Record<string, Procedure<any> | AnyRouter>;
+
+export interface ProcedureStructure {
+  queries: Record<string, QueryProcedure<any>>;
+  mutations: Record<string, MutationProcedure<any>>;
+  subscriptions: Record<string, SubscriptionProcedure<any>>;
+  procedures: ProcedureRecord;
+}
+
+type ObjKeyof<T> = T extends object ? keyof T : never;
+type KeyofKeyof<T> = ObjKeyof<T> | { [K in keyof T]: ObjKeyof<T[K]> }[keyof T];
+type StripNever<T> = Pick<
+  T,
+  { [K in keyof T]: [T[K]] extends [never] ? never : K }[keyof T]
+>;
+type Lookup<T, K> = T extends any ? (K extends keyof T ? T[K] : never) : never;
+type SimpleFlatten<T> = T extends object
+  ? StripNever<{
+      [K in KeyofKeyof<T>]:
+        | Exclude<K extends keyof T ? T[K] : never, object>
+        | { [P in keyof T]: Lookup<T[P], K> }[keyof T];
+    }>
+  : T;
+
+type PrefixedProcedures<T extends ProcedureRouterRecord> = {
+  [K in keyof T]: T[K] extends AnyRouter
+    ? T[K] extends Procedure<any>
+      ? never
+      : Prefixer<T[K]['_def']['procedures'], `${K & string}.`>
+    : never;
+};
+export interface RouterDef<
+  // FIXME this should use RootConfig
+  TContext,
+  TErrorShape extends TRPCErrorShape<number>,
+  TMeta extends Record<string, unknown>,
+  TRecord extends ProcedureRouterRecord,
+> {
+  router: true;
+  /**
+   * @internal
+   */
+  _ctx: TContext;
+  /**
+   * @internal
+   */
+  _errorShape: TErrorShape;
+  /**
+   * @internal
+   */
+  _meta: TMeta;
+  errorFormatter: ErrorFormatter<TContext, TErrorShape>;
+  transformer: CombinedDataTransformer;
+  // FIXME this is slow
+  procedures: Filter<TRecord, Procedure<any>> &
+    SimpleFlatten<PrefixedProcedures<TRecord>>;
+  routers: Filter<TRecord, Router<any>>;
+  record: TRecord;
+  // FIXME this is slow
+  subscriptions: Filter<TRecord, SubscriptionProcedure<any>> &
+    Filter<
+      SimpleFlatten<PrefixedProcedures<TRecord>>,
+      SubscriptionProcedure<any>
+    >;
+  queries: Filter<TRecord, QueryProcedure<any>> &
+    Filter<SimpleFlatten<PrefixedProcedures<TRecord>>, QueryProcedure<any>>;
+  mutations: Filter<TRecord, MutationProcedure<any>> &
+    Filter<SimpleFlatten<PrefixedProcedures<TRecord>>, MutationProcedure<any>>;
+}
+
+export type AnyRouterDef<TContext = any> = RouterDef<TContext, any, any, any>;
+
+/**
+ * @internal
+ */
+export type inferHandlerInput<TProcedure extends Procedure<any>> =
+  TProcedure extends Procedure<infer TDef>
+    ? undefined extends TDef['_input_in'] // ? is input optional
+      ? unknown extends TDef['_input_in'] // ? is input unset
+        ? [(null | undefined)?] // -> there is no input
+        : [(TDef['_input_in'] | null | undefined)?] // -> there is optional input
+      : [TDef['_input_in']] // -> input is required
+    : [(undefined | null)?]; // -> there is no input
+
+/**
+ * @internal
+ */
+type inferHandlerFn<TProcedures extends Record<string, Procedure<any>>> = <
+  TProcedure extends TProcedures[TPath],
+  TPath extends keyof TProcedures & string,
+>(
+  path: TPath,
+  ...args: inferHandlerInput<TProcedure>
+) => Promise<inferProcedureOutput<TProcedure>>;
+
+/**
+ * This only exists b/c of interop mode
+ * @internal
+ */
+
+type RouterCaller<TDef extends AnyRouterDef> = (ctx: TDef['_ctx']) => {
+  /**
+   * @deprecated
+   */
+  query: inferHandlerFn<TDef['queries']>;
+  /**
+   * @deprecated
+   */
+  mutation: inferHandlerFn<TDef['mutations']>;
+  /**
+   * @deprecated
+   */
+  subscription: inferHandlerFn<TDef['subscriptions']>;
+};
+
+export interface Router<TDef extends AnyRouterDef> {
+  _def: RouterDef<
+    TDef['_ctx'],
+    TDef['_errorShape'],
+    TDef['_meta'],
+    TDef['record']
+  >;
+  /** @deprecated **/
+  errorFormatter: TDef['errorFormatter'];
+  /** @deprecated **/
+  transformer: TDef['transformer'];
+
+  // FIXME rename me and deprecate
+  createCaller: RouterCaller<TDef>;
+  // FIXME rename me and deprecate
+  getErrorShape(opts: {
+    error: TRPCError;
+    type: ProcedureType | 'unknown';
+    path: string | undefined;
+    input: unknown;
+    ctx: undefined | TDef['_ctx'];
+  }): TDef['_errorShape'];
+}
+
+/**
+ * @internal
+ */
+export type RouterDefaultOptions<TContext> = Pick<
+  AnyRouterDef<TContext>,
+  'transformer' | 'errorFormatter'
+>;
+
+/**
+ * @internal
+ */
+export type RouterBuildOptions<TContext> = Partial<
+  Pick<AnyRouterDef<TContext>, 'procedures'>
+>;
+
+export type AnyRouter = Router<any>;
+
+function createRouterProxy(callback: (...args: [string, ...unknown[]]) => any) {
+  return new Proxy({} as any, {
+    get(_, path: string) {
+      return (...args: unknown[]) => callback(path, ...args);
+    },
+  });
+}
+const emptyRouter = {
+  _ctx: null as any,
+  _errorShape: null as any,
+  _meta: null as any,
+  queries: {},
+  mutations: {},
+  subscriptions: {},
+  errorFormatter: defaultFormatter,
+  transformer: defaultTransformer,
+};
+
+/**
+ *
+ * @internal
+ */
+export function createRouterFactory<TConfig extends RootConfig>(
+  defaults?: RouterDefaultOptions<TConfig['ctx']>,
+) {
+  return function createRouterInner<
+    TProcRouterRecord extends ProcedureRouterRecord,
+  >(
+    opts: TProcRouterRecord,
+  ): Router<
+    RouterDef<
+      TConfig['ctx'],
+      TConfig['errorShape'],
+      TConfig['meta'],
+      TProcRouterRecord
+    >
+  > &
+    TProcRouterRecord {
+    const routerProcedures: Record<string, Procedure<any>> = omitPrototype({});
+    function recursiveGetPaths(procedures: ProcedureRouterRecord, path = '') {
+      for (const [key, procedureOrRouter] of Object.entries(procedures ?? {})) {
+        const newPath = `${path}${key}`;
+
+        if (typeof procedureOrRouter === 'object') {
+          const router = procedureOrRouter as AnyRouter;
+          recursiveGetPaths(router._def.procedures, `${newPath}.`);
+          continue;
+        }
+
+        routerProcedures[newPath] = procedureOrRouter;
+      }
+    }
+
+    recursiveGetPaths(opts);
+
+    const result = mergeWithoutOverrides<
+      RouterDefaultOptions<TConfig['ctx']> & RouterBuildOptions<TConfig['ctx']>
+    >(
+      {
+        transformer: defaults?.transformer ?? defaultTransformer,
+        errorFormatter: defaults?.errorFormatter ?? defaultFormatter,
+      },
+      { procedures: routerProcedures },
+    );
+
+    const _def: AnyRouterDef<TConfig['ctx']> = {
+      router: true,
+      procedures: {},
+      ...emptyRouter,
+      ...result,
+      record: opts,
+      queries: Object.entries(result.procedures || {})
+        .filter((pair) => (pair[1] as any)._def.query)
+        .reduce((acc, [key, val]) => ({ ...acc, [key]: val }), {}),
+      mutations: Object.entries(result.procedures || {})
+        .filter((pair) => (pair[1] as any)._def.mutation)
+        .reduce((acc, [key, val]) => ({ ...acc, [key]: val }), {}),
+      subscriptions: Object.entries(result.procedures || {})
+        .filter((pair) => (pair[1] as any)._def.subscription)
+        .reduce((acc, [key, val]) => ({ ...acc, [key]: val }), {}),
+      routers: Object.entries(result.procedures || {})
+        .filter((pair) => (pair[1] as any)._def._router)
+        .reduce((acc, [key, val]) => ({ ...acc, [key]: val }), {}),
+    };
+
+    function callProcedure(opts: InternalProcedureCallOptions) {
+      const { type, path } = opts;
+
+      if (!(path in _def.procedures) || !_def.procedures[path]['_def'][type]) {
+        throw new TRPCError({
+          code: 'NOT_FOUND',
+          message: `No "${type}"-procedure on path "${path}"`,
+        });
+      }
+
+      const procedure = _def.procedures[path] as InternalProcedure;
+
+      return procedure(opts);
+    }
+    const router: AnyRouter = {
+      ...opts,
+      _def,
+      transformer: _def.transformer,
+      errorFormatter: _def.errorFormatter,
+      createCaller(ctx) {
+        return {
+          query: (path, ...args) =>
+            callProcedure({
+              path,
+              rawInput: args[0],
+              ctx,
+              type: 'query',
+            }) as any,
+          mutation: (path, ...args) =>
+            callProcedure({
+              path,
+              rawInput: args[0],
+              ctx,
+              type: 'mutation',
+            }) as any,
+          subscription: (path, ...args) =>
+            callProcedure({
+              path,
+              rawInput: args[0],
+              ctx,
+              type: 'subscription',
+            }) as any,
+
+          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: DefaultErrorShape = {
+          message: error.message,
+          code: TRPC_ERROR_CODES_BY_KEY[code],
+          data: {
+            code,
+            httpStatus: 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 as any;
+  };
+}

package/src/core/types.ts

@@ -0,0 +1,54 @@
+import { inferObservableValue } from '../observable';
+import { Procedure, ProcedureArgs } from './procedure';
+import { AnyRouter, AnyRouterDef, Router } from './router';
+
+export type inferRouterDef<TRouter extends AnyRouter> = TRouter extends Router<
+  infer TParams
+>
+  ? TParams extends AnyRouterDef<any>
+    ? TParams
+    : never
+  : never;
+
+export type inferRouterContext<TRouter extends AnyRouter> =
+  inferRouterDef<TRouter>['_ctx'];
+export type inferRouterError<TRouter extends AnyRouter> =
+  inferRouterDef<TRouter>['_errorShape'];
+export type inferRouterMeta<TRouter extends AnyRouter> =
+  inferRouterDef<TRouter>['_meta'];
+
+/**
+ * @public
+ */
+export type ProcedureType = 'query' | 'mutation' | 'subscription';
+
+export type inferHandlerInput<TProcedure extends Procedure<any>> =
+  ProcedureArgs<inferProcedureParams<TProcedure>>;
+
+export type inferProcedureInput<TProcedure extends Procedure<any>> =
+  inferHandlerInput<TProcedure>[0];
+
+// /**
+//  * @internal
+//  */
+// type inferProcedureFn<TProcedure extends Procedure<any>> =
+//   TProcedure extends QueryProcedure<any>
+//     ? TProcedure['query']
+//     : TProcedure extends SubscriptionProcedure<any>
+//     ? TProcedure['subscription']
+//     : TProcedure extends MutationProcedure<any>
+//     ? TProcedure['mutate']
+//     : never;
+
+export type inferProcedureParams<TProcedure> = TProcedure extends Procedure<any>
+  ? TProcedure['_def']
+  : never;
+export type inferProcedureOutput<TProcedure> =
+  inferProcedureParams<TProcedure>['_output_out'];
+
+export type inferSubscriptionOutput<
+  TRouter extends AnyRouter,
+  TPath extends keyof TRouter['_def']['subscriptions'] & string,
+> = inferObservableValue<
+  inferProcedureOutput<TRouter['_def']['subscriptions'][TPath]>
+>;

package/src/{internals → deprecated/internals}/callProcedure.ts

@@ -1,6 +1,9 @@
+import { Observable } from '../../observable';
 import { AnyRouter, ProcedureType } from '../router';
-import { Subscription } from '../subscription';
 
+/**
+ * @deprecated
+ */
 export async function callProcedure<
   TRouter extends AnyRouter<TContext>,
   TContext,
@@ -10,7 +13,7 @@ export async function callProcedure<
   router: TRouter;
   ctx: TContext;
   type: ProcedureType;
-}): Promise<unknown | Subscription<TRouter>> {
+}): Promise<unknown | Observable<TRouter, any>> {
   const { type, path, input } = opts;
 
   const caller = opts.router.createCaller(opts.ctx);
@@ -21,7 +24,10 @@ export async function callProcedure<
     return caller.mutation(path, input as any);
   }
   if (type === 'subscription') {
-    const sub = (await caller.subscription(path, input as any)) as Subscription;
+    const sub = (await caller.subscription(path, input as any)) as Observable<
+      any,
+      any
+    >;
     return sub;
   }
   /* istanbul ignore next */