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

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>>;

package/src/deprecated/internals/procedure.ts

@@ -0,0 +1,415 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { assertNotBrowser } from '../../assertNotBrowser';
+import { TRPCError } from '../../error/TRPCError';
+import { getCauseFromUnknown, getErrorFromUnknown } from '../../error/utils';
+import { InferLast } from '../../types';
+import { ProcedureType } from '../router';
+import {
+  MiddlewareFunction,
+  MiddlewareResult,
+  middlewareMarker,
+} from './middlewares';
+
+assertNotBrowser();
+
+export type ProcedureParserZodEsque<TInput, TOutput> = {
+  _input: TInput;
+  _output: TOutput;
+};
+
+export type ProcedureParserMyZodEsque<T> = {
+  parse: (input: any) => T;
+};
+
+export type ProcedureParserSuperstructEsque<T> = {
+  create: (input: unknown) => T;
+};
+
+export type ProcedureParserCustomValidatorEsque<T> = (
+  input: unknown,
+) => T | Promise<T>;
+
+export type ProcedureParserYupEsque<T> = {
+  validateSync: (input: unknown) => T;
+};
+
+export type ProcedureParserWithInputOutput<TInput, TOutput> =
+  ProcedureParserZodEsque<TInput, TOutput>;
+
+export type ProcedureParser<T> =
+  | ProcedureParserYupEsque<T>
+  | ProcedureParserSuperstructEsque<T>
+  | ProcedureParserCustomValidatorEsque<T>
+  | ProcedureParserMyZodEsque<T>;
+
+export type ProcedureResolver<TContext, TInput, TOutput> = (opts: {
+  ctx: TContext;
+  input: TInput;
+  type: ProcedureType;
+}) => Promise<TOutput> | TOutput;
+
+interface ProcedureOptions<TContext, TMeta, TInput, TOutput, TParsedOutput> {
+  middlewares: Array<MiddlewareFunction<any, any, any>>;
+  resolver: ProcedureResolver<TContext, TInput, TOutput>;
+  inputParser: ProcedureParser<TInput>;
+  outputParser: ProcedureParser<TParsedOutput>;
+  meta: TMeta;
+}
+
+/**
+ * @internal
+ * @deprecated
+ */
+export interface ProcedureCallOptions<TContext> {
+  ctx: TContext;
+  rawInput: unknown;
+  path: string;
+  type: ProcedureType;
+}
+
+type ParseFn<T> = (value: unknown) => T | Promise<T>;
+
+function getParseFn<T>(procedureParser: ProcedureParser<T>): 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');
+}
+
+/**
+ * @internal
+ * @deprecated
+ */
+export class Procedure<
+  TInputContext,
+  TContext,
+  TMeta,
+  TInput,
+  TParsedInput,
+  TOutput,
+  TParsedOutput,
+  TFinalOutput = unknown extends TParsedOutput ? TOutput : TParsedOutput,
+> {
+  private middlewares: Readonly<Array<MiddlewareFunction<any, any, any>>>;
+  private resolver: ProcedureResolver<TContext, TParsedInput, TOutput>;
+  private readonly inputParser: ProcedureParser<TParsedInput>;
+  private parseInputFn: ParseFn<TParsedInput>;
+  private readonly outputParser: ProcedureParser<TFinalOutput>;
+  private parseOutputFn: ParseFn<TFinalOutput>;
+  public readonly meta: TMeta;
+
+  constructor(
+    opts: ProcedureOptions<
+      TContext,
+      TMeta,
+      TParsedInput,
+      TOutput,
+      TFinalOutput
+    >,
+  ) {
+    this.middlewares = opts.middlewares;
+    this.resolver = opts.resolver;
+    this.inputParser = opts.inputParser;
+    this.parseInputFn = getParseFn(this.inputParser);
+    this.outputParser = opts.outputParser;
+    this.parseOutputFn = getParseFn(this.outputParser);
+    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);
+    } catch (cause) {
+      throw new TRPCError({
+        code: 'BAD_REQUEST',
+        cause: getCauseFromUnknown(cause),
+      });
+    }
+  }
+
+  private async parseOutput(rawOutput: TOutput): Promise<TFinalOutput> {
+    try {
+      return await this.parseOutputFn(rawOutput);
+    } catch (cause) {
+      throw new TRPCError({
+        code: 'INTERNAL_SERVER_ERROR',
+        cause: getCauseFromUnknown(cause),
+        message: 'Output validation failed',
+      });
+    }
+  }
+
+  /**
+   * Trigger middlewares in order, parse raw input, call resolver & parse raw output
+   * @internal
+   */
+  public async call(
+    opts: ProcedureCallOptions<TInputContext>,
+  ): Promise<TFinalOutput> {
+    // wrap the actual resolver and treat as the last "middleware"
+    const middlewaresWithResolver = this.middlewares.concat([
+      async ({ ctx }: { ctx: any }) => {
+        const input = await this.parseInput(opts.rawInput);
+        const rawOutput = await this.resolver({
+          ...opts,
+          ctx,
+          input,
+        });
+        const data = await this.parseOutput(rawOutput);
+        return {
+          marker: middlewareMarker,
+          ok: true,
+          data,
+          ctx,
+        } as const;
+      },
+    ]);
+
+    // run the middlewares recursively with the resolver as the last one
+    const callRecursive = async (
+      callOpts: { ctx: any; index: number } = {
+        index: 0,
+        ctx: opts.ctx,
+      },
+    ): Promise<MiddlewareResult<any>> => {
+      try {
+        const result = await middlewaresWithResolver[callOpts.index]({
+          ctx: callOpts.ctx,
+          type: opts.type,
+          path: opts.path,
+          rawInput: opts.rawInput,
+          meta: this.meta,
+          next: async (nextOpts?: { ctx: any }) => {
+            return await callRecursive({
+              index: callOpts.index + 1,
+              ctx: nextOpts ? nextOpts.ctx : callOpts.ctx,
+            });
+          },
+        });
+        return result;
+      } catch (cause) {
+        return {
+          ctx: callOpts.ctx,
+          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 as TFinalOutput;
+  }
+
+  /**
+   * Create new procedure with passed middlewares
+   * @param middlewares
+   */
+  public inheritMiddlewares(
+    middlewares: MiddlewareFunction<TInputContext, TContext, TMeta>[],
+  ): this {
+    const Constructor: {
+      new (
+        opts: ProcedureOptions<
+          TContext,
+          TMeta,
+          TParsedInput,
+          TOutput,
+          TFinalOutput
+        >,
+      ): Procedure<
+        TInputContext,
+        TContext,
+        TMeta,
+        TInput,
+        TParsedInput,
+        TOutput,
+        TParsedOutput
+      >;
+    } = (this as any).constructor;
+
+    const instance = new Constructor({
+      middlewares: [...middlewares, ...this.middlewares],
+      resolver: this.resolver,
+      inputParser: this.inputParser,
+      outputParser: this.outputParser,
+      meta: this.meta,
+    });
+
+    return instance as any;
+  }
+}
+
+export type CreateProcedureWithInput<TContext, TMeta, TInput, TOutput> = {
+  input: ProcedureParser<TInput>;
+  output?: ProcedureParser<TOutput>;
+  meta?: TMeta;
+  resolve: ProcedureResolver<TContext, TInput, InferLast<TOutput>>;
+};
+
+export type CreateProcedureWithInputOutputParser<
+  TContext,
+  TMeta,
+  TInput,
+  TParsedInput,
+  TOutput,
+  TParsedOutput,
+> = {
+  input: ProcedureParserWithInputOutput<TInput, TParsedInput>;
+  output?: ProcedureParserWithInputOutput<TOutput, TParsedOutput>;
+  meta?: TMeta;
+  resolve: ProcedureResolver<TContext, TParsedInput, InferLast<TOutput>>;
+};
+
+export type CreateProcedureWithoutInput<
+  TContext,
+  TMeta,
+  TOutput,
+  TParsedOutput,
+> = {
+  output?:
+    | ProcedureParserWithInputOutput<TOutput, TParsedOutput>
+    | ProcedureParser<TOutput>;
+  meta?: TMeta;
+  resolve: ProcedureResolver<TContext, undefined, InferLast<TOutput>>;
+};
+
+export type CreateProcedureOptions<
+  TContext,
+  TMeta = undefined,
+  TInput = undefined,
+  TParsedInput = undefined,
+  TOutput = undefined,
+  TParsedOutput = undefined,
+> =
+  | CreateProcedureWithInputOutputParser<
+      TContext,
+      TMeta,
+      TInput,
+      TParsedInput,
+      TOutput,
+      TParsedOutput
+    >
+  | CreateProcedureWithInput<TContext, TMeta, TInput, TOutput>
+  | CreateProcedureWithoutInput<TContext, TMeta, TOutput, TParsedOutput>;
+
+export function createProcedure<
+  TContext,
+  TMeta,
+  TInput,
+  TParsedInput,
+  TOutput,
+  TParsedOutput,
+>(
+  opts: CreateProcedureOptions<
+    TContext,
+    TMeta,
+    TInput,
+    TParsedInput,
+    TOutput,
+    TParsedOutput
+  >,
+): Procedure<
+  unknown,
+  TContext,
+  TMeta,
+  TInput,
+  TParsedInput,
+  TOutput,
+  TParsedOutput
+> {
+  const inputParser =
+    'input' in opts
+      ? opts.input
+      : (input: unknown) => {
+          if (input != null) {
+            throw new TRPCError({
+              code: 'BAD_REQUEST',
+              message: 'No input expected',
+            });
+          }
+          return undefined;
+        };
+
+  const outputParser =
+    'output' in opts && opts.output
+      ? opts.output
+      : (output: unknown) => output as TOutput;
+
+  return new Procedure({
+    inputParser: inputParser as any,
+    resolver: opts.resolve as any,
+    middlewares: [],
+    outputParser: outputParser as any,
+    meta: opts.meta as any,
+  });
+}
+
+export type inferProcedureFromOptions<
+  TInputContext,
+  TOptions extends CreateProcedureOptions<any, any, any, any, any, any>,
+> = TOptions extends CreateProcedureOptions<
+  infer TContext,
+  infer TMeta,
+  infer TInput,
+  infer TParsedInput,
+  infer TOutput,
+  infer TParsedOutput
+>
+  ? Procedure<
+      TInputContext,
+      TContext,
+      TMeta,
+      unknown extends TInput ? undefined : TInput,
+      unknown extends TParsedInput ? undefined : TParsedInput,
+      TOutput,
+      TParsedOutput
+    >
+  : never;

package/src/deprecated/interop.ts

@@ -0,0 +1,229 @@
+import { CombinedDataTransformer, ProcedureParams, ProcedureType } from '..';
+import { CreateRootConfig, RootConfig } from '../core/internals/config';
+import { getParseFnOrPassThrough } from '../core/internals/getParseFn';
+import {
+  createInputMiddleware,
+  createInternalBuilder,
+  createOutputMiddleware,
+} from '../core/internals/internalProcedure';
+import { mergeWithoutOverrides } from '../core/internals/mergeWithoutOverrides';
+import {
+  MutationProcedure,
+  Procedure as NewProcedure,
+  QueryProcedure,
+  SubscriptionProcedure,
+} from '../core/procedure';
+import {
+  Router as NewRouter,
+  RouterDef,
+  createRouterFactory,
+} from '../core/router';
+import {
+  AnyRouter as AnyOldRouter,
+  Router as OldRouter,
+} from '../deprecated/router';
+import { TRPCErrorShape } from '../rpc';
+import { Procedure as OldProcedure } from './internals/procedure';
+import { ProcedureRecord } from './router';
+
+type AnyOldProcedure = OldProcedure<any, any, any, any, any, any, any, any>;
+
+type convertProcedureParams<
+  TConfig extends RootConfig,
+  TProcedure extends AnyOldProcedure,
+> = TProcedure extends OldProcedure<
+  infer TInputContext,
+  infer TContext,
+  infer TMeta,
+  infer TInput,
+  infer TParsedInput,
+  infer TOutput,
+  infer _TParsedOutput,
+  infer TFinalInput
+>
+  ? ProcedureParams<
+      TConfig,
+      TInputContext,
+      TContext,
+      TInput,
+      TParsedInput,
+      TOutput,
+      TFinalInput,
+      TMeta
+    >
+  : never;
+
+type MigrateProcedure<
+  TConfig extends RootConfig,
+  TProcedure extends AnyOldProcedure,
+  TType extends ProcedureType,
+> = TType extends 'query'
+  ? QueryProcedure<convertProcedureParams<TConfig, TProcedure>>
+  : TType extends 'mutation'
+  ? MutationProcedure<convertProcedureParams<TConfig, TProcedure>>
+  : TType extends 'subscription'
+  ? SubscriptionProcedure<convertProcedureParams<TConfig, TProcedure>>
+  : never;
+
+export type MigrateProcedureRecord<
+  TConfig extends RootConfig,
+  T extends ProcedureRecord<any>,
+  TType extends ProcedureType,
+> = {
+  [K in keyof T]: MigrateProcedure<TConfig, T[K], TType>;
+};
+
+export type MigrateRouter<
+  TInputContext extends Record<string, any>,
+  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<any>,
+> = NewRouter<
+  RouterDef<
+    TInputContext,
+    TErrorShape,
+    TMeta,
+    MigrateProcedureRecord<
+      CreateRootConfig<{
+        ctx: TInputContext;
+        errorShape: TErrorShape;
+        meta: TMeta;
+        transformer: CombinedDataTransformer;
+      }>,
+      TQueries,
+      'query'
+    > &
+      MigrateProcedureRecord<
+        CreateRootConfig<{
+          ctx: TInputContext;
+          errorShape: TErrorShape;
+          meta: TMeta;
+          transformer: CombinedDataTransformer;
+        }>,
+        TMutations,
+        'mutation'
+      > &
+      MigrateProcedureRecord<
+        CreateRootConfig<{
+          ctx: TInputContext;
+          errorShape: TErrorShape;
+          meta: TMeta;
+          transformer: CombinedDataTransformer;
+        }>,
+        TSubscriptions,
+        'subscription'
+      >
+  >
+>;
+
+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,
+  TType extends ProcedureType,
+>(oldProc: TProcedure, type: TType): MigrateProcedure<any, TProcedure, TType> {
+  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,
+    mutation: type === 'mutation',
+    query: type === 'query',
+    subscription: type === 'subscription',
+  });
+
+  const proc = builder[type]((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, 'query');
+  }
+
+  for (const [name, procedure] of Object.entries(oldRouter._def.mutations)) {
+    mutations[name] = migrateProcedure(procedure as any, 'mutation');
+  }
+
+  for (const [name, procedure] of Object.entries(
+    oldRouter._def.subscriptions,
+  )) {
+    subscriptions[name] = migrateProcedure(procedure as any, 'subscription');
+  }
+
+  const procedures = mergeWithoutOverrides(queries, mutations, subscriptions);
+
+  const newRouter = createRouterFactory<any>({
+    transformer,
+    errorFormatter,
+  })(procedures);
+
+  return newRouter as any;
+}