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

package/src/core/procedure.ts

@@ -0,0 +1,72 @@
+import { UnsetMarker } from './internals/utils';
+
+type ClientContext = Record<string, unknown>;
+export interface ProcedureOptions {
+  /**
+   * Client-side context
+   */
+  context?: ClientContext;
+}
+
+/**
+ * @internal
+ */
+export interface ProcedureParams<
+  TContextIn = unknown,
+  TContextOut = unknown,
+  TInputIn = unknown,
+  TInputOut = unknown,
+  TOutputIn = unknown,
+  TOutputOut = unknown,
+  TMeta = unknown,
+> {
+  /**
+   * @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 Procedure<TParams extends ProcedureParams> {
+  (...args: ProcedureArgs<TParams>): Promise<TParams['_output_out']>;
+  /**
+   * @deprecated use `._def.meta` instead
+   */
+  meta?: TParams['_meta'];
+}

package/src/core/router.ts

@@ -0,0 +1,313 @@
+/* eslint-disable @typescript-eslint/ban-types */
+import { TRPCError } from '../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 { EnsureRecord, ValidateShape } from './internals/utils';
+import { Procedure } from './procedure';
+import { ProcedureType } from './types';
+
+// FIXME this should properly use TContext maybe?
+export type ProcedureRecord<_TContext> = Record<string, Procedure<any>>;
+type AnyProcedureRecord = ProcedureRecord<any>;
+export interface ProcedureStructure {
+  queries: AnyProcedureRecord;
+  mutations: AnyProcedureRecord;
+  subscriptions: AnyProcedureRecord;
+}
+
+export interface RouterParams<
+  // FIXME this should use RootConfig
+  TContext,
+  TErrorShape extends TRPCErrorShape<number>,
+  TMeta extends Record<string, unknown>,
+  TQueries extends ProcedureRecord<TContext>,
+  TMutations extends ProcedureRecord<TContext>,
+  TSubscriptions extends ProcedureRecord<TContext>,
+> extends ProcedureStructure {
+  /**
+   * @internal
+   */
+  _ctx: TContext;
+  /**
+   * @internal
+   */
+  _errorShape: TErrorShape;
+  /**
+   * @internal
+   */
+  _meta: TMeta;
+  queries: TQueries;
+  mutations: TMutations;
+  subscriptions: TSubscriptions;
+  errorFormatter: ErrorFormatter<TContext, TErrorShape>;
+  transformer: CombinedDataTransformer;
+}
+
+export type AnyRouterParams<TContext = any> = RouterParams<
+  TContext,
+  any,
+  any,
+  any,
+  any,
+  any
+>;
+
+/**
+ * @internal
+ */
+export type inferHandlerInput<TProcedure extends Procedure<any>> =
+  TProcedure extends Procedure<infer TParams>
+    ? undefined extends TParams['_input_in'] // ? is input optional
+      ? unknown extends TParams['_input_in'] // ? is input unset
+        ? [(null | undefined)?] // -> there is no input
+        : [(TParams['_input_in'] | null | undefined)?] // -> there is optional input
+      : [TParams['_input_in']] // -> input is required
+    : [(undefined | null)?]; // -> there is no input
+
+/**
+ * @internal
+ */
+type inferHandlerFn<TProcedures extends ProcedureRecord<any>> = <
+  TProcedure extends TProcedures[TPath],
+  TPath extends keyof TProcedures & string,
+>(
+  path: TPath,
+  ...args: inferHandlerInput<TProcedure>
+) => ReturnType<TProcedure>;
+
+/**
+ * This only exists b/c of interop mode
+ * @internal
+ */
+
+type RouterCaller<TParams extends AnyRouterParams> = (ctx: TParams['_ctx']) => {
+  query: inferHandlerFn<TParams['queries']>;
+  mutation: inferHandlerFn<TParams['mutations']>;
+  subscription: inferHandlerFn<TParams['subscriptions']>;
+};
+
+export interface Router<TParams extends AnyRouterParams>
+  extends ProcedureStructure {
+  _def: RouterParams<
+    TParams['_ctx'],
+    TParams['_errorShape'],
+    TParams['_meta'],
+    TParams['queries'],
+    TParams['mutations'],
+    TParams['subscriptions']
+  >;
+  queries: TParams['queries'];
+  mutations: TParams['mutations'];
+  subscriptions: TParams['subscriptions'];
+  errorFormatter: TParams['errorFormatter'];
+  transformer: TParams['transformer'];
+
+  createCaller: RouterCaller<TParams>;
+  getErrorShape(opts: {
+    error: TRPCError;
+    type: ProcedureType | 'unknown';
+    path: string | undefined;
+    input: unknown;
+    ctx: undefined | TParams['_ctx'];
+  }): TParams['_errorShape'];
+}
+
+/**
+ * @internal
+ */
+export type RouterOptions<TContext> = Partial<AnyRouterParams<TContext>>;
+
+/**
+ * @internal
+ */
+export type RouterDefaultOptions<TContext> = Pick<
+  AnyRouterParams<TContext>,
+  'transformer' | 'errorFormatter'
+>;
+
+/**
+ * @internal
+ */
+type RouterBuildOptions<TContext> = Pick<
+  RouterOptions<TContext>,
+  'queries' | 'subscriptions' | 'mutations'
+>;
+
+export type AnyRouter = Router<any>;
+
+const emptyRouter = {
+  _ctx: null as any,
+  _errorShape: null as any,
+  _meta: null as any,
+  queries: {},
+  mutations: {},
+  subscriptions: {},
+  errorFormatter: defaultFormatter,
+  transformer: defaultTransformer,
+};
+// type EmptyRouter = typeof emptyRouter;
+
+const PROCEDURE_DEFINITION_MAP: Record<
+  ProcedureType,
+  'queries' | 'mutations' | 'subscriptions'
+> = {
+  query: 'queries',
+  mutation: 'mutations',
+  subscription: 'subscriptions',
+};
+
+/**
+ *
+ * @internal
+ */
+export function createRouterFactory<TSettings extends RootConfig>(
+  defaults?: RouterDefaultOptions<TSettings['ctx']>,
+) {
+  return function createRouterInner<
+    TProcedures extends RouterBuildOptions<TSettings['ctx']>,
+  >(
+    procedures: ValidateShape<
+      TProcedures,
+      RouterBuildOptions<TSettings['ctx']>
+    >,
+  ): Router<{
+    _ctx: TSettings['ctx'];
+    _errorShape: TSettings['errorShape'];
+    _meta: TSettings['meta'];
+    queries: EnsureRecord<TProcedures['queries']>;
+    mutations: EnsureRecord<TProcedures['mutations']>;
+    subscriptions: EnsureRecord<TProcedures['subscriptions']>;
+    errorFormatter: ErrorFormatter<TSettings['ctx'], TSettings['errorShape']>;
+    transformer: TSettings['transformer'];
+  }> {
+    const result = mergeWithoutOverrides<
+      RouterDefaultOptions<TSettings['ctx']> &
+        RouterBuildOptions<TSettings['ctx']>
+    >(
+      {
+        transformer: defaults?.transformer ?? defaultTransformer,
+        errorFormatter: defaults?.errorFormatter ?? defaultFormatter,
+      },
+      {
+        queries: omitPrototype(procedures.queries),
+        mutations: omitPrototype(procedures.mutations),
+        subscriptions: omitPrototype(procedures.subscriptions),
+      },
+    );
+
+    const _def: AnyRouterParams<TSettings['ctx']> = {
+      ...emptyRouter,
+      ...result,
+    };
+    const def = {
+      _def,
+      ..._def,
+    };
+
+    function callProcedure(opts: InternalProcedureCallOptions) {
+      const { type, path } = opts;
+      const defTarget = PROCEDURE_DEFINITION_MAP[type];
+      const defs = def[defTarget];
+
+      if (!(path in defs)) {
+        throw new TRPCError({
+          code: 'NOT_FOUND',
+          message: `No "${type}"-procedure on path "${path}"`,
+        });
+      }
+      const procedure = defs[path] as InternalProcedure;
+      return procedure(opts);
+    }
+    const router: AnyRouter = {
+      ...def,
+      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,
+        };
+      },
+      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;
+  };
+}
+
+type combineProcedureRecords<
+  A extends Partial<AnyRouter>,
+  B extends Partial<AnyRouter>,
+> = {
+  queries: A['queries'] & B['queries'];
+  mutations: A['mutations'] & B['mutations'];
+  subscriptions: A['subscriptions'] & B['subscriptions'];
+};
+/**
+ * @internal
+ */
+export type mergeProcedureRecordsVariadic<
+  Routers extends Partial<AnyRouter>[],
+> = Routers extends []
+  ? {
+      queries: {};
+      mutations: {};
+      subscriptions: {};
+    }
+  : Routers extends [infer First, ...infer Rest]
+  ? First extends Partial<AnyRouter>
+    ? Rest extends Partial<AnyRouter>[]
+      ? combineProcedureRecords<First, mergeProcedureRecordsVariadic<Rest>>
+      : never
+    : never
+  : never;

