@trpc/server 11.0.0-alpha-tmp-export-from-main.218 → 11.0.0-alpha-tmp-export-from-main-nuke-core.239

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

@@ -0,0 +1,90 @@
+import type { ErrorFormatter } from './error/formatter';
+import type { TRPCErrorShape } from './rpc';
+
+/**
+ * The initial generics that are used in the init function
+ * @internal
+ */
+export interface RootConfigTypes {
+  ctx: object;
+  meta: object;
+  errorShape: unknown;
+  transformer: unknown;
+}
+
+/**
+ * The default check to see if we're in a server
+ */
+export const isServerDefault: boolean =
+  typeof window === 'undefined' ||
+  'Deno' in window ||
+  // eslint-disable-next-line @typescript-eslint/dot-notation
+  globalThis.process?.env?.['NODE_ENV'] === 'test' ||
+  !!globalThis.process?.env?.['JEST_WORKER_ID'] ||
+  !!globalThis.process?.env?.['VITEST_WORKER_ID'];
+
+/**
+ * The runtime config that are used and actually represents real values underneath
+ * @internal
+ */
+export interface RuntimeConfig<TTypes extends RootConfigTypes> {
+  /**
+   * Use a data transformer
+   * @link https://trpc.io/docs/v11/data-transformers
+   */
+  transformer: TTypes['transformer'];
+  /**
+   * Use custom error formatting
+   * @link https://trpc.io/docs/v11/error-formatting
+   */
+  errorFormatter: ErrorFormatter<
+    TTypes['ctx'],
+    TRPCErrorShape<number> & { [key: string]: any }
+  >;
+  /**
+   * Allow `@trpc/server` to run in non-server environments
+   * @warning **Use with caution**, this should likely mainly be used within testing.
+   * @default false
+   */
+  allowOutsideOfServer: boolean;
+  /**
+   * Is this a server environment?
+   * @warning **Use with caution**, this should likely mainly be used within testing.
+   * @default typeof window === 'undefined' || 'Deno' in window || process.env.NODE_ENV === 'test'
+   */
+  isServer: boolean;
+  /**
+   * Is this development?
+   * Will be used to decide if the API should return stack traces
+   * @default process.env.NODE_ENV !== 'production'
+   */
+  isDev: boolean;
+
+  defaultMeta?: TTypes['meta'] extends object ? TTypes['meta'] : never;
+}
+
+/**
+ * @internal
+ */
+export type CreateRootConfigTypes<TGenerics extends RootConfigTypes> =
+  TGenerics;
+
+/**
+ * The config that is resolved after `initTRPC.create()` has been called
+ * Combination of `InitTOptions` + `InitGenerics`
+ * @internal
+ */
+export interface RootConfig<TGenerics extends RootConfigTypes>
+  extends RuntimeConfig<TGenerics> {
+  $types: TGenerics;
+}
+
+/**
+ * @internal
+ */
+export type AnyRootConfig = RootConfig<{
+  ctx: any;
+  meta: any;
+  errorShape: any;
+  transformer: any;
+}>;

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

