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

package/src/observable/types.ts

@@ -1,76 +0,0 @@
-export interface Unsubscribable {
-  unsubscribe(): void;
-}
-export type UnsubscribeFn = () => void;
-interface Subscribable<TValue, TError> {
-  subscribe(observer: Partial<Observer<TValue, TError>>): Unsubscribable;
-}
-export interface Observable<TValue, TError>
-  extends Subscribable<TValue, TError> {
-  pipe(): Observable<TValue, TError>;
-  pipe<TValue1, TError1>(
-    op1: OperatorFunction<TValue, TError, TValue1, TError1>,
-  ): Observable<TValue1, TError1>;
-  pipe<TValue1, TError1, TValue2, TError2>(
-    op1: OperatorFunction<TValue, TError, TValue1, TError1>,
-    op2: OperatorFunction<TValue1, TError1, TValue2, TError2>,
-  ): Observable<TValue2, TError2>;
-  pipe<TValue1, TError1, TValue2, TError2, TValue3, TError3>(
-    op1: OperatorFunction<TValue, TError, TValue1, TError1>,
-    op2: OperatorFunction<TValue1, TError1, TValue2, TError2>,
-    op3: OperatorFunction<TValue2, TError2, TValue3, TError3>,
-  ): Observable<TValue2, TError2>;
-  pipe<TValue1, TError1, TValue2, TError2, TValue3, TError3, TValue4, TError4>(
-    op1: OperatorFunction<TValue, TError, TValue1, TError1>,
-    op2: OperatorFunction<TValue1, TError1, TValue2, TError2>,
-    op3: OperatorFunction<TValue2, TError2, TValue3, TError3>,
-    op4: OperatorFunction<TValue3, TError3, TValue4, TError4>,
-  ): Observable<TValue2, TError2>;
-  pipe<
-    TValue1,
-    TError1,
-    TValue2,
-    TError2,
-    TValue3,
-    TError3,
-    TValue4,
-    TError4,
-    TValue5,
-    TError5,
-  >(
-    op1: OperatorFunction<TValue, TError, TValue1, TError1>,
-    op2: OperatorFunction<TValue1, TError1, TValue2, TError2>,
-    op3: OperatorFunction<TValue2, TError2, TValue3, TError3>,
-    op4: OperatorFunction<TValue3, TError3, TValue4, TError4>,
-    op5: OperatorFunction<TValue4, TError4, TValue5, TError5>,
-  ): Observable<TValue2, TError2>;
-}
-
-export interface Observer<TValue, TError> {
-  next: (value: TValue) => void;
-  error: (err: TError) => void;
-  complete: () => void;
-}
-
-export type TeardownLogic =
-  // | SubscriptionLike
-  Unsubscribable | UnsubscribeFn | void;
-
-export type UnaryFunction<TSource, TReturn> = (source: TSource) => TReturn;
-
-export type OperatorFunction<
-  TValueBefore,
-  TErrorBefore,
-  TValueAfter,
-  TErrorAfter,
-> = UnaryFunction<
-  Subscribable<TValueBefore, TErrorBefore>,
-  Subscribable<TValueAfter, TErrorAfter>
->;
-
-export type MonoTypeOperatorFunction<TValue, TError> = OperatorFunction<
-  TValue,
-  TError,
-  TValue,
-  TError
->;

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

@@ -1,9 +0,0 @@
-import type { AnyRootConfig } from './rootConfig';
-import type { AnyRouter } from './router';
-
-export type TRPCInferrable = AnyRouter | AnyRootConfig;
-export type inferConfig<TInferrable extends TRPCInferrable> =
-  TInferrable extends AnyRouter ? TInferrable['_def']['_config'] : TInferrable;
-
-export type inferErrorShape<TInferrable extends TRPCInferrable> =
-  inferConfig<TInferrable>['$types']['errorShape'];

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

