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

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

package/src/{router.ts → deprecated/router.ts}

@@ -1,9 +1,21 @@
 /* eslint-disable @typescript-eslint/ban-types */
 
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { TRPCError } from './TRPCError';
-import { assertNotBrowser } from './assertNotBrowser';
-import { getHTTPStatusCodeFromError } from './http/internals/getHTTPStatusCode';
+import { TRPCError } from '../TRPCError';
+import { assertNotBrowser } from '../assertNotBrowser';
+import { getHTTPStatusCodeFromError } from '../http/internals/getHTTPStatusCode';
+import { Observable, inferObservableValue } from '../observable';
+import {
+  TRPCErrorShape,
+  TRPC_ERROR_CODES_BY_KEY,
+  TRPC_ERROR_CODE_KEY,
+  TRPC_ERROR_CODE_NUMBER,
+} from '../rpc';
+import {
+  CombinedDataTransformer,
+  DataTransformerOptions,
+} from '../transformer';
+import { Prefixer, ThenArg, flatten } from '../types';
 import { MiddlewareFunction } from './internals/middlewares';
 import {
   CreateProcedureOptions,
@@ -15,25 +27,21 @@ import {
   createProcedure,
   inferProcedureFromOptions,
 } from './internals/procedure';
-import { Observable, inferObservableValue } from './observable';
-import {
-  TRPCErrorShape,
-  TRPC_ERROR_CODES_BY_KEY,
-  TRPC_ERROR_CODE_KEY,
-  TRPC_ERROR_CODE_NUMBER,
-} from './rpc';
-import { CombinedDataTransformer, DataTransformerOptions } from './transformer';
-import { Prefixer, ThenArg, flatten } from './types';
+import { MigrateRouter, migrateRouter } from './interop';
 
 assertNotBrowser();
 
+export type { Procedure } from './internals/procedure';
+
 /**
  * @public
+ * @deprecated
  */
 export type ProcedureType = 'query' | 'mutation' | 'subscription';
 
 /**
  * @internal
+ * @deprecated
  */
 export type ProcedureRecord<
   TInputContext = any,
@@ -58,6 +66,7 @@ export type ProcedureRecord<
 
 /**
  * @public
+ * @deprecated
  */
 export type inferProcedureInput<
   TProcedure extends Procedure<any, any, any, any, any, any, any>,
@@ -69,12 +78,14 @@ export type inferProcedureInput<
 
 /**
  * @public
+ * @deprecated
  */
 export type inferAsyncReturnType<TFunction extends (...args: any) => any> =
   ThenArg<ReturnType<TFunction>>;
 
 /**
  * @public
+ * @deprecated
  */
 export type inferProcedureOutput<
   TProcedure extends Procedure<any, any, any, any, any, any, any>,
@@ -83,6 +94,7 @@ export type inferProcedureOutput<
 /**
  * @public
  * @beta
+ * @deprecated
  */
 export type inferSubscriptionOutput<
   TRouter extends AnyRouter,
@@ -101,6 +113,7 @@ function getDataTransformer(
 }
 /**
  * @internal
+ * @deprecated
  */
 export type inferHandlerInput<
   TProcedure extends Procedure<any, any, any, any, any, any, any>,
@@ -122,6 +135,7 @@ type inferHandlerFn<TProcedures extends ProcedureRecord> = <
 
 /**
  * @internal
+ * @deprecated
  */
 export type inferRouterContext<TRouter extends AnyRouter> = Parameters<
   TRouter['createCaller']
@@ -144,6 +158,7 @@ export type inferRouterMeta<TRouter extends AnyRouter> = TRouter extends Router<
 
 /**
  * @public
+ * @deprecated
  */
 export type AnyRouter<TContext = any> = Router<
   any,
@@ -157,6 +172,7 @@ export type AnyRouter<TContext = any> = Router<
 
 /**
  * @internal
+ * @deprecated
  */
 export type inferRouterError<TRouter extends AnyRouter> = ReturnType<
   TRouter['getErrorShape']
@@ -172,6 +188,7 @@ const PROCEDURE_DEFINITION_MAP: Record<
 
 /**
  * @internal
+ * @deprecated
  */
 export type ErrorFormatter<TContext, TShape extends TRPCErrorShape<number>> = ({
   error,
@@ -193,6 +210,7 @@ type DefaultErrorData = {
 
 /**
  * @internal
+ * @deprecated
  */
 export interface DefaultErrorShape
   extends TRPCErrorShape<TRPC_ERROR_CODE_NUMBER, DefaultErrorData> {
@@ -262,6 +280,7 @@ type SwapContext<
 
 /**
  * @internal The type signature of this class may change without warning.
+ * @deprecated
  */
 export class Router<
   TInputContext,
@@ -852,8 +871,26 @@ export class Router<
   > {
     return this as any;
   }
+
+  /**
+   * Interop mode for v9.x -> v10.x
+   */
+  public interop(): MigrateRouter<
+    TInputContext,
+    TContext,
+    TMeta,
+    TQueries,
+    TMutations,
+    TSubscriptions,
+    TErrorShape
+  > {
+    return migrateRouter(this);
+  }
 }
 
+/**
+ * @deprecated
+ */
 export function router<TContext, TMeta extends Record<string, any> = {}>() {
   return new Router<TContext, TContext, TMeta, {}, {}, {}, DefaultErrorShape>();
 }

package/src/error/TRPCError.ts

@@ -0,0 +1,27 @@
+import { TRPC_ERROR_CODE_KEY } from '../rpc/codes';
+import { getMessageFromUnkownError } from './utils';
+
+export class TRPCError extends Error {
+  public readonly cause?: Error | undefined;
+  public readonly code;
+
+  constructor(opts: {
+    message?: string;
+    code: TRPC_ERROR_CODE_KEY;
+    cause?: Error;
+  }) {
+    const cause = opts.cause;
+    const code = opts.code;
+    const message = opts.message ?? getMessageFromUnkownError(cause, code);
+
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore https://github.com/tc39/proposal-error-cause
+    super(message, { cause });
+
+    this.code = code;
+    this.cause = cause;
+    this.name = 'TRPCError';
+
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}

package/src/error/formatter.ts

@@ -0,0 +1,51 @@
+import { ProcedureType } from '../core';
+import {
+  TRPCErrorShape,
+  TRPC_ERROR_CODE_KEY,
+  TRPC_ERROR_CODE_NUMBER,
+} from '../rpc';
+import { TRPCError } from './TRPCError';
+
+/**
+ * @internal
+ */
+export type ErrorFormatter<TContext, TShape extends TRPCErrorShape<number>> = ({
+  error,
+}: {
+  error: TRPCError;
+  type: ProcedureType | 'unknown';
+  path: string | undefined;
+  input: unknown;
+  ctx: undefined | TContext;
+  shape: DefaultErrorShape;
+}) => TShape;
+
+export type ErrorFormatterShape<T> = T extends ErrorFormatter<any, infer TShape>
+  ? TShape
+  : DefaultErrorShape;
+/**
+ * @internal
+ */
+export type DefaultErrorData = {
+  code: TRPC_ERROR_CODE_KEY;
+  httpStatus: number;
+  path?: string;
+  stack?: string;
+};
+
+/**
+ * @internal
+ */
+export interface DefaultErrorShape
+  extends TRPCErrorShape<TRPC_ERROR_CODE_NUMBER, DefaultErrorData> {
+  message: string;
+  code: TRPC_ERROR_CODE_NUMBER;
+}
+
+export const defaultFormatter: ErrorFormatter<any, any> = ({
+  shape,
+}: {
+  shape: DefaultErrorShape;
+}) => {
+  return shape;
+};

package/src/error/utils.ts

@@ -0,0 +1,49 @@
+import { TRPCError } from './TRPCError';
+
+export function getMessageFromUnkownError(
+  err: unknown,
+  fallback: string,
+): string {
+  if (typeof err === 'string') {
+    return err;
+  }
+
+  if (err instanceof Error && typeof err.message === 'string') {
+    return err.message;
+  }
+  return fallback;
+}
+
+export function getErrorFromUnknown(cause: unknown): TRPCError {
+  // this should ideally be an `instanceof TRPCError` but for some reason that isn't working
+  // ref https://github.com/trpc/trpc/issues/331
+  if (cause instanceof Error && cause.name === 'TRPCError') {
+    return cause as TRPCError;
+  }
+
+  let errorCause: Error | undefined = undefined;
+  let stack: string | undefined = undefined;
+
+  if (cause instanceof Error) {
+    errorCause = cause;
+    // take stack trace from cause
+    stack = cause.stack;
+  }
+
+  const err = new TRPCError({
+    code: 'INTERNAL_SERVER_ERROR',
+    cause: errorCause,
+  });
+
+  err.stack = stack;
+
+  return err;
+}
+
+export function getCauseFromUnknown(cause: unknown) {
+  if (cause instanceof Error) {
+    return cause;
+  }
+
+  return undefined;
+}

package/src/http/index.ts

@@ -1,6 +1,6 @@
 import { assertNotBrowser } from '../assertNotBrowser';
 
 export * from './resolveHTTPResponse';
-export * from './responseMeta';
+export * from './types';
 
 assertNotBrowser();

package/src/http/internals/types.ts

@@ -1,14 +1,9 @@
 import { TRPCError } from '../../TRPCError';
-import { BaseHandlerOptions } from '../../internals/baseHandlerOptions';
-import {
-  AnyRouter,
-  ProcedureType,
-  inferRouterContext,
-  inferRouterError,
-} from '../../router';
+import { AnyRouter, ProcedureType, inferRouterParams } from '../../core';
+import { BaseHandlerOptions } from '../../internals/types';
 import { TRPCResponse } from '../../rpc';
 import { Dict } from '../../types';
-import { ResponseMeta } from '../responseMeta';
+import { ResponseMeta } from '../types';
 
 export type HTTPHeaders = Dict<string | string[]>;
 
@@ -25,9 +20,12 @@ export interface HTTPRequest {
   body: unknown;
 }
 
-type ResponseMetaFn<TRouter extends AnyRouter> = (opts: {
-  data: TRPCResponse<unknown, inferRouterError<TRouter>>[];
-  ctx?: inferRouterContext<TRouter>;
+/**
+ * @internal
+ */
+export type ResponseMetaFn<TRouter extends AnyRouter> = (opts: {
+  data: TRPCResponse<unknown, inferRouterParams<TRouter>['_error']>[];
+  ctx?: inferRouterParams<TRouter>['_ctx'];
   /**
    * The different tRPC paths requested
    **/

package/src/http/resolveHTTPResponse.ts

@@ -1,14 +1,13 @@
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
 import { TRPCError } from '../TRPCError';
-import { callProcedure } from '../internals/callProcedure';
-import { getCauseFromUnknown, getErrorFromUnknown } from '../internals/errors';
-import { transformTRPCResponse } from '../internals/transformTRPCResponse';
 import {
   AnyRouter,
   ProcedureType,
   inferRouterContext,
   inferRouterError,
-} from '../router';
+} from '../core';
+import { getCauseFromUnknown, getErrorFromUnknown } from '../internals/errors';
+import { transformTRPCResponse } from '../internals/transformTRPCResponse';
 import { TRPCResponse } from '../rpc';
 import { Maybe } from '../types';
 import { getHTTPStatusCode } from './internals/getHTTPStatusCode';
@@ -170,14 +169,10 @@ export async function resolveHTTPResponse<
     const rawResults = await Promise.all(
       paths.map(async (path, index) => {
         const input = inputs[index];
+
         try {
-          const output = await callProcedure({
-            ctx,
-            router,
-            path,
-            input,
-            type,
-          });
+          const caller = router.createCaller(ctx);
+          const output = await caller[type](path, input as any);
           return {
             input,
             path,

package/src/index.ts

@@ -3,4 +3,5 @@ export * from './http';
 export * from './transformer';
 export * from './TRPCError';
 export * from './types';
-export * from './router';
+export { router } from './deprecated/router';
+export * from './core';

package/src/internals/transformTRPCResponse.ts

@@ -1,4 +1,4 @@
-import { AnyRouter } from '../router';
+import { AnyRouter } from '../core/router';
 import { TRPCResponse, TRPCResponseMessage } from '../rpc';
 
 function transformTRPCResponseItem<

package/src/internals/types.ts

@@ -0,0 +1,24 @@
+import { TRPCError } from '../TRPCError';
+import { inferRouterParams } from '../core';
+import { ProcedureType } from '../core';
+import { AnyRouter } from '../core/router';
+
+/**
+ * Base interface for any response handler
+ */
+export interface BaseHandlerOptions<TRouter extends AnyRouter, TRequest> {
+  onError?: OnErrorFunction<TRouter, TRequest>;
+  batching?: {
+    enabled: boolean;
+  };
+  router: TRouter;
+}
+
+export type OnErrorFunction<TRouter extends AnyRouter, TRequest> = (opts: {
+  error: TRPCError;
+  type: ProcedureType | 'unknown';
+  path: string | undefined;
+  req: TRequest;
+  input: unknown;
+  ctx: undefined | inferRouterParams<TRouter>['_ctx'];
+}) => void;

package/src/rpc/codes.ts

@@ -1,4 +1,4 @@
-import { invert } from '../internals/invert';
+import { invert } from './internals/invert';
 
 // reference: https://www.jsonrpc.org/specification
 

package/src/rpc/envelopes.ts

@@ -1,5 +1,5 @@
 /* eslint-disable @typescript-eslint/no-namespace */
-import { ProcedureType } from '../router';
+import { ProcedureType } from '../deprecated/router';
 import { TRPC_ERROR_CODE_NUMBER } from './codes';
 
 /**

package/src/rpc/internals/invert.ts

@@ -0,0 +1,27 @@
+/**
+ * @internal
+ */
+type KeyFromValue<V, T extends Record<PropertyKey, PropertyKey>> = {
+  [K in keyof T]: V extends T[K] ? K : never;
+}[keyof T];
+
+/**
+ * @internal
+ */
+type Invert<T extends Record<PropertyKey, PropertyKey>> = {
+  [V in T[keyof T]]: KeyFromValue<V, T>;
+};
+
+/**
+ * @internal
+ */
+export function invert<T extends Record<PropertyKey, PropertyKey>>(
+  obj: T,
+): Invert<T> {
+  const newObj = Object.create(null) as any;
+  for (const key in obj) {
+    const v = obj[key];
+    newObj[v] = key;
+  }
+  return newObj;
+}

package/src/transformer.ts

@@ -35,3 +35,31 @@ export type DataTransformerOptions = DataTransformer | CombinedDataTransformer;
 export type ClientDataTransformerOptions =
   | DataTransformer
   | CombinedDataTransformerClient;
+
+/**
+ * @internal
+ */
+export function getDataTransformer(
+  transformer: DataTransformerOptions,
+): CombinedDataTransformer {
+  if ('input' in transformer) {
+    return transformer;
+  }
+  return { input: transformer, output: transformer };
+}
+
+/**
+ * @internal
+ */
+export type DefaultDataTransformer = CombinedDataTransformer & {
+  _default: true;
+};
+
+/**
+ * @internal
+ */
+export const defaultTransformer: DefaultDataTransformer = {
+  _default: true,
+  input: { serialize: (obj) => obj, deserialize: (obj) => obj },
+  output: { serialize: (obj) => obj, deserialize: (obj) => obj },
+};

package/src/types.ts

@@ -47,9 +47,21 @@ export type ThenArg<T> = T extends PromiseLike<infer U> ? ThenArg<U> : T;
  */
 export type Dict<T> = Record<string, T | undefined>;
 
+/**
+ * @public
+ */
+export type MaybePromise<T> = T | Promise<T>;
+
 /**
  * @internal
+ *
  * Creates a "lower-priority" type inference.
  * https://github.com/microsoft/TypeScript/issues/14829#issuecomment-322267089
  */
 export type InferLast<T> = T & { [K in keyof T]: T[K] };
+
+/**
+ * @public
+ */
+export type inferAsyncReturnType<TFunction extends (...args: any) => any> =
+  ThenArg<ReturnType<TFunction>>;

package/dist/http/responseMeta.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"responseMeta.d.ts","sourceRoot":"","sources":["../../src/http/responseMeta.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,YAAY;IAC3B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAClC"}