@@ -0,0 +1,370 @@
+import { createRecursiveProxy } from './createProxy';
+import { defaultFormatter } from './error/formatter';
+import { TRPCError } from './error/TRPCError';
+import type {
+  AnyProcedure,
+  inferProcedureInput,
+  inferTransformedProcedureOutput,
+  ProcedureArgs,
+} from './procedure';
+import type { ProcedureCallOptions } from './procedureBuilder';
+import type { AnyRootConfig } from './rootConfig';
+import type { CombinedDataTransformer } from './transformer';
+import { defaultTransformer } from './transformer';
+import type { MaybePromise } from './types';
+import { mergeWithoutOverrides, omitPrototype } from './utils';
+
+/** @internal **/
+export type ProcedureRecord = Record<string, AnyProcedure>;
+
+export interface ProcedureRouterRecord {
+  [key: string]: AnyProcedure | AnyRouter;
+}
+
+export interface RouterDef<
+  TConfig extends AnyRootConfig,
+  TRecord extends ProcedureRouterRecord,
+> {
+  _config: TConfig;
+  router: true;
+  procedure?: never;
+  procedures: TRecord;
+  record: TRecord;
+}
+
+export type AnyRouterDef<TConfig extends AnyRootConfig = AnyRootConfig> =
+  RouterDef<TConfig, any>;
+
+type DecorateProcedure<TProcedure extends AnyProcedure> = (
+  input: ProcedureArgs<TProcedure['_def']>[0],
+) => Promise<TProcedure['_def']['_output_out']>;
+
+/**
+ * @internal
+ */
+type DecoratedProcedureRecord<TProcedures extends ProcedureRouterRecord> = {
+  [TKey in keyof TProcedures]: TProcedures[TKey] extends AnyRouter
+    ? DecoratedProcedureRecord<TProcedures[TKey]['_def']['record']>
+    : TProcedures[TKey] extends AnyProcedure
+    ? DecorateProcedure<TProcedures[TKey]>
+    : never;
+};
+
+/**
+ * @internal
+ */
+export type RouterCaller<TDef extends AnyRouterDef> = (
+  /**
+   * @note
+   * If passing a function, we recommend it's a cached function
+   * e.g. wrapped in `React.cache` to avoid unnecessary computations
+   */
+  ctx:
+    | TDef['_config']['$types']['ctx']
+    | (() => MaybePromise<TDef['_config']['$types']['ctx']>),
+) => DecoratedProcedureRecord<TDef['record']>;
+
+export interface Router<TDef extends AnyRouterDef> {
+  _def: TDef;
+  /**
+   * @deprecated use `t.createCallerFactory(router)` instead
+   * @link https://trpc.io/docs/v11/server/server-side-calls
+   */
+  createCaller: RouterCaller<TDef>;
+}
+
+export type AnyRouter = Router<AnyRouterDef>;
+
+type inferRouterDef<TRouter extends AnyRouter> = TRouter extends Router<
+  infer TParams
+>
+  ? TParams extends AnyRouterDef<any>
+    ? TParams
+    : never
+  : never;
+type inferRouterConfig<TRouter extends AnyRouter> =
+  inferRouterDef<TRouter>['_config'];
+
+export type inferRouterContext<TRouter extends AnyRouter> =
+  inferRouterConfig<TRouter>['$types']['ctx'];
+export type inferRouterError<TRouter extends AnyRouter> =
+  inferRouterConfig<TRouter>['$types']['errorShape'];
+export type inferRouterMeta<TRouter extends AnyRouter> =
+  inferRouterConfig<TRouter>['$types']['meta'];
+
+type GetInferenceHelpers<
+  TType extends 'input' | 'output',
+  TRouter extends AnyRouter,
+> = {
+  [TKey in keyof TRouter['_def']['record']]: TRouter['_def']['record'][TKey] extends infer TRouterOrProcedure
+    ? TRouterOrProcedure extends AnyRouter
+      ? GetInferenceHelpers<TType, TRouterOrProcedure>
+      : TRouterOrProcedure extends AnyProcedure
+      ? TType extends 'input'
+        ? inferProcedureInput<TRouterOrProcedure>
+        : inferTransformedProcedureOutput<
+            TRouter['_def']['_config'],
+            TRouterOrProcedure
+          >
+      : never
+    : never;
+};
+
+export type inferRouterInputs<TRouter extends AnyRouter> = GetInferenceHelpers<
+  'input',
+  TRouter
+>;
+
+export type inferRouterOutputs<TRouter extends AnyRouter> = GetInferenceHelpers<
+  'output',
+  TRouter
+>;
+
+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,
+};
+
+/**
+ * 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',
+];
+
+/**
+ * @internal
+ */
+export type CreateRouterInner<
+  TConfig extends AnyRootConfig,
+  TProcRouterRecord extends ProcedureRouterRecord,
+> = Router<RouterDef<TConfig, TProcRouterRecord>> &
+  /**
+   * This adds ability to call procedures directly but is primarily used for quick access in type inference
+   */
+  TProcRouterRecord;
+
+/**
+ * @internal
+ */
+export function createRouterFactory<TConfig extends AnyRootConfig>(
+  config: TConfig,
+) {
+  return function createRouterInner<
+    TProcRouterRecord extends ProcedureRouterRecord,
+  >(
+    procedures: TProcRouterRecord,
+  ): CreateRouterInner<TConfig, TProcRouterRecord> {
+    const reservedWordsUsed = new Set(
+      Object.keys(procedures).filter((v) => reservedWords.includes(v)),
+    );
+    if (reservedWordsUsed.size > 0) {
+      throw new Error(
+        'Reserved words used in `router({})` call: ' +
+          Array.from(reservedWordsUsed).join(', '),
+      );
+    }
+
+    const routerProcedures: ProcedureRecord = 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;
+        }
+
+        if (routerProcedures[newPath]) {
+          throw new Error(`Duplicate key: ${newPath}`);
+        }
+
+        routerProcedures[newPath] = procedureOrRouter;
+      }
+    }
+    recursiveGetPaths(procedures);
+
+    const _def: AnyRouterDef<TConfig> = {
+      _config: config,
+      router: true,
+      procedures: routerProcedures,
+      ...emptyRouter,
+      record: procedures,
+    };
+
+    const router: AnyRouter = {
+      ...procedures,
+      _def,
+      createCaller(ctx) {
+        const proxy = createRecursiveProxy(({ path, args }) => {
+          const fullPath = path.join('.');
+          const procedure = _def.procedures[fullPath] as AnyProcedure;
+
+          return procedure({
+            path: fullPath,
+            getRawInput: async () => args[0],
+            ctx,
+            type: procedure._def.type,
+          });
+        });
+
+        return proxy as ReturnType<RouterCaller<any>>;
+      },
+    };
+
+    return router as any;
+  };
+}
+
+function isProcedure(
+  procedureOrRouter: AnyProcedure | AnyRouter,
+): procedureOrRouter is AnyProcedure {
+  return !!procedureOrRouter._def.procedure;
+}
+/**
+ * @internal
+ */
+export function callProcedure(
+  opts: ProcedureCallOptions & { procedures: ProcedureRouterRecord },
+) {
+  const { type, path } = opts;
+  const proc = opts.procedures[path];
+  if (!proc || !isProcedure(proc) || proc._def.type !== type) {
+    throw new TRPCError({
+      code: 'NOT_FOUND',
+      message: `No "${type}"-procedure on path "${path}"`,
+    });
+  }
+
+  return proc(opts);
+}
+
+export function createCallerFactory<TConfig extends AnyRootConfig>() {
+  return function createCallerInner<
+    TRouter extends Router<AnyRouterDef<TConfig>>,
+  >(router: TRouter): RouterCaller<TRouter['_def']> {
+    const _def = router._def;
+    type Context = TConfig['$types']['ctx'];
+
+    return function createCaller(maybeContext) {
+      const proxy = createRecursiveProxy(({ path, args }) => {
+        const fullPath = path.join('.');
+        const procedure = _def.procedures[fullPath] as AnyProcedure;
+
+        const callProc = (ctx: Context) =>
+          procedure({
+            path: fullPath,
+            getRawInput: async () => args[0],
+            ctx,
+            type: procedure._def.type,
+          });
+
+        if (typeof maybeContext === 'function') {
+          const context = (maybeContext as () => MaybePromise<Context>)();
+          if (context instanceof Promise) {
+            return context.then(callProc);
+          }
+          return callProc(context);
+        }
+
+        return callProc(maybeContext);
+      });
+
+      return proxy as ReturnType<RouterCaller<any>>;
+    };
+  };
+}
+
+/** @internal */
+type MergeRouters<
+  TRouters extends AnyRouter[],
+  TRouterDef extends AnyRouterDef = RouterDef<
+    TRouters[0]['_def']['_config'],
+    // eslint-disable-next-line @typescript-eslint/ban-types
+    {}
+  >,
+> = TRouters extends [
+  infer Head extends AnyRouter,
+  ...infer Tail extends AnyRouter[],
+]
+  ? MergeRouters<
+      Tail,
+      {
+        _config: TRouterDef['_config'];
+        router: true;
+        procedures: Head['_def']['procedures'] & TRouterDef['procedures'];
+        record: Head['_def']['record'] & TRouterDef['record'];
+      }
+    >
+  : Router<TRouterDef> & TRouterDef['record'];
+
+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 as CombinedDataTransformer);
+
+  const router = createRouterFactory({
+    errorFormatter,
+    transformer,
+    isDev: routerList.some((r) => r._def._config.isDev),
+    allowOutsideOfServer: routerList.some(
+      (r) => r._def._config.allowOutsideOfServer,
+    ),
+    isServer: routerList.some((r) => r._def._config.isServer),
+    $types: routerList[0]?._def._config.$types as any,
+  })(record);
+  return router as any;
+}

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