@@ -1,59 +0,0 @@
-interface ProxyCallbackOptions {
-  path: string[];
-  args: unknown[];
-}
-type ProxyCallback = (opts: ProxyCallbackOptions) => unknown;
-
-const noop = () => {
-  // noop
-};
-
-function createInnerProxy(callback: ProxyCallback, path: string[]) {
-  const proxy: unknown = new Proxy(noop, {
-    get(_obj, key) {
-      if (typeof key !== 'string' || key === 'then') {
-        // special case for if the proxy is accidentally treated
-        // like a PromiseLike (like in `Promise.resolve(proxy)`)
-        return undefined;
-      }
-      return createInnerProxy(callback, [...path, key]);
-    },
-    apply(_1, _2, args) {
-      const isApply = path[path.length - 1] === 'apply';
-      return callback({
-        args: isApply ? (args.length >= 2 ? args[1] : []) : args,
-        path: isApply ? path.slice(0, -1) : path,
-      });
-    },
-  });
-
-  return proxy;
-}
-
-/**
- * Creates a proxy that calls the callback with the path and arguments
- *
- * @internal
- */
-export const createRecursiveProxy = (callback: ProxyCallback) =>
-  createInnerProxy(callback, []);
-
-/**
- * Used in place of `new Proxy` where each handler will map 1 level deep to another value.
- *
- * @internal
- */
-export const createFlatProxy = <TFaux>(
-  callback: (path: string & keyof TFaux) => any,
-): TFaux => {
-  return new Proxy(noop, {
-    get(_obj, name) {
-      if (typeof name !== 'string' || name === 'then') {
-        // special case for if the proxy is accidentally treated
-        // like a PromiseLike (like in `Promise.resolve(proxy)`)
-        return undefined;
-      }
-      return callback(name as any);
-    },
-  }) as TFaux;
-};

package/src/unstable-core-do-not-import/error/TRPCError.ts

@@ -1,82 +0,0 @@
-import type { TRPC_ERROR_CODE_KEY } from '../rpc/codes';
-import { isObject } from '../utils';
-
-class UnknownCauseError extends Error {
-  [key: string]: unknown;
-}
-export function getCauseFromUnknown(cause: unknown): Error | undefined {
-  if (cause instanceof Error) {
-    return cause;
-  }
-
-  const type = typeof cause;
-  if (type === 'undefined' || type === 'function' || cause === null) {
-    return undefined;
-  }
-
-  // Primitive types just get wrapped in an error
-  if (type !== 'object') {
-    return new Error(String(cause));
-  }
-
-  // If it's an object, we'll create a synthetic error
-  if (isObject(cause)) {
-    const err = new UnknownCauseError();
-    for (const key in cause) {
-      err[key] = cause[key];
-    }
-    return err;
-  }
-
-  return undefined;
-}
-
-export function getTRPCErrorFromUnknown(cause: unknown): TRPCError {
-  if (cause instanceof TRPCError) {
-    return cause;
-  }
-  if (cause instanceof Error && cause.name === 'TRPCError') {
-    // https://github.com/trpc/trpc/pull/4848
-    return cause as TRPCError;
-  }
-
-  const trpcError = new TRPCError({
-    code: 'INTERNAL_SERVER_ERROR',
-    cause,
-  });
-
-  // Inherit stack from error
-  if (cause instanceof Error && cause.stack) {
-    trpcError.stack = cause.stack;
-  }
-
-  return trpcError;
-}
-
-export class TRPCError extends Error {
-  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-  // @ts-ignore override doesn't work in all environments due to "This member cannot have an 'override' modifier because it is not declared in the base class 'Error'"
-  public override readonly cause?: Error;
-  public readonly code;
-
-  constructor(opts: {
-    message?: string;
-    code: TRPC_ERROR_CODE_KEY;
-    cause?: unknown;
-  }) {
-    const cause = getCauseFromUnknown(opts.cause);
-    const message = opts.message ?? cause?.message ?? opts.code;
-
-    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-    // @ts-ignore https://github.com/tc39/proposal-error-cause
-    super(message, { cause });
-
-    this.code = opts.code;
-    this.name = 'TRPCError';
-
-    if (!this.cause) {
-      // < ES2022 / < Node 16.9.0 compatability
-      this.cause = cause;
-    }
-  }
-}

package/src/unstable-core-do-not-import/error/formatter.ts

@@ -1,51 +0,0 @@
-import type { ProcedureType } from '../procedure';
-import type {
-  TRPC_ERROR_CODE_KEY,
-  TRPC_ERROR_CODE_NUMBER,
-  TRPCErrorShape,
-} from '../rpc';
-import type { TRPCError } from './TRPCError';
-
-/**
- * @internal
- */
-export type ErrorFormatter<
-  TContext,
-  TShape extends TRPCErrorShape<number>,
-> = (args: {
-  error: TRPCError;
-  type: ProcedureType | 'unknown';
-  path: string | undefined;
-  input: unknown;
-  ctx: TContext | undefined;
-  shape: DefaultErrorShape;
-}) => TShape;
-
-export type ErrorFormatterShape<TType> = TType 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 }) => {
-  return shape;
-};

