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

package/src/observable/observable.ts

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

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

@@ -0,0 +1,76 @@
+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/rpc.ts

@@ -1,26 +1 @@
-// 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 './@trpc-core-unstable-do-not-import-this-please';
-export {
-  TRPC_ERROR_CODES_BY_KEY,
-  TRPC_ERROR_CODES_BY_NUMBER,
-  parseTRPCMessage,
-} from './@trpc-core-unstable-do-not-import-this-please';
+export * from './@trpc/server/rpc';

package/src/shared.ts

@@ -23,4 +23,4 @@ export {
    * @deprecated `import { createTRPCFlatProxy } from '@trpc/server'` instead
    */
   createTRPCFlatProxy as createFlatProxy,
-} from '.';
+} from './@trpc/server';

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

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

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

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

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

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

@@ -0,0 +1,29 @@
+/**
+ * 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;
+}