@trpc/server 11.0.0-alpha-tmp-export-from-main-nuke-core.215 → 11.0.0-alpha-tmp-export-from-main.211

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

@@ -1,370 +0,0 @@
-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

@@ -1,44 +0,0 @@
-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

@@ -1,136 +0,0 @@
-/* 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

@@ -1,21 +0,0 @@
-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/unstable-core-do-not-import/rpc/parseTRPCMessage.ts

@@ -1,85 +0,0 @@
-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 (!isObject(obj)) {
-    throw new Error('Not an object');
-  }
-}
-
-/* istanbul ignore next -- @preserve */
-function assertIsProcedureType(obj: unknown): asserts obj is ProcedureType {
-  if (!procedureTypes.includes(obj as any)) {
-    throw new Error('Invalid procedure type');
-  }
-}
-
-/* istanbul ignore next -- @preserve */
-function assertIsRequestId(
-  obj: unknown,
-): asserts obj is number | string | null {
-  if (
-    obj !== null &&
-    typeof obj === 'number' &&
-    isNaN(obj) &&
-    typeof obj !== 'string'
-  ) {
-    throw new Error('Invalid request id');
-  }
-}
-
-/* istanbul ignore next -- @preserve */
-function assertIsString(obj: unknown): asserts obj is string {
-  if (typeof obj !== 'string') {
-    throw new Error('Invalid string');
-  }
-}
-
-/* istanbul ignore next -- @preserve */
-function assertIsJSONRPC2OrUndefined(
-  obj: unknown,
-): asserts obj is '2.0' | undefined {
-  if (typeof obj !== 'undefined' && obj !== '2.0') {
-    throw new Error('Must be JSONRPC 2.0');
-  }
-}
-
-/** @public */
-export function parseTRPCMessage(
-  obj: unknown,
-  transformer: CombinedDataTransformer,
-): TRPCClientOutgoingMessage {
-  assertIsObject(obj);
-
-  const { id, jsonrpc, method, params } = obj;
-  assertIsRequestId(id);
-  assertIsJSONRPC2OrUndefined(jsonrpc);
-
-  if (method === 'subscription.stop') {
-    return {
-      id,
-      jsonrpc,
-      method,
-    };
-  }
-  assertIsProcedureType(method);
-  assertIsObject(params);
-  const { input: rawInput, path } = params;
-
-  assertIsString(path);
-
-  const input = transformer.input.deserialize(rawInput);
-
-  return {
-    id,
-    jsonrpc,
-    method,
-    params: {
-      input,
-      path,
-    },
-  };
-}