package/src/unstable-core-do-not-import/error/getErrorShape.ts

@@ -1,36 +0,0 @@
-import { getHTTPStatusCodeFromError } from '../http/getHTTPStatusCode';
-import type { ProcedureType } from '../procedure';
-import type { AnyRootConfig } from '../rootConfig';
-import { TRPC_ERROR_CODES_BY_KEY } from '../rpc';
-import type { DefaultErrorShape } from './formatter';
-import type { TRPCError } from './TRPCError';
-
-/**
- * @internal
- */
-export function getErrorShape<TConfig extends AnyRootConfig>(opts: {
-  config: TConfig;
-  error: TRPCError;
-  type: ProcedureType | 'unknown';
-  path: string | undefined;
-  input: unknown;
-  ctx: TConfig['$types']['ctx'] | undefined;
-}): TConfig['$types']['errorShape'] {
-  const { path, error, config } = opts;
-  const { code } = opts.error;
-  const shape: DefaultErrorShape = {
-    message: error.message,
-    code: TRPC_ERROR_CODES_BY_KEY[code],
-    data: {
-      code,
-      httpStatus: getHTTPStatusCodeFromError(error),
-    },
-  };
-  if (config.isDev && typeof opts.error.stack === 'string') {
-    shape.data.stack = opts.error.stack;
-  }
-  if (typeof path === 'string') {
-    shape.data.path = path;
-  }
-  return config.errorFormatter({ ...opts, shape });
-}

package/src/unstable-core-do-not-import/http/batchStreamFormatter.ts

@@ -1,29 +0,0 @@
-/**
- * Format a batch response as a line-delimited JSON stream
- * that the `unstable_httpBatchStreamLink` can parse:
- *
- * @example
- * ```ts
- * const formatter = getBatchStreamFormatter();
- * res.send(formatter(1, 'response #2'));
- * res.send(formatter(0, 'response #1'));
- * res.send(formatter.end());
- * ```
- *
- * Expected format:
- * ```json
- * {"1":"response #2"
- * ,"0":"response #1"
- * }
- * ```
- */
-export function getBatchStreamFormatter() {
-  let first = true;
-  function format(index: number, string: string) {
-    const prefix = first ? '{' : ',';
-    first = false;
-    return `${prefix}"${index}":${string}\n`;
-  }
-  format.end = () => '}';
-  return format;
-}

package/src/unstable-core-do-not-import/http/contentType.ts

@@ -1,99 +0,0 @@
-/* eslint-disable @typescript-eslint/no-non-null-assertion */
-import { TRPCError } from '../error/TRPCError';
-import type { AnyRouter } from '../router';
-import type { CombinedDataTransformer } from '../transformer';
-import type { MaybePromise } from '../types';
-import type { HTTPRequest } from './types';
-
-type GetInputs = (opts: {
-  req: HTTPRequest;
-  isBatchCall: boolean;
-  router: AnyRouter;
-  preprocessedBody: boolean;
-}) => MaybePromise<Record<number, unknown>>;
-
-export type BodyResult =
-  | {
-      ok: true;
-      data: unknown;
-      /**
-       * If the HTTP handler has already parsed the body
-       */
-      preprocessed: boolean;
-    }
-  | { ok: false; error: TRPCError };
-
-export type BaseContentTypeHandler<TOptions> = {
-  isMatch(opts: TOptions): boolean;
-  getBody: (opts: TOptions) => MaybePromise<BodyResult>;
-  getInputs: GetInputs;
-};
-
-function getRawProcedureInputOrThrow(opts: {
-  req: HTTPRequest;
-  preprocessedBody: boolean;
-}) {
-  const { req } = opts;
-  try {
-    if (req.method === 'GET') {
-      if (!req.query.has('input')) {
-        return undefined;
-      }
-      const raw = req.query.get('input');
-      return JSON.parse(raw!);
-    }
-    if (!opts.preprocessedBody && typeof req.body === 'string') {
-      // A mutation with no inputs will have req.body === ''
-      return req.body.length === 0 ? undefined : JSON.parse(req.body);
-    }
-    return req.body;
-  } catch (cause) {
-    throw new TRPCError({
-      code: 'PARSE_ERROR',
-      cause,
-    });
-  }
-}
-
-const deserializeInputValue = (
-  rawValue: unknown,
-  transformer: CombinedDataTransformer,
-) => {
-  return typeof rawValue !== 'undefined'
-    ? transformer.input.deserialize(rawValue)
-    : rawValue;
-};
-
-export const getJsonContentTypeInputs: GetInputs = (opts) => {
-  const rawInput = getRawProcedureInputOrThrow(opts);
-  const transformer = opts.router._def._config.transformer;
-
-  if (!opts.isBatchCall) {
-    return {
-      0: deserializeInputValue(rawInput, transformer),
-    };
-  }
-
-  /* istanbul ignore if  */
-  if (
-    rawInput == null ||
-    typeof rawInput !== 'object' ||
-    Array.isArray(rawInput)
-  ) {
-    throw new TRPCError({
-      code: 'BAD_REQUEST',
-      message: '"input" needs to be an object when doing a batch call',
-    });
-  }
-  const input: Record<number, unknown> = {};
-  for (const key in rawInput) {
-    const k = key as any as number;
-    const rawValue = rawInput[k];
-
-    const value = deserializeInputValue(rawValue, transformer);
-
-    input[k] = value;
-  }
-
-  return input;
-};

package/src/unstable-core-do-not-import/http/getHTTPStatusCode.ts

@@ -1,57 +0,0 @@
-import type { TRPCError } from '../error/TRPCError';
-import type { TRPC_ERROR_CODES_BY_KEY, TRPCResponse } from '../rpc';
-import { TRPC_ERROR_CODES_BY_NUMBER } from '../rpc';
-
-const JSONRPC2_TO_HTTP_CODE: Record<
-  keyof typeof TRPC_ERROR_CODES_BY_KEY,
-  number
-> = {
-  PARSE_ERROR: 400,
-  BAD_REQUEST: 400,
-  UNAUTHORIZED: 401,
-  NOT_FOUND: 404,
-  FORBIDDEN: 403,
-  METHOD_NOT_SUPPORTED: 405,
-  TIMEOUT: 408,
-  CONFLICT: 409,
-  PRECONDITION_FAILED: 412,
-  PAYLOAD_TOO_LARGE: 413,
-  UNPROCESSABLE_CONTENT: 422,
-  TOO_MANY_REQUESTS: 429,
-  CLIENT_CLOSED_REQUEST: 499,
-  INTERNAL_SERVER_ERROR: 500,
-  NOT_IMPLEMENTED: 501,
-};
-
-function getStatusCodeFromKey(code: keyof typeof TRPC_ERROR_CODES_BY_KEY) {
-  return JSONRPC2_TO_HTTP_CODE[code] ?? 500;
-}
-
-export function getHTTPStatusCode(json: TRPCResponse | TRPCResponse[]) {
-  const arr = Array.isArray(json) ? json : [json];
-  const httpStatuses = new Set(
-    arr.map((res) => {
-      if ('error' in res) {
-        const data = res.error.data;
-        if (typeof data['httpStatus'] === 'number') {
-          return data['httpStatus'];
-        }
-        const code = TRPC_ERROR_CODES_BY_NUMBER[res.error.code];
-        return getStatusCodeFromKey(code);
-      }
-      return 200;
-    }),
-  );
-
-  if (httpStatuses.size !== 1) {
-    return 207;
-  }
-
-  const httpStatus = httpStatuses.values().next().value;
-
-  return httpStatus;
-}
-
-export function getHTTPStatusCodeFromError(error: TRPCError) {
-  return getStatusCodeFromKey(error.code);
-}

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

@@ -1,23 +0,0 @@
-export {
-  getHTTPStatusCode,
-  getHTTPStatusCodeFromError,
-} from './getHTTPStatusCode';
-export { resolveHTTPResponse } from './resolveHTTPResponse';
-export type {
-  BaseHandlerOptions,
-  HTTPBaseHandlerOptions,
-  HTTPHeaders,
-  HTTPRequest,
-  HTTPResponse,
-  OnErrorFunction,
-  ProcedureCall,
-  ResolveHTTPRequestOptionsContextFn,
-  ResponseChunk,
-  ResponseMeta,
-  ResponseMetaFn,
-  TRPCRequestInfo,
-} from './types';
-
-export { getBatchStreamFormatter } from './batchStreamFormatter';
-export type { BaseContentTypeHandler, BodyResult } from './contentType';
-export { getJsonContentTypeInputs } from './contentType';