@trpc/server 11.0.0-next.92 → 11.0.0-rc.330

package/src/unstable-core-do-not-import/router.ts

@@ -0,0 +1,363 @@
+import type { Observable } from '../observable';
+import { createRecursiveProxy } from './createProxy';
+import { defaultFormatter } from './error/formatter';
+import { getTRPCErrorFromUnknown, TRPCError } from './error/TRPCError';
+import type {
+  AnyProcedure,
+  ErrorHandlerOptions,
+  inferProcedureInput,
+  inferProcedureOutput,
+} from './procedure';
+import type { ProcedureCallOptions } from './procedureBuilder';
+import type { AnyRootTypes, RootConfig } from './rootConfig';
+import { defaultTransformer } from './transformer';
+import type { MaybePromise, ValueOf } from './types';
+import { isFunction, mergeWithoutOverrides, omitPrototype } from './utils';
+
+export interface RouterRecord {
+  [key: string]: AnyProcedure | RouterRecord;
+}
+
+type DecorateProcedure<TProcedure extends AnyProcedure> = (
+  input: inferProcedureInput<TProcedure>,
+) => Promise<
+  TProcedure['_def']['type'] extends 'subscription'
+    ? Observable<inferProcedureOutput<TProcedure>, TRPCError>
+    : inferProcedureOutput<TProcedure>
+>;
+
+/**
+ * @internal
+ */
+export type DecorateRouterRecord<TRecord extends RouterRecord> = {
+  [TKey in keyof TRecord]: TRecord[TKey] extends AnyProcedure
+    ? DecorateProcedure<TRecord[TKey]>
+    : TRecord[TKey] extends RouterRecord
+    ? DecorateRouterRecord<TRecord[TKey]>
+    : never;
+};
+
+/**
+ * @internal
+ */
+
+export type RouterCallerErrorHandler<TContext> = (
+  opts: ErrorHandlerOptions<TContext>,
+) => void;
+
+/**
+ * @internal
+ */
+export type RouterCaller<
+  TRoot extends AnyRootTypes,
+  TRecord extends RouterRecord,
+> = (
+  /**
+   * @note
+   * If passing a function, we recommend it's a cached function
+   * e.g. wrapped in `React.cache` to avoid unnecessary computations
+   */
+  ctx: TRoot['ctx'] | (() => MaybePromise<TRoot['ctx']>),
+  options?: {
+    onError?: RouterCallerErrorHandler<TRoot['ctx']>;
+  },
+) => DecorateRouterRecord<TRecord>;
+
+export interface Router<
+  TRoot extends AnyRootTypes,
+  TRecord extends RouterRecord,
+> {
+  _def: {
+    _config: RootConfig<TRoot>;
+    router: true;
+    procedure?: never;
+    procedures: TRecord;
+    record: TRecord;
+  };
+  /**
+   * @deprecated use `t.createCallerFactory(router)` instead
+   * @link https://trpc.io/docs/v11/server/server-side-calls
+   */
+  createCaller: RouterCaller<TRoot, TRecord>;
+}
+
+export type BuiltRouter<
+  TRoot extends AnyRootTypes,
+  TDef extends RouterRecord,
+> = Router<TRoot, TDef> & TDef;
+
+export type AnyRouter = Router<any, any>;
+
+export type inferRouterRootTypes<TRouter extends AnyRouter> =
+  TRouter['_def']['_config']['$types'];
+
+export type inferRouterContext<TRouter extends AnyRouter> =
+  inferRouterRootTypes<TRouter>['ctx'];
+export type inferRouterError<TRouter extends AnyRouter> =
+  inferRouterRootTypes<TRouter>['errorShape'];
+export type inferRouterMeta<TRouter extends AnyRouter> =
+  inferRouterRootTypes<TRouter>['meta'];
+
+function isRouter(
+  procedureOrRouter: ValueOf<CreateRouterOptions>,
+): procedureOrRouter is AnyRouter {
+  return procedureOrRouter._def && '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,
+};
+
+/**
+ * Reserved words that can't be used as router or procedure names
+ */
+const reservedWords = [
+  /**
+   * Then is a reserved word because otherwise we can't return a promise that returns a Proxy
+   * since JS will think that `.then` is something that exists
+   */
+  'then',
+];
+
+export type CreateRouterOptions = {
+  [key: string]: AnyProcedure | AnyRouter | CreateRouterOptions;
+};
+
+export type DecorateCreateRouterOptions<
+  TRouterOptions extends CreateRouterOptions,
+> = {
+  [K in keyof TRouterOptions]: TRouterOptions[K] extends infer $Value
+    ? $Value extends AnyProcedure
+      ? $Value
+      : $Value extends Router<any, infer TRecord>
+      ? TRecord
+      : $Value extends CreateRouterOptions
+      ? DecorateCreateRouterOptions<$Value>
+      : never
+    : never;
+};
+
+/**
+ * @internal
+ */
+export function createRouterFactory<TRoot extends AnyRootTypes>(
+  config: RootConfig<TRoot>,
+) {
+  function createRouterInner<TInput extends RouterRecord>(
+    input: TInput,
+  ): BuiltRouter<TRoot, TInput>;
+  function createRouterInner<TInput extends CreateRouterOptions>(
+    input: TInput,
+  ): BuiltRouter<TRoot, DecorateCreateRouterOptions<TInput>>;
+  function createRouterInner(input: RouterRecord | CreateRouterOptions) {
+    const reservedWordsUsed = new Set(
+      Object.keys(input).filter((v) => reservedWords.includes(v)),
+    );
+    if (reservedWordsUsed.size > 0) {
+      throw new Error(
+        'Reserved words used in `router({})` call: ' +
+          Array.from(reservedWordsUsed).join(', '),
+      );
+    }
+
+    const procedures: Record<string, AnyProcedure> = omitPrototype({});
+
+    function step(from: CreateRouterOptions, path: string[] = []) {
+      const aggregate: RouterRecord = omitPrototype({});
+      for (const [key, item] of Object.entries(from ?? {})) {
+        if (isRouter(item)) {
+          aggregate[key] = step(item._def.record, [...path, key]);
+          continue;
+        }
+        if (!isProcedure(item)) {
+          // RouterRecord
+          aggregate[key] = step(item, [...path, key]);
+          continue;
+        }
+
+        const newPath = [...path, key].join('.');
+
+        if (procedures[newPath]) {
+          throw new Error(`Duplicate key: ${newPath}`);
+        }
+
+        procedures[newPath] = item;
+        aggregate[key] = item;
+      }
+
+      return aggregate;
+    }
+    const record = step(input);
+
+    const _def: AnyRouter['_def'] = {
+      _config: config,
+      router: true,
+      procedures,
+      ...emptyRouter,
+      record,
+    };
+
+    return {
+      ...record,
+      _def,
+      createCaller: createCallerFactory<TRoot>()({
+        _def,
+      }),
+    };
+  }
+
+  return createRouterInner;
+}
+
+function isProcedure(
+  procedureOrRouter: ValueOf<CreateRouterOptions>,
+): procedureOrRouter is AnyProcedure {
+  return typeof procedureOrRouter === 'function';
+}
+/**
+ * @internal
+ */
+export function callProcedure(
+  opts: ProcedureCallOptions<unknown> & {
+    procedures: RouterRecord;
+    allowMethodOverride?: boolean;
+  },
+) {
+  const { type, path } = opts;
+  const proc = opts.procedures[path];
+  if (
+    !proc ||
+    !isProcedure(proc) ||
+    (proc._def.type !== type && !opts.allowMethodOverride)
+  ) {
+    throw new TRPCError({
+      code: 'NOT_FOUND',
+      message: `No "${type}"-procedure on path "${path}"`,
+    });
+  }
+
+  return proc(opts);
+}
+
+export function createCallerFactory<TRoot extends AnyRootTypes>() {
+  return function createCallerInner<TRecord extends RouterRecord>(
+    router: Pick<Router<TRoot, TRecord>, '_def'>,
+  ): RouterCaller<TRoot, TRecord> {
+    const _def = router._def;
+    type Context = TRoot['ctx'];
+
+    return function createCaller(
+      ctxOrCallback,
+      options?: {
+        onError?: RouterCallerErrorHandler<Context>;
+      },
+    ) {
+      const proxy = createRecursiveProxy(async ({ path, args }) => {
+        const fullPath = path.join('.');
+
+        const procedure = _def.procedures[fullPath] as AnyProcedure;
+
+        let ctx: Context | undefined = undefined;
+        try {
+          ctx = isFunction(ctxOrCallback)
+            ? await Promise.resolve(ctxOrCallback())
+            : ctxOrCallback;
+
+          return await procedure({
+            path: fullPath,
+            getRawInput: async () => args[0],
+            ctx,
+            type: procedure._def.type,
+          });
+        } catch (cause) {
+          options?.onError?.({
+            ctx,
+            error: getTRPCErrorFromUnknown(cause),
+            input: args[0],
+            path: fullPath,
+            type: procedure._def.type,
+          });
+          throw cause;
+        }
+      });
+
+      return proxy as ReturnType<RouterCaller<any, any>>;
+    };
+  };
+}
+
+/** @internal */
+type MergeRouters<
+  TRouters extends AnyRouter[],
+  TRoot extends AnyRootTypes = TRouters[0]['_def']['_config']['$types'],
+  // eslint-disable-next-line @typescript-eslint/ban-types
+  TRecord extends RouterRecord = {},
+> = TRouters extends [
+  infer Head extends AnyRouter,
+  ...infer Tail extends AnyRouter[],
+]
+  ? MergeRouters<Tail, TRoot, Head['_def']['record'] & TRecord>
+  : BuiltRouter<TRoot, TRecord>;
+
+export function mergeRouters<TRouters extends AnyRouter[]>(
+  ...routerList: [...TRouters]
+): MergeRouters<TRouters> {
+  const record = mergeWithoutOverrides(
+    {},
+    ...routerList.map((r) => r._def.record),
+  );
+  const errorFormatter = routerList.reduce(
+    (currentErrorFormatter, nextRouter) => {
+      if (
+        nextRouter._def._config.errorFormatter &&
+        nextRouter._def._config.errorFormatter !== defaultFormatter
+      ) {
+        if (
+          currentErrorFormatter !== defaultFormatter &&
+          currentErrorFormatter !== nextRouter._def._config.errorFormatter
+        ) {
+          throw new Error('You seem to have several error formatters');
+        }
+        return nextRouter._def._config.errorFormatter;
+      }
+      return currentErrorFormatter;
+    },
+    defaultFormatter,
+  );
+
+  const transformer = routerList.reduce((prev, current) => {
+    if (
+      current._def._config.transformer &&
+      current._def._config.transformer !== defaultTransformer
+    ) {
+      if (
+        prev !== defaultTransformer &&
+        prev !== current._def._config.transformer
+      ) {
+        throw new Error('You seem to have several transformers');
+      }
+      return current._def._config.transformer;
+    }
+    return prev;
+  }, defaultTransformer);
+
+  const router = createRouterFactory({
+    errorFormatter,
+    transformer,
+    isDev: routerList.every((r) => r._def._config.isDev),
+    allowOutsideOfServer: routerList.every(
+      (r) => r._def._config.allowOutsideOfServer,
+    ),
+    isServer: routerList.every((r) => r._def._config.isServer),
+    $types: routerList[0]?._def._config.$types,
+  })(record);
+
+  return router as MergeRouters<TRouters>;
+}