@@ -0,0 +1,44 @@
+import { invert } from '../utils';
+
+// reference: https://www.jsonrpc.org/specification
+
+/**
+ * JSON-RPC 2.0 Error codes
+ *
+ * `-32000` to `-32099` are reserved for implementation-defined server-errors.
+ * For tRPC we're copying the last digits of HTTP 4XX errors.
+ */
+export const TRPC_ERROR_CODES_BY_KEY = {
+  /**
+   * Invalid JSON was received by the server.
+   * An error occurred on the server while parsing the JSON text.
+   */
+  PARSE_ERROR: -32700,
+  /**
+   * The JSON sent is not a valid Request object.
+   */
+  BAD_REQUEST: -32600, // 400
+
+  // Internal JSON-RPC error
+  INTERNAL_SERVER_ERROR: -32603,
+  NOT_IMPLEMENTED: -32603,
+
+  // Implementation specific errors
+  UNAUTHORIZED: -32001, // 401
+  FORBIDDEN: -32003, // 403
+  NOT_FOUND: -32004, // 404
+  METHOD_NOT_SUPPORTED: -32005, // 405
+  TIMEOUT: -32008, // 408
+  CONFLICT: -32009, // 409
+  PRECONDITION_FAILED: -32012, // 412
+  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];
+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/unstable-core-do-not-import/rpc/envelopes.ts