package/src/core/types.ts

@@ -0,0 +1,37 @@
+import { inferObservableValue } from '../observable';
+import { inferAsyncReturnType } from '../types';
+import { Procedure, ProcedureArgs } from './procedure';
+import { AnyRouter, AnyRouterParams, Router } from './router';
+
+export type inferRouterParams<TRouter extends AnyRouter> =
+  TRouter extends Router<infer TParams>
+    ? TParams extends AnyRouterParams<any>
+      ? TParams
+      : never
+    : never;
+
+export type inferRouterContext<TRouter extends AnyRouter> =
+  inferRouterParams<TRouter>['_ctx'];
+export type inferRouterError<TRouter extends AnyRouter> =
+  inferRouterParams<TRouter>['_errorShape'];
+export type inferRouterMeta<TRouter extends AnyRouter> =
+  inferRouterParams<TRouter>['_meta'];
+
+/**
+ * @public
+ */
+export type ProcedureType = 'query' | 'mutation' | 'subscription';
+
+export type inferHandlerInput<TProcedure extends Procedure<any>> =
+  TProcedure extends Procedure<infer TParams> ? ProcedureArgs<TParams> : never;
+
+export type inferProcedureInput<TProcedure extends Procedure<any>> =
+  inferHandlerInput<TProcedure>[0];
+
+export type inferProcedureOutput<TProcedure extends Procedure<any>> =
+  inferAsyncReturnType<TProcedure>;
+
+export type inferSubscriptionOutput<
+  TRouter extends AnyRouter,
+  TPath extends keyof TRouter['subscriptions'] & string,
+> = inferObservableValue<inferProcedureOutput<TRouter['subscriptions'][TPath]>>;

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