package/src/{rpc → unstable-core-do-not-import/rpc}/codes.ts

@@ -1,4 +1,4 @@
-import { invert } from '../internals/invert';
+import type { ValueOf } from '../types';
 
 // reference: https://www.jsonrpc.org/specification
 
@@ -31,14 +31,41 @@ export const TRPC_ERROR_CODES_BY_KEY = {
   TIMEOUT: -32008, // 408
   CONFLICT: -32009, // 409
   PRECONDITION_FAILED: -32012, // 412
+  UNSUPPORTED_MEDIA_TYPE: -32015, // 415
   PAYLOAD_TOO_LARGE: -32013, // 413
   UNPROCESSABLE_CONTENT: -32022, // 422
   TOO_MANY_REQUESTS: -32029, // 429
   CLIENT_CLOSED_REQUEST: -32099, // 499
 } as const;
 
-export const TRPC_ERROR_CODES_BY_NUMBER = invert(TRPC_ERROR_CODES_BY_KEY);
-type ValueOf<TObj> = TObj[keyof TObj];
+type KeyFromValue<TValue, TType extends Record<PropertyKey, PropertyKey>> = {
+  [K in keyof TType]: TValue extends TType[K] ? K : never;
+}[keyof TType];
+
+type Invert<TType extends Record<PropertyKey, PropertyKey>> = {
+  [TValue in TType[keyof TType]]: KeyFromValue<TValue, TType>;
+};
+
+// pure
+export const TRPC_ERROR_CODES_BY_NUMBER: Invert<
+  typeof TRPC_ERROR_CODES_BY_KEY
+> = {
+  [-32700]: 'PARSE_ERROR',
+  [-32600]: 'BAD_REQUEST',
+  [-32603]: 'INTERNAL_SERVER_ERROR',
+  [-32001]: 'UNAUTHORIZED',
+  [-32003]: 'FORBIDDEN',
+  [-32004]: 'NOT_FOUND',
+  [-32005]: 'METHOD_NOT_SUPPORTED',
+  [-32008]: 'TIMEOUT',
+  [-32009]: 'CONFLICT',
+  [-32012]: 'PRECONDITION_FAILED',
+  [-32013]: 'PAYLOAD_TOO_LARGE',
+  [-32015]: 'UNSUPPORTED_MEDIA_TYPE',
+  [-32022]: 'UNPROCESSABLE_CONTENT',
+  [-32029]: 'TOO_MANY_REQUESTS',
+  [-32099]: 'CLIENT_CLOSED_REQUEST',
+};
 
 export type TRPC_ERROR_CODE_NUMBER = ValueOf<typeof TRPC_ERROR_CODES_BY_KEY>;
 export type TRPC_ERROR_CODE_KEY = keyof typeof TRPC_ERROR_CODES_BY_KEY;