@@ -0,0 +1,136 @@
+/* eslint-disable @typescript-eslint/no-namespace */
+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;
+  message: string;
+  data: TData;
+}
+
+/**
+ * JSON-RPC 2.0 Specification
+ */
+export namespace JSONRPC2 {
+  export type RequestId = number | string | null;
+
+  /**
+   * All requests/responses extends this shape
+   */
+  export interface BaseEnvelope {
+    id?: RequestId;
+    jsonrpc?: '2.0';
+  }
+
+  export interface BaseRequest<TMethod extends string = string>
+    extends BaseEnvelope {
+    method: TMethod;
+  }
+
+  export interface Request<TMethod extends string = string, TParams = unknown>
+    extends BaseRequest<TMethod> {
+    params: TParams;
+  }
+
+  export interface ResultResponse<TResult = unknown> extends BaseEnvelope {
+    result: TResult;
+  }
+
+  export interface ErrorResponse<TError extends TRPCErrorShape = TRPCErrorShape>
+    extends BaseEnvelope {
+    error: TError;
+  }
+}
+
+/////////////////////////// HTTP envelopes ///////////////////////
+
+export interface TRPCRequest
+  extends JSONRPC2.Request<ProcedureType, { path: string; input: unknown }> {}
+
+export interface TRPCResult<TData = unknown> {
+  data: TData;
+}
+
+export interface TRPCSuccessResponse<TData>
+  extends JSONRPC2.ResultResponse<
+    TRPCResult<TData> & {
+      type?: 'data';
+    }
+  > {}
+
+export interface TRPCErrorResponse<
+  TError extends TRPCErrorShape = TRPCErrorShape,
+> extends JSONRPC2.ErrorResponse<TError> {}
+
+export type TRPCResponse<
+  TData = unknown,
+  TError extends TRPCErrorShape = TRPCErrorShape,
+> = TRPCErrorResponse<TError> | TRPCSuccessResponse<TData>;
+
+/////////////////////////// WebSocket envelopes ///////////////////////
+
+export type TRPCRequestMessage = TRPCRequest & {
+  id: JSONRPC2.RequestId;
+};
+
+/**
+ * The client asked the server to unsubscribe
+ */
+export interface TRPCSubscriptionStopNotification
+  extends JSONRPC2.BaseRequest<'subscription.stop'> {
+  id: null;
+}
+
+/**
+ * The client's outgoing request types
+ */
+export type TRPCClientOutgoingRequest = TRPCSubscriptionStopNotification;
+
+/**
+ * The client's sent messages shape
+ */
+export type TRPCClientOutgoingMessage =
+  | TRPCRequestMessage
+  | (JSONRPC2.BaseRequest<'subscription.stop'> & { id: JSONRPC2.RequestId });
+
+export interface TRPCResultMessage<TData>
+  extends JSONRPC2.ResultResponse<
+    | { type: 'started'; data?: never }
+    | { type: 'stopped'; data?: never }
+    | (TRPCResult<TData> & { type: 'data' })
+  > {}
+
+export type TRPCResponseMessage<
+  TData = unknown,
+  TError extends TRPCErrorShape = TRPCErrorShape,
+> = { id: JSONRPC2.RequestId } & (
+  | TRPCErrorResponse<TError>
+  | TRPCResultMessage<TData>
+);
+
+/**
+ * The server asked the client to reconnect - useful when restarting/redeploying service
+ */
+export interface TRPCReconnectNotification
+  extends JSONRPC2.BaseRequest<'reconnect'> {
+  id: JSONRPC2.RequestId;
+}
+
+/**
+ * The client's incoming request types
+ */
+export type TRPCClientIncomingRequest = TRPCReconnectNotification;
+
+/**
+ * The client's received messages shape
+ */
+export type TRPCClientIncomingMessage<
+  TResult = unknown,
+  TError extends TRPCErrorShape = TRPCErrorShape,
+> = TRPCClientIncomingRequest | TRPCResponseMessage<TResult, TError>;

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