@trpc/server 10.0.0-alpha.4 → 10.0.0-alpha.42

package/src/core/procedure.ts

@@ -0,0 +1,120 @@
+import { DefaultErrorShape } from '../error/formatter';
+import { CombinedDataTransformer } from '../transformer';
+import { RootConfig } from './internals/config';
+import {
+  ProcedureBuilderDef,
+  ProcedureCallOptions,
+} from './internals/procedureBuilder';
+import { UnsetMarker } from './internals/utils';
+
+type ClientContext = Record<string, unknown>;
+
+/**
+ * @internal
+ */
+export interface ProcedureOptions {
+  /**
+   * Client-side context
+   */
+  context?: ClientContext;
+}
+
+/**
+ * FIXME: this should only take 1 generic argument instead of a list
+ * @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
+   */
+  _input_in: TInputIn;
+  /**
+   * @internal
+   */
+  _input_out: TInputOut;
+  /**
+   * @internal
+   */
+  _output_in: TOutputIn;
+  /**
+   * @internal
+   */
+  _output_out: TOutputOut;
+}
+
+/**
+ * @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 & ProcedureBuilderDef;
+  /**
+   * @deprecated use `._def.meta` instead
+   */
+  meta?: TParams['_meta'];
+  _procedure: true;
+  /**
+   * @internal
+   */
+  (opts: ProcedureCallOptions): Promise<unknown>;
+}
+
+export interface QueryProcedure<TParams extends ProcedureParams>
+  extends ProcedureBase<TParams> {
+  _query: true;
+}
+
+export interface MutationProcedure<TParams extends ProcedureParams>
+  extends ProcedureBase<TParams> {
+  _mutation: true;
+}
+
+export interface SubscriptionProcedure<TParams extends ProcedureParams>
+  extends ProcedureBase<TParams> {
+  _subscription: true;
+}
+
+export type Procedure<TParams extends ProcedureParams> =
+  | QueryProcedure<TParams>
+  | MutationProcedure<TParams>
+  | SubscriptionProcedure<TParams>;
+
+export type AnyProcedure = Procedure<any>;

package/src/core/router.ts

@@ -0,0 +1,366 @@
+/* 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 { createProxy } from '../shared';
+import { CombinedDataTransformer, defaultTransformer } from '../transformer';
+import { RootConfig } from './internals/config';
+import { mergeWithoutOverrides } from './internals/mergeWithoutOverrides';
+import { omitPrototype } from './internals/omitPrototype';
+import { ProcedureCallOptions } from './internals/procedureBuilder';
+import {
+  AnyProcedure,
+  MutationProcedure,
+  Procedure,
+  ProcedureArgs,
+  QueryProcedure,
+  SubscriptionProcedure,
+} from './procedure';
+import { ProcedureType, procedureTypes } 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>>;
+
+type DecorateProcedure<TProcedure extends Procedure<any>> = (
+  input: ProcedureArgs<TProcedure['_def']>[0],
+) => Promise<TProcedure['_def']['_output_out']>;
+
+type assertProcedure<T> = T extends Procedure<any> ? T : never;
+
+/**
+ * @internal
+ */
+type DecoratedProcedureRecord<TProcedures extends ProcedureRouterRecord> = {
+  [TKey in keyof TProcedures]: TProcedures[TKey] extends AnyRouter
+    ? DecoratedProcedureRecord<TProcedures[TKey]['_def']['record']>
+    : DecorateProcedure<assertProcedure<TProcedures[TKey]>>;
+};
+
+/**
+ * @internal
+ */
+type RouterCaller<TDef extends AnyRouterDef> = (ctx: TDef['_ctx']) => {
+  /**
+   * @deprecated
+   */
+  query: inferHandlerFn<TDef['queries']>;
+  /**
+   * @deprecated
+   */
+  mutation: inferHandlerFn<TDef['mutations']>;
+  /**
+   * @deprecated
+   */
+  subscription: inferHandlerFn<TDef['subscriptions']>;
+} & DecoratedProcedureRecord<TDef['record']>;
+
+export interface Router<TDef extends AnyRouterDef> {
+  _def: RouterDef<
+    TDef['_ctx'],
+    TDef['_errorShape'],
+    TDef['_meta'],
+    TDef['record']
+  >;
+  /** @deprecated **/
+  errorFormatter: TDef['errorFormatter'];
+  /** @deprecated **/
+  transformer: TDef['transformer'];
+  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 isRouter(
+  procedureOrRouter: AnyProcedure | AnyRouter,
+): procedureOrRouter is AnyRouter {
+  return 'router' in procedureOrRouter._def;
+}
+
+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 (isRouter(procedureOrRouter)) {
+          recursiveGetPaths(procedureOrRouter._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 }), {}),
+    };
+
+    const router: AnyRouter = {
+      ...opts,
+      _def,
+      transformer: _def.transformer,
+      errorFormatter: _def.errorFormatter,
+      createCaller(ctx) {
+        const proxy = createProxy(({ path, args }) => {
+          // interop mode
+          if (
+            path.length === 1 &&
+            procedureTypes.includes(path[0] as ProcedureType)
+          ) {
+            return callProcedure({
+              procedures: _def.procedures,
+              path: args[0] as string,
+              rawInput: args[1],
+              ctx,
+              type: path[0] as ProcedureType,
+            });
+          }
+
+          const fullPath = path.join('.');
+          const procedure = _def.procedures[fullPath] as AnyProcedure;
+
+          let type: ProcedureType = 'query';
+          if (procedure._def.mutation) {
+            type = 'mutation';
+          } else if (procedure._def.subscription) {
+            type = 'subscription';
+          }
+
+          return procedure({
+            path: fullPath,
+            rawInput: args[0],
+            ctx,
+            type,
+          });
+        });
+
+        return proxy as ReturnType<RouterCaller<any>>;
+      },
+      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;
+  };
+}
+
+/**
+ * @internal
+ */
+export function callProcedure(
+  opts: ProcedureCallOptions & { procedures: ProcedureRouterRecord },
+) {
+  const { type, path } = opts;
+
+  if (!(path in opts.procedures) || !opts.procedures[path]?._def[type]) {
+    throw new TRPCError({
+      code: 'NOT_FOUND',
+      message: `No "${type}"-procedure on path "${path}"`,
+    });
+  }
+
+  const procedure = opts.procedures[path] as AnyProcedure;
+
+  return procedure(opts);
+}