package/src/{rpc → unstable-core-do-not-import/rpc}/envelopes.ts

@@ -1,15 +1,12 @@
 /* eslint-disable @typescript-eslint/no-namespace */
-import { ProcedureType } from '../core';
-import { TRPC_ERROR_CODE_NUMBER } from './codes';
+import type { ProcedureType } from '../procedure';
+import type { TRPC_ERROR_CODE_NUMBER } from './codes';
 
 /**
  * Error response
  */
-export interface TRPCErrorShape<
-  TCode extends number = TRPC_ERROR_CODE_NUMBER,
-  TData extends Record<string, unknown> = Record<string, unknown>,
-> {
-  code: TCode;
+export interface TRPCErrorShape<TData extends object = object> {
+  code: TRPC_ERROR_CODE_NUMBER;
   message: string;
   data: TData;
 }
@@ -101,8 +98,8 @@ export type TRPCClientOutgoingMessage =
 
 export interface TRPCResultMessage<TData>
   extends JSONRPC2.ResultResponse<
-    | { type: 'started' }
-    | { type: 'stopped' }
+    | { type: 'started'; data?: never }
+    | { type: 'stopped'; data?: never }
     | (TRPCResult<TData> & { type: 'data' })
   > {}
 

package/src/unstable-core-do-not-import/rpc/index.ts

@@ -0,0 +1,21 @@
+export { TRPC_ERROR_CODES_BY_KEY, TRPC_ERROR_CODES_BY_NUMBER } from './codes';
+export type { TRPC_ERROR_CODE_KEY, TRPC_ERROR_CODE_NUMBER } from './codes';
+export type {
+  JSONRPC2,
+  TRPCClientIncomingMessage,
+  TRPCClientIncomingRequest,
+  TRPCClientOutgoingMessage,
+  TRPCClientOutgoingRequest,
+  TRPCErrorResponse,
+  TRPCErrorShape,
+  TRPCReconnectNotification,
+  TRPCRequest,
+  TRPCRequestMessage,
+  TRPCResponse,
+  TRPCResponseMessage,
+  TRPCResult,
+  TRPCResultMessage,
+  TRPCSubscriptionStopNotification,
+  TRPCSuccessResponse,
+} from './envelopes';
+export { parseTRPCMessage } from './parseTRPCMessage';

package/src/{rpc → unstable-core-do-not-import/rpc}/parseTRPCMessage.ts

@@ -1,17 +1,18 @@
-import type { ProcedureType } from '../core';
+import { procedureTypes, type ProcedureType } from '../procedure';
 import type { CombinedDataTransformer } from '../transformer';
+import { isObject } from '../utils';
 import type { TRPCClientOutgoingMessage } from './envelopes';
 
 /* istanbul ignore next -- @preserve */
 function assertIsObject(obj: unknown): asserts obj is Record<string, unknown> {
-  if (typeof obj !== 'object' || Array.isArray(obj) || !obj) {
+  if (!isObject(obj)) {
     throw new Error('Not an object');
   }
 }
 
 /* istanbul ignore next -- @preserve */
 function assertIsProcedureType(obj: unknown): asserts obj is ProcedureType {
-  if (obj !== 'query' && obj !== 'subscription' && obj !== 'mutation') {
+  if (!procedureTypes.includes(obj as any)) {
     throw new Error('Invalid procedure type');
   }
 }

package/src/unstable-core-do-not-import/transformer.ts

@@ -0,0 +1,194 @@
+import type { AnyRootTypes, RootConfig } from './rootConfig';
+import type { AnyRouter, inferRouterError } from './router';
+import type {
+  TRPCResponse,
+  TRPCResponseMessage,
+  TRPCResultMessage,
+} from './rpc';
+import { isObject } from './utils';
+
+/**
+ * @public
+ */
+export interface DataTransformer {
+  serialize: (object: any) => any;
+  deserialize: (object: any) => any;
+}
+
+interface InputDataTransformer extends DataTransformer {
+  /**
+   * This function runs **on the client** before sending the data to the server.
+   */
+  serialize: (object: any) => any;
+  /**
+   * This function runs **on the server** to transform the data before it is passed to the resolver
+   */
+  deserialize: (object: any) => any;
+}
+
+interface OutputDataTransformer extends DataTransformer {
+  /**
+   * This function runs **on the server** before sending the data to the client.
+   */
+  serialize: (object: any) => any;
+  /**
+   * This function runs **only on the client** to transform the data sent from the server.
+   */
+  deserialize: (object: any) => any;
+}
+
+/**
+ * @public
+ */
+export interface CombinedDataTransformer {
+  /**
+   * Specify how the data sent from the client to the server should be transformed.
+   */
+  input: InputDataTransformer;
+  /**
+   * Specify how the data sent from the server to the client should be transformed.
+   */
+  output: OutputDataTransformer;
+}
+
+/**
+ * @public
+ */
+export type CombinedDataTransformerClient = {
+  input: Pick<CombinedDataTransformer['input'], 'serialize'>;
+  output: Pick<CombinedDataTransformer['output'], 'deserialize'>;
+};
+
+/**
+ * @public
+ */
+export type DataTransformerOptions = CombinedDataTransformer | DataTransformer;
+
+/**
+ * @internal
+ */
+export function getDataTransformer(
+  transformer: DataTransformerOptions,
+): CombinedDataTransformer {
+  if ('input' in transformer) {
+    return transformer;
+  }
+  return { input: transformer, output: transformer };
+}
+
+/**
+ * @internal
+ */
+export const defaultTransformer: CombinedDataTransformer = {
+  input: { serialize: (obj) => obj, deserialize: (obj) => obj },
+  output: { serialize: (obj) => obj, deserialize: (obj) => obj },
+};
+
+function transformTRPCResponseItem<
+  TResponseItem extends TRPCResponse | TRPCResponseMessage,
+>(config: RootConfig<AnyRootTypes>, item: TResponseItem): TResponseItem {
+  if ('error' in item) {
+    return {
+      ...item,
+      error: config.transformer.output.serialize(item.error),
+    };
+  }
+
+  if ('data' in item.result) {
+    return {
+      ...item,
+      result: {
+        ...item.result,
+        data: config.transformer.output.serialize(item.result.data),
+      },
+    };
+  }
+
+  return item;
+}
+
+/**
+ * Takes a unserialized `TRPCResponse` and serializes it with the router's transformers
+ **/
+export function transformTRPCResponse<
+  TResponse extends
+    | TRPCResponse
+    | TRPCResponse[]
+    | TRPCResponseMessage
+    | TRPCResponseMessage[],
+>(config: RootConfig<AnyRootTypes>, itemOrItems: TResponse) {
+  return Array.isArray(itemOrItems)
+    ? itemOrItems.map((item) => transformTRPCResponseItem(config, item))
+    : transformTRPCResponseItem(config, itemOrItems);
+}
+
+// FIXME:
+// - the generics here are probably unnecessary
+// - the RPC-spec could probably be simplified to combine HTTP + WS
+/** @internal */
+function transformResultInner<TRouter extends AnyRouter, TOutput>(
+  response:
+    | TRPCResponse<TOutput, inferRouterError<TRouter>>
+    | TRPCResponseMessage<TOutput, inferRouterError<TRouter>>,
+  transformer: DataTransformer,
+) {
+  if ('error' in response) {
+    const error = transformer.deserialize(
+      response.error,
+    ) as inferRouterError<TRouter>;
+    return {
+      ok: false,
+      error: {
+        ...response,
+        error,
+      },
+    } as const;
+  }
+
+  const result = {
+    ...response.result,
+    ...((!response.result.type || response.result.type === 'data') && {
+      type: 'data',
+      data: transformer.deserialize(response.result.data),
+    }),
+  } as TRPCResultMessage<TOutput>['result'];
+  return { ok: true, result } as const;
+}
+
+class TransformResultError extends Error {
+  constructor() {
+    super('Unable to transform response from server');
+  }
+}
+
+/**
+ * Transforms and validates that the result is a valid TRPCResponse
+ * @internal
+ */
+export function transformResult<TRouter extends AnyRouter, TOutput>(
+  response:
+    | TRPCResponse<TOutput, inferRouterError<TRouter>>
+    | TRPCResponseMessage<TOutput, inferRouterError<TRouter>>,
+  transformer: DataTransformer,
+): ReturnType<typeof transformResultInner> {
+  let result: ReturnType<typeof transformResultInner>;
+  try {
+    // Use the data transformers on the JSON-response
+    result = transformResultInner(response, transformer);
+  } catch (err) {
+    throw new TransformResultError();
+  }
+
+  // check that output of the transformers is a valid TRPCResponse
+  if (
+    !result.ok &&
+    (!isObject(result.error.error) ||
+      typeof result.error.error['code'] !== 'number')
+  ) {
+    throw new TransformResultError();
+  }
+  if (result.ok && !isObject(result.result)) {
+    throw new TransformResultError();
+  }
+  return result;
+}