@trpc/server 11.0.0-next-beta.216 → 11.0.0-next-beta.218

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,2 +1 @@
-// Note: this should likely be moved to a sort of `@trpc/plugin` package
-export * from '@trpc/core/rpc';
+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;
+    }
+  }
+}

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

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

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

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

@@ -0,0 +1,23 @@
+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';