@@ -1,6 +1,9 @@
-import { Observable } from '../observable';
+import { Observable } from '../../observable';
 import { AnyRouter, ProcedureType } from '../router';
 
+/**
+ * @deprecated
+ */
 export async function callProcedure<
   TRouter extends AnyRouter<TContext>,
   TContext,

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

@@ -1,6 +1,9 @@
-import { TRPCError } from '../TRPCError';
+import { TRPCError } from '../../TRPCError';
 import { ProcedureType } from '../router';
 
+/**
+ * @deprecated
+ */
 export const middlewareMarker = 'middlewareMarker' as 'middlewareMarker' & {
   __brand: 'middlewareMarker';
 };
@@ -14,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;
@@ -26,10 +36,16 @@ interface MiddlewareErrorResult<TContext>
   // we could guarantee it's always of this type
 }
 
+/**
+ * @deprecated
+ */
 export type MiddlewareResult<TContext> =
   | MiddlewareOKResult<TContext>
   | MiddlewareErrorResult<TContext>;
 
+/**
+ * @deprecated
+ */
 export type MiddlewareFunction<TInputContext, TContext, TMeta> = (opts: {
   ctx: TInputContext;
   type: ProcedureType;

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

@@ -1,9 +1,12 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { TRPCError } from '../TRPCError';
-import { assertNotBrowser } from '../assertNotBrowser';
+import { TRPCError } from '../../TRPCError';
+import { assertNotBrowser } from '../../assertNotBrowser';
+import {
+  getCauseFromUnknown,
+  getErrorFromUnknown,
+} from '../../internals/errors';
+import { InferLast } from '../../types';
 import { ProcedureType } from '../router';
-import { InferLast } from '../types';
-import { getCauseFromUnknown, getErrorFromUnknown } from './errors';
 import {
   MiddlewareFunction,
   MiddlewareResult,
@@ -58,6 +61,7 @@ interface ProcedureOptions<TContext, TMeta, TInput, TOutput, TParsedOutput> {
 
 /**
  * @internal
+ * @deprecated
  */
 export interface ProcedureCallOptions<TContext> {
   ctx: TContext;
@@ -101,6 +105,7 @@ function getParseFn<T>(procedureParser: ProcedureParser<T>): ParseFn<T> {
 
 /**
  * @internal
+ * @deprecated
  */
 export class Procedure<
   TInputContext,
@@ -138,6 +143,16 @@ export class Procedure<
     this.meta = opts.meta;
   }
 
+  public _def() {
+    return {
+      middlewares: this.middlewares,
+      resolver: this.resolver,
+      inputParser: this.inputParser,
+      outputParser: this.outputParser,
+      meta: this.meta,
+    };
+  }
+
   private async parseInput(rawInput: unknown): Promise<TParsedInput> {
     try {
       return await this.parseInputFn(rawInput);

package/src/deprecated/interop.ts

@@ -0,0 +1,169 @@
+import { getParseFnOrPassThrough } from '../core/internals/getParseFn';
+import {
+  createInputMiddleware,
+  createInternalBuilder,
+  createOutputMiddleware,
+} from '../core/internals/internalProcedure';
+import { Procedure as NewProcedure } from '../core/procedure';
+import { Router as NewRouter, createRouterFactory } from '../core/router';
+import {
+  AnyRouter as AnyOldRouter,
+  Router as OldRouter,
+} from '../deprecated/router';
+import { TRPCErrorShape } from '../rpc';
+import { CombinedDataTransformer } from '../transformer';
+import { Procedure as OldProcedure } from './internals/procedure';
+import { ProcedureRecord } from './router';
+
+type AnyOldProcedure = OldProcedure<any, any, any, any, any, any, any, any>;
+type MigrateProcedure<TProcedure extends AnyOldProcedure> =
+  TProcedure extends OldProcedure<
+    infer TInputContext,
+    infer TContext,
+    infer TMeta,
+    infer TInput,
+    infer TParsedInput,
+    infer TOutput,
+    infer _TParsedOutput,
+    infer TFinalInput
+  >
+    ? NewProcedure<{
+        _ctx_in: TInputContext;
+        _ctx_out: TContext;
+        _meta: TMeta;
+        _input_in: TInput;
+        _input_out: TParsedInput;
+        _output_in: TOutput;
+        _output_out: TFinalInput;
+      }>
+    : never;
+
+export type MigrateProcedureRecord<T extends ProcedureRecord<any>> = {
+  [K in keyof T]: MigrateProcedure<T[K]>;
+};
+
+export type MigrateRouter<
+  TInputContext,
+  TContext,
+  TMeta extends Record<string, any>,
+  TQueries extends ProcedureRecord<
+    TInputContext,
+    TContext,
+    any,
+    any,
+    any,
+    any,
+    any
+  >,
+  TMutations extends ProcedureRecord<
+    TInputContext,
+    TContext,
+    any,
+    any,
+    any,
+    any,
+    any
+  >,
+  TSubscriptions extends ProcedureRecord<
+    TInputContext,
+    TContext,
+    unknown,
+    unknown,
+    any,
+    unknown,
+    unknown
+  >,
+  TErrorShape extends TRPCErrorShape<number>,
+> = NewRouter<{
+  _ctx: TInputContext;
+  _errorShape: TErrorShape;
+  _meta: TMeta;
+  errorFormatter: never;
+  mutations: MigrateProcedureRecord<TMutations>;
+  queries: MigrateProcedureRecord<TQueries>;
+  subscriptions: MigrateProcedureRecord<TSubscriptions>;
+  transformer: CombinedDataTransformer;
+}>;
+
+export type MigrateOldRouter<TRouter extends AnyOldRouter> =
+  TRouter extends OldRouter<
+    infer TInputContext,
+    infer TContext,
+    infer TMeta,
+    infer TQueries,
+    infer TMutations,
+    infer TSubscriptions,
+    infer TErrorShape
+  >
+    ? MigrateRouter<
+        TInputContext,
+        TContext,
+        TMeta,
+        TQueries,
+        TMutations,
+        TSubscriptions,
+        TErrorShape
+      >
+    : never;
+
+function migrateProcedure<TProcedure extends AnyOldProcedure>(
+  oldProc: TProcedure,
+): MigrateProcedure<TProcedure> {
+  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 as any),
+      inputMiddleware,
+      createOutputMiddleware(outputParser),
+    ],
+    meta: def.meta,
+    output: def.outputParser,
+  });
+
+  const proc = builder.resolve((opts) => def.resolver(opts as any));
+
+  return proc as any;
+}
+export function migrateRouter<TOldRouter extends AnyOldRouter>(
+  oldRouter: TOldRouter,
+): MigrateOldRouter<TOldRouter> {
+  const errorFormatter = oldRouter._def.errorFormatter;
+  const transformer = oldRouter._def.transformer;
+
+  type ProcRecord = Record<string, NewProcedure<any>>;
+
+  const queries: ProcRecord = {};
+  const mutations: ProcRecord = {};
+  const subscriptions: ProcRecord = {};
+  for (const [name, procedure] of Object.entries(oldRouter._def.queries)) {
+    queries[name] = migrateProcedure(procedure as any);
+  }
+
+  for (const [name, procedure] of Object.entries(oldRouter._def.mutations)) {
+    mutations[name] = migrateProcedure(procedure as any);
+  }
+
+  for (const [name, procedure] of Object.entries(
+    oldRouter._def.subscriptions,
+  )) {
+    subscriptions[name] = migrateProcedure(procedure as any);
+  }
+
+  const newRouter = createRouterFactory<any>({
+    transformer,
+    errorFormatter,
+  })({
+    mutations,
+    queries,
+    subscriptions,
+  });
+
+  return newRouter as any;
+}