package/src/core/types.ts

@@ -0,0 +1,58 @@
+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'];
+
+export const procedureTypes = ['query', 'mutation', 'subscription'] as const;
+/**
+ * @public
+ */
+export type ProcedureType = typeof procedureTypes[number];
+
+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]>
+>;
+
+export type inferProcedureClientError<T extends Procedure<any>> =
+  inferProcedureParams<T>['_config']['errorShape'];

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 */

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

@@ -1,7 +1,13 @@
+import { TRPCError } from '../../error/TRPCError';
 import { ProcedureType } from '../router';
-import { TRPCError } from '../TRPCError';
 
-export const middlewareMarker = Symbol('middlewareMarker');
+/**
+ * @deprecated
+ */
+export const middlewareMarker = 'middlewareMarker' as 'middlewareMarker' & {
+  __brand: 'middlewareMarker';
+};
+
 interface MiddlewareResultBase<TContext> {
   /**
    * All middlewares should pass through their `next()`'s output.
@@ -11,11 +17,18 @@ interface MiddlewareResultBase<TContext> {
   ctx: TContext;
 }
 
+/**
+ * @deprecated
+ */
 interface MiddlewareOKResult<TContext> extends MiddlewareResultBase<TContext> {
   ok: true;
   data: unknown;
   // this could be extended with `input`/`rawInput` later
 }
+
+/**
+ * @deprecated
+ */
 interface MiddlewareErrorResult<TContext>
   extends MiddlewareResultBase<TContext> {
   ok: false;
@@ -23,15 +36,22 @@ interface MiddlewareErrorResult<TContext>
   // we could guarantee it's always of this type
 }
 
+/**
+ * @deprecated
+ */
 export type MiddlewareResult<TContext> =
   | MiddlewareOKResult<TContext>
   | MiddlewareErrorResult<TContext>;
 
-export type MiddlewareFunction<TInputContext, TContext> = (opts: {
+/**
+ * @deprecated
+ */
+export type MiddlewareFunction<TInputContext, TContext, TMeta> = (opts: {
   ctx: TInputContext;
   type: ProcedureType;
   path: string;
   rawInput: unknown;
+  meta?: TMeta;
   next: {
     (): Promise<MiddlewareResult<TInputContext>>;
     <T>(opts: { ctx: T }): Promise<MiddlewareResult<T>>;