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

package/src/adapters/node-http/types.ts

@@ -1,7 +1,6 @@
 /**
  * If you're making an adapter for tRPC and looking at this file for reference, you should import types and functions from `@trpc/server` and `@trpc/server/http`
  *
- * Do **not** import from `@trpc/core`
  * @example
  * ```ts
  * import type { AnyTRPCRouter } from '@trpc/server'
@@ -9,15 +8,15 @@
  * ```
  */
 import type { IncomingMessage, ServerResponse } from 'http';
-// eslint-disable-next-line no-restricted-imports
-import type { MaybePromise } from '@trpc/core';
 // @trpc/server
-import type { AnyRouter, inferRouterContext } from '../../@trpc-server';
+import type { AnyRouter, inferRouterContext } from '../../@trpc/server';
 // @trpc/server/http
 import type {
   HTTPBaseHandlerOptions,
   TRPCRequestInfo,
-} from '../../@trpc-server/http';
+} from '../../@trpc/server/http';
+// eslint-disable-next-line no-restricted-imports
+import type { MaybePromise } from '../../unstable-core-do-not-import';
 import type { NodeHTTPContentTypeHandler } from './internals/contentType';
 
 interface ParsedQs {

package/src/adapters/standalone.ts

@@ -1,7 +1,6 @@
 /**
  * If you're making an adapter for tRPC and looking at this file for reference, you should import types and functions from `@trpc/server` and `@trpc/server/http`
  *
- * Do **not** import from `@trpc/core`
  * @example
  * ```ts
  * import type { AnyTRPCRouter } from '@trpc/server'
@@ -11,7 +10,7 @@
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
 import http from 'http';
 // @trpc/server
-import type { AnyRouter } from '../@trpc-server';
+import type { AnyRouter } from '../@trpc/server';
 import type {
   NodeHTTPCreateContextFnOptions,
   NodeHTTPHandlerOptions,
@@ -37,6 +36,7 @@ export function createHTTPHandler<TRouter extends AnyRouter>(
     await nodeHTTPRequestHandler({
       // FIXME: no typecasting should be needed here
       ...(opts as CreateHTTPHandlerOptions<AnyRouter>),
+      ...(opts as any),
       req,
       res,
       path,

package/src/adapters/ws.ts

@@ -1,25 +1,26 @@
 import type { IncomingMessage } from 'http';
-// eslint-disable-next-line no-restricted-imports
-import type {
-  BaseHandlerOptions,
-  JSONRPC2,
-  MaybePromise,
-  TRPCClientOutgoingMessage,
-  TRPCReconnectNotification,
-  TRPCResponseMessage,
-  Unsubscribable,
-} from '@trpc/core';
 import type ws from 'ws';
-import type { AnyRouter, inferRouterContext } from '../@trpc-server';
+import type { AnyRouter, inferRouterContext } from '../@trpc/server';
 import {
   callProcedure,
   getErrorShape,
   getTRPCErrorFromUnknown,
   transformTRPCResponse,
   TRPCError,
-} from '../@trpc-server';
+} from '../@trpc/server';
+import type { BaseHandlerOptions } from '../@trpc/server/http';
+import { parseTRPCMessage } from '../@trpc/server/rpc';
+// @trpc/server/rpc
+import type {
+  JSONRPC2,
+  TRPCClientOutgoingMessage,
+  TRPCReconnectNotification,
+  TRPCResponseMessage,
+} from '../@trpc/server/rpc';
 import { isObservable } from '../observable';
-import { parseTRPCMessage } from '../rpc';
+import type { Unsubscribable } from '../observable';
+// eslint-disable-next-line no-restricted-imports
+import type { MaybePromise } from '../unstable-core-do-not-import';
 import type { NodeHTTPCreateContextFnOptions } from './node-http';
 
 /**

package/src/http.ts

@@ -1,26 +1 @@
-export {
-  getHTTPStatusCode,
-  getHTTPStatusCodeFromError,
-} from './@trpc-core-unstable-do-not-import-this-please';
-export { resolveHTTPResponse } from './@trpc-core-unstable-do-not-import-this-please';
-export type {
-  BaseHandlerOptions,
-  HTTPBaseHandlerOptions,
-  HTTPHeaders,
-  HTTPRequest,
-  HTTPResponse,
-  OnErrorFunction,
-  ProcedureCall,
-  ResolveHTTPRequestOptionsContextFn,
-  ResponseChunk,
-  ResponseMeta,
-  ResponseMetaFn,
-  TRPCRequestInfo,
-} from './@trpc-core-unstable-do-not-import-this-please';
-
-export { getBatchStreamFormatter } from './@trpc-core-unstable-do-not-import-this-please';
-export type {
-  BaseContentTypeHandler,
-  BodyResult,
-} from './@trpc-core-unstable-do-not-import-this-please';
-export { getJsonContentTypeInputs } from './@trpc-core-unstable-do-not-import-this-please';
+export * from './@trpc/server/http';

package/src/index.ts

@@ -1 +1 @@
-export * from './@trpc-server';
+export * from './@trpc/server';

package/src/observable/index.ts

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

@@ -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 './@trpc-server';
+} 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;
+    }
+  }
+}