@trpc/server 11.0.0-alpha-tmp-export-from-main-nuke-core.240 → 11.0.0-alpha-tmp-export-from-main.222

package/src/@trpc/server/index.ts

@@ -1,105 +0,0 @@
-export {
-  TRPCError,
-  /**
-   * @deprecated use `experimental_trpcMiddleware` instead
-   */
-  experimental_standaloneMiddleware,
-  experimental_standaloneMiddleware as experimental_trpcMiddleware,
-  initTRPC,
-  // --- FIXME a bunch of these exports are only useful for plugins - move them somewhere else? ----
-  callProcedure as callTRPCProcedure,
-  getTRPCErrorFromUnknown,
-  transformTRPCResponse,
-  createFlatProxy as createTRPCFlatProxy,
-  type inferProcedureInput,
-  type inferProcedureOutput,
-  type inferRouterError,
-  type inferRouterInputs,
-  type inferRouterOutputs,
-  type inferRouterContext,
-  type inferTransformedProcedureOutput,
-  type inferTransformedSubscriptionOutput,
-  type AnyProcedure as AnyTRPCProcedure,
-  type AnyRouter as AnyTRPCRouter,
-  type AnyMiddlewareFunction as AnyTRPCMiddlewareFunction,
-  type CombinedDataTransformer as TRPCCombinedDataTransformer,
-  type ProcedureType as TRPCProcedureType,
-  type AnyMutationProcedure as AnyTRPCMutationProcedure,
-  type AnyQueryProcedure as AnyTRPCQueryProcedure,
-  type ProcedureRouterRecord as TRPCProcedureRouterRecord,
-  type ProcedureArgs as TRPCProcedureArgs,
-  type AnySubscriptionProcedure as AnyTRPCSubscriptionProcedure,
-} from '../../unstable-core-do-not-import';
-
-export type {
-  /**
-   * @deprecated use `AnyTRPCProcedure` instead
-   */
-  AnyProcedure,
-  /**
-   * @deprecated use `AnyTRPCRouter` instead
-   */
-  AnyRouter,
-  /**
-   * @deprecated use `AnyTRPCMiddlewareFunction` instead
-   */
-  AnyMiddlewareFunction,
-  /**
-   * @deprecated use `TRPCCombinedDataTransformer` instead
-   */
-  CombinedDataTransformer,
-
-  /**
-   * @deprecated This is a utility type will be removed in v12
-   */
-  Dict,
-
-  /**
-   * @deprecated This is a utility type will be removed in v12
-   */
-  DeepPartial,
-  /**
-   * @deprecated use `TRPCProcedureType` instead
-   */
-  ProcedureType,
-  /**
-   * @deprecated use `AnyTRPCMutationProcedure` instead
-   */
-  AnyMutationProcedure,
-
-  /**
-   * @deprecated use `AnyTRPCQueryProcedure` instead
-   */
-  AnyQueryProcedure,
-  /**
-   * @deprecated use `TRPCProcedureRouterRecord` instead
-   */
-  ProcedureRouterRecord,
-  /**
-   * @deprecated use `TRPCProcedureArgs` instead
-   */
-  ProcedureArgs,
-  /**
-   * @deprecated use `AnyTRPCSubscriptionProcedure` instead
-   */
-  AnySubscriptionProcedure,
-} from '../../unstable-core-do-not-import';
-
-export {
-  /**
-   * @deprecated use `getTRPCErrorShape` instead
-   */
-  getErrorShape,
-
-  /**
-   * @deprecated use `callTRPCProcedure` instead
-   */
-  callProcedure,
-} from '../../unstable-core-do-not-import';
-
-/**
- * @deprecated
- * Use `Awaited<ReturnType<typeof myFunction>>` instead
- */
-export type inferAsyncReturnType<TFunction extends (...args: any[]) => any> =
-  Awaited<ReturnType<TFunction>>;

package/src/@trpc/server/rpc.ts

@@ -1,26 +0,0 @@
-// Note: this should likely be moved to a sort of `@trpc/plugin` package
-export type {
-  JSONRPC2,
-  TRPCClientIncomingMessage,
-  TRPCClientIncomingRequest,
-  TRPCClientOutgoingMessage,
-  TRPCClientOutgoingRequest,
-  TRPCErrorResponse,
-  TRPCErrorShape,
-  TRPCReconnectNotification,
-  TRPCRequest,
-  TRPCRequestMessage,
-  TRPCResponse,
-  TRPCResponseMessage,
-  TRPCResult,
-  TRPCResultMessage,
-  TRPCSubscriptionStopNotification,
-  TRPCSuccessResponse,
-  TRPC_ERROR_CODE_KEY,
-  TRPC_ERROR_CODE_NUMBER,
-} from '../../unstable-core-do-not-import';
-export {
-  TRPC_ERROR_CODES_BY_KEY,
-  TRPC_ERROR_CODES_BY_NUMBER,
-  parseTRPCMessage,
-} from '../../unstable-core-do-not-import';

package/src/observable/index.ts

@@ -1,10 +0,0 @@
-export type { inferObservableValue } from './observable';
-export { isObservable, observable, observableToPromise } from './observable';
-export { map, share, tap } from './operators';
-export type {
-  Observable,
-  Observer,
-  TeardownLogic,
-  Unsubscribable,
-  UnsubscribeFn,
-} from './types';

package/src/observable/observable.ts

@@ -1,158 +0,0 @@
-import type {
-  Observable,
-  Observer,
-  OperatorFunction,
-  TeardownLogic,
-  UnaryFunction,
-} from './types';
-
-function identity<TType>(x: TType): TType {
-  return x;
-}
-
-/** @public */
-export type inferObservableValue<TObservable> = TObservable extends Observable<
-  infer TValue,
-  unknown
->
-  ? TValue
-  : never;
-
-/** @public */
-export function isObservable(x: unknown): x is Observable<unknown, unknown> {
-  return typeof x === 'object' && x !== null && 'subscribe' in x;
-}
-
-/** @public */
-export function observable<TValue, TError = unknown>(
-  subscribe: (observer: Observer<TValue, TError>) => TeardownLogic,
-): Observable<TValue, TError> {
-  const self: Observable<TValue, TError> = {
-    subscribe(observer) {
-      let teardownRef: TeardownLogic | null = null;
-      let isDone = false;
-      let unsubscribed = false;
-      let teardownImmediately = false;
-      function unsubscribe() {
-        if (teardownRef === null) {
-          teardownImmediately = true;
-          return;
-        }
-        if (unsubscribed) {
-          return;
-        }
-        unsubscribed = true;
-
-        if (typeof teardownRef === 'function') {
-          teardownRef();
-        } else if (teardownRef) {
-          teardownRef.unsubscribe();
-        }
-      }
-      teardownRef = subscribe({
-        next(value) {
-          if (isDone) {
-            return;
-          }
-          observer.next?.(value);
-        },
-        error(err) {
-          if (isDone) {
-            return;
-          }
-          isDone = true;
-          observer.error?.(err);
-          unsubscribe();
-        },
-        complete() {
-          if (isDone) {
-            return;
-          }
-          isDone = true;
-          observer.complete?.();
-          unsubscribe();
-        },
-      });
-      if (teardownImmediately) {
-        unsubscribe();
-      }
-      return {
-        unsubscribe,
-      };
-    },
-    pipe(
-      ...operations: OperatorFunction<any, any, any, any>[]
-    ): Observable<any, any> {
-      return pipeFromArray(operations)(self) as any;
-    },
-  };
-  return self;
-}
-
-function pipeFromArray<TSource, TReturn>(
-  fns: UnaryFunction<TSource, TReturn>[],
-): UnaryFunction<TSource, TReturn> {
-  if (fns.length === 0) {
-    return identity as UnaryFunction<any, any>;
-  }
-
-  if (fns.length === 1) {
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    return fns[0]!;
-  }
-
-  return function piped(input: TSource): TReturn {
-    return fns.reduce(
-      (prev: any, fn: UnaryFunction<TSource, TReturn>) => fn(prev),
-      input as any,
-    );
-  };
-}
-
-class ObservableAbortError extends Error {
-  constructor(message: string) {
-    super(message);
-    this.name = 'ObservableAbortError';
-    Object.setPrototypeOf(this, ObservableAbortError.prototype);
-  }
-}
-
-/** @internal */
-export function observableToPromise<TValue>(
-  observable: Observable<TValue, unknown>,
-) {
-  let abort: () => void;
-  const promise = new Promise<TValue>((resolve, reject) => {
-    let isDone = false;
-    function onDone() {
-      if (isDone) {
-        return;
-      }
-      isDone = true;
-      reject(new ObservableAbortError('This operation was aborted.'));
-      obs$.unsubscribe();
-    }
-    const obs$ = observable.subscribe({
-      next(data) {
-        isDone = true;
-        resolve(data);
-        onDone();
-      },
-      error(data) {
-        isDone = true;
-        reject(data);
-        onDone();
-      },
-      complete() {
-        isDone = true;
-        onDone();
-      },
-    });
-    abort = onDone;
-  });
-  return {
-    promise,
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    abort: abort!,
-  };
-}

package/src/observable/operators.ts

@@ -1,119 +0,0 @@
-import type {
-  MonoTypeOperatorFunction,
-  Observer,
-  OperatorFunction,
-  Unsubscribable,
-} from './types';
-
-export function map<TValueBefore, TError, TValueAfter>(
-  project: (value: TValueBefore, index: number) => TValueAfter,
-): OperatorFunction<TValueBefore, TError, TValueAfter, TError> {
-  return (originalObserver) => {
-    return {
-      subscribe(observer) {
-        let index = 0;
-        const subscription = originalObserver.subscribe({
-          next(value) {
-            observer.next?.(project(value, index++));
-          },
-          error(error) {
-            observer.error?.(error);
-          },
-          complete() {
-            observer.complete?.();
-          },
-        });
-        return subscription;
-      },
-    };
-  };
-}
-
-interface ShareConfig {}
-export function share<TValue, TError>(
-  _opts?: ShareConfig,
-): MonoTypeOperatorFunction<TValue, TError> {
-  return (originalObserver) => {
-    let refCount = 0;
-
-    let subscription: Unsubscribable | null = null;
-    const observers: Partial<Observer<TValue, TError>>[] = [];
-
-    function startIfNeeded() {
-      if (subscription) {
-        return;
-      }
-      subscription = originalObserver.subscribe({
-        next(value) {
-          for (const observer of observers) {
-            observer.next?.(value);
-          }
-        },
-        error(error) {
-          for (const observer of observers) {
-            observer.error?.(error);
-          }
-        },
-        complete() {
-          for (const observer of observers) {
-            observer.complete?.();
-          }
-        },
-      });
-    }
-    function resetIfNeeded() {
-      // "resetOnRefCountZero"
-      if (refCount === 0 && subscription) {
-        const _sub = subscription;
-        subscription = null;
-        _sub.unsubscribe();
-      }
-    }
-
-    return {
-      subscribe(observer) {
-        refCount++;
-
-        observers.push(observer);
-        startIfNeeded();
-        return {
-          unsubscribe() {
-            refCount--;
-            resetIfNeeded();
-
-            const index = observers.findIndex((v) => v === observer);
-
-            if (index > -1) {
-              observers.splice(index, 1);
-            }
-          },
-        };
-      },
-    };
-  };
-}
-
-export function tap<TValue, TError>(
-  observer: Partial<Observer<TValue, TError>>,
-): MonoTypeOperatorFunction<TValue, TError> {
-  return (originalObserver) => {
-    return {
-      subscribe(observer2) {
-        return originalObserver.subscribe({
-          next(v) {
-            observer.next?.(v);
-            observer2.next?.(v);
-          },
-          error(v) {
-            observer.error?.(v);
-            observer2.error?.(v);
-          },
-          complete() {
-            observer.complete?.();
-            observer2.complete?.();
-          },
-        });
-      },
-    };
-  };
-}

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