@trpc/server 10.0.0-alpha.3 → 10.0.0-alpha.32

package/src/{TRPCError.ts → error/TRPCError.ts}

@@ -1,24 +1,16 @@
-import { TRPC_ERROR_CODE_KEY } from './rpc/codes';
-import { getMessageFromUnkownError } from './internals/errors';
+import { getMessageFromUnkownError } from '../error/utils';
+import { TRPC_ERROR_CODE_KEY } from '../rpc/codes';
 
 export class TRPCError extends Error {
-  /**
-   * @deprecated use `cause`
-   */
-  public readonly originalError?: unknown;
-  public readonly cause?: unknown;
+  public readonly cause?;
   public readonly code;
 
   constructor(opts: {
     message?: string;
     code: TRPC_ERROR_CODE_KEY;
-    /**
-     * @deprecated use `cause`
-     */
-    originalError?: unknown;
-    cause?: unknown;
+    cause?: Error;
   }) {
-    const cause = opts.cause ?? opts.originalError;
+    const cause = opts.cause;
     const code = opts.code;
     const message = opts.message ?? getMessageFromUnkownError(cause, code);
 
@@ -27,7 +19,7 @@ export class TRPCError extends Error {
     super(message, { cause });
 
     this.code = code;
-    this.cause = this.originalError = cause;
+    this.cause = cause;
     this.name = 'TRPCError';
 
     Object.setPrototypeOf(this, new.target.prototype);

package/src/error/formatter.ts

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

package/src/{internals/errors.ts → error/utils.ts}

@@ -1,4 +1,4 @@
-import { TRPCError } from '../TRPCError';
+import { TRPCError } from './TRPCError';
 
 export function getMessageFromUnkownError(
   err: unknown,
@@ -20,14 +20,30 @@ export function getErrorFromUnknown(cause: unknown): TRPCError {
   if (cause instanceof Error && cause.name === 'TRPCError') {
     return cause as TRPCError;
   }
+
+  let errorCause: Error | undefined = undefined;
+  let stack: string | undefined = undefined;
+
+  if (cause instanceof Error) {
+    errorCause = cause;
+    // take stack trace from cause
+    stack = cause.stack;
+  }
+
   const err = new TRPCError({
     code: 'INTERNAL_SERVER_ERROR',
-    cause,
+    cause: errorCause,
   });
 
-  // take stack trace from cause
+  err.stack = stack;
+
+  return err;
+}
+
+export function getCauseFromUnknown(cause: unknown) {
   if (cause instanceof Error) {
-    err.stack = cause.stack;
+    return cause;
   }
-  return err;
+
+  return undefined;
 }

package/src/http/index.ts

@@ -1,6 +1,6 @@
 import { assertNotBrowser } from '../assertNotBrowser';
 
 export * from './resolveHTTPResponse';
-export * from './ResponseMeta';
+export * from './types';
 
 assertNotBrowser();

package/src/http/internals/getHTTPStatusCode.ts

@@ -1,6 +1,6 @@
-import { TRPCResponse, TRPC_ERROR_CODES_BY_KEY } from '../../rpc';
-import { TRPCError } from '../../TRPCError';
+import { TRPCError } from '../../error/TRPCError';
 import { invert } from '../../internals/invert';
+import { TRPCResponse, TRPC_ERROR_CODES_BY_KEY } from '../../rpc';
 
 export const TRPC_ERROR_CODES_BY_NUMBER = invert(TRPC_ERROR_CODES_BY_KEY);
 type ValueOf<T> = T[keyof T];
@@ -17,6 +17,7 @@ const JSONRPC2_TO_HTTP_CODE: Record<
   UNAUTHORIZED: 401,
   FORBIDDEN: 403,
   TIMEOUT: 408,
+  CONFLICT: 409,
   CLIENT_CLOSED_REQUEST: 499,
   PRECONDITION_FAILED: 412,
   PAYLOAD_TOO_LARGE: 413,

package/src/http/internals/types.ts

@@ -1,15 +1,9 @@
-import {
-  AnyRouter,
-  Dict,
-  inferRouterContext,
-  inferRouterError,
-  ProcedureType,
-  ResponseMeta,
-  TRPCError,
-} from '@trpc/server';
-import { URLSearchParams } from 'url';
-import { BaseHandlerOptions } from '../../internals/BaseHandlerOptions';
+import { AnyRouter, ProcedureType, inferRouterDef } from '../../core';
+import { TRPCError } from '../../error/TRPCError';
+import { BaseHandlerOptions } from '../../internals/types';
 import { TRPCResponse } from '../../rpc';
+import { Dict } from '../../types';
+import { ResponseMeta } from '../types';
 
 export type HTTPHeaders = Dict<string | string[]>;
 
@@ -26,9 +20,12 @@ export interface HTTPRequest {
   body: unknown;
 }
 
-type ResponseMetaFn<TRouter extends AnyRouter> = (opts: {
-  data: TRPCResponse<unknown, inferRouterError<TRouter>>[];
-  ctx?: inferRouterContext<TRouter>;
+/**
+ * @internal
+ */
+export type ResponseMetaFn<TRouter extends AnyRouter> = (opts: {
+  data: TRPCResponse<unknown, inferRouterDef<TRouter>['_error']>[];
+  ctx?: inferRouterDef<TRouter>['_ctx'];
   /**
    * The different tRPC paths requested
    **/

package/src/http/resolveHTTPResponse.ts

@@ -1,22 +1,21 @@
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
-import { Maybe } from '@trpc/server';
-import { callProcedure } from '../internals/callProcedure';
-import { getErrorFromUnknown } from '../internals/errors';
-import { transformTRPCResponse } from '../internals/transformTRPCResponse';
 import {
   AnyRouter,
+  ProcedureType,
   inferRouterContext,
   inferRouterError,
-  ProcedureType,
-} from '../router';
-import { TRPCErrorResponse, TRPCResponse, TRPCResultResponse } from '../rpc';
-import { TRPCError } from '../TRPCError';
+} from '../core';
+import { TRPCError } from '../error/TRPCError';
+import { getCauseFromUnknown, getErrorFromUnknown } from '../error/utils';
+import { transformTRPCResponse } from '../internals/transformTRPCResponse';
+import { TRPCResponse } from '../rpc';
+import { Maybe } from '../types';
 import { getHTTPStatusCode } from './internals/getHTTPStatusCode';
 import {
+  HTTPBaseHandlerOptions,
   HTTPHeaders,
   HTTPRequest,
   HTTPResponse,
-  HTTPBaseHandlerOptions,
 } from './internals/types';
 
 const HTTP_METHOD_PROCEDURE_TYPE_MAP: Record<
@@ -37,10 +36,10 @@ function getRawProcedureInputOrThrow(req: HTTPRequest) {
       return JSON.parse(raw!);
     }
     return typeof req.body === 'string' ? JSON.parse(req.body) : req.body;
-  } catch (cause) {
+  } catch (err) {
     throw new TRPCError({
       code: 'PARSE_ERROR',
-      cause,
+      cause: getCauseFromUnknown(err),
     });
   }
 }
@@ -170,14 +169,10 @@ export async function resolveHTTPResponse<
     const rawResults = await Promise.all(
       paths.map(async (path, index) => {
         const input = inputs[index];
+
         try {
-          const output = await callProcedure({
-            ctx,
-            router,
-            path,
-            input,
-            type,
-          });
+          const caller = router.createCaller(ctx);
+          const output = await caller[type](path, input as any);
           return {
             input,
             path,
@@ -196,12 +191,11 @@ export async function resolveHTTPResponse<
       }),
     );
     const errors = rawResults.flatMap((obj) => (obj.error ? [obj.error] : []));
-    const resultEnvelopes = rawResults.map((obj) => {
+    const resultEnvelopes = rawResults.map((obj): TRouterResponse => {
       const { path, input } = obj;
 
       if (obj.error) {
-        const json: TRPCErrorResponse<TRouterError> = {
-          id: null,
+        return {
           error: router.getErrorShape({
             error: obj.error,
             type,
@@ -210,16 +204,12 @@ export async function resolveHTTPResponse<
             ctx,
           }),
         };
-        return json;
       } else {
-        const json: TRPCResultResponse<unknown> = {
-          id: null,
+        return {
           result: {
-            type: 'data',
             data: obj.data,
           },
         };
-        return json;
       }
     });
 
@@ -233,16 +223,6 @@ export async function resolveHTTPResponse<
     // - input deserialization fails
     const error = getErrorFromUnknown(cause);
 
-    const json: TRPCErrorResponse<TRouterError> = {
-      id: null,
-      error: router.getErrorShape({
-        error,
-        type,
-        path: undefined,
-        input: undefined,
-        ctx,
-      }),
-    };
     onError?.({
       error,
       path: undefined,
@@ -251,6 +231,17 @@ export async function resolveHTTPResponse<
       type: type,
       req,
     });
-    return endResponse(json, [error]);
+    return endResponse(
+      {
+        error: router.getErrorShape({
+          error,
+          type,
+          path: undefined,
+          input: undefined,
+          ctx,
+        }),
+      },
+      [error],
+    );
   }
 }

package/src/index.ts

@@ -1,11 +1,7 @@
 export * from './assertNotBrowser';
 export * from './http';
-export * from './subscription';
 export * from './transformer';
-export * from './TRPCError';
+export * from './error/TRPCError';
 export * from './types';
-
-// deprecated
-export * from './deprecated/createHttpServer';
-export * from './deprecated/requestHandler';
-export * from './deprecated/LegacyRouter';
+export { router } from './deprecated/router';
+export * from './core';

package/src/internals/transformTRPCResponse.ts

@@ -1,33 +1,38 @@
-import { AnyRouter } from '../router';
-import { TRPCResponse } from '../rpc';
+import { AnyRouter } from '../core/router';
+import { TRPCResponse, TRPCResponseMessage } from '../rpc';
 
-function transformTRPCResponseItem(
-  router: AnyRouter,
-  item: TRPCResponse,
-): TRPCResponse {
+function transformTRPCResponseItem<
+  TResponseItem extends TRPCResponse | TRPCResponseMessage,
+>(router: AnyRouter, item: TResponseItem): TResponseItem {
   if ('error' in item) {
     return {
       ...item,
       error: router._def.transformer.output.serialize(item.error),
     };
   }
-  if (item.result.type !== 'data') {
-    return item;
+
+  if ('data' in item.result) {
+    return {
+      ...item,
+      result: {
+        ...item.result,
+        data: router._def.transformer.output.serialize(item.result.data),
+      },
+    };
   }
-  return {
-    ...item,
-    result: {
-      ...item.result,
-      data: router._def.transformer.output.serialize(item.result.data),
-    },
-  };
+
+  return item;
 }
 
 /**
  * Takes a unserialized `TRPCResponse` and serializes it with the router's transformers
  **/
 export function transformTRPCResponse<
-  TResponse extends TRPCResponse | TRPCResponse[],
+  TResponse extends
+    | TRPCResponse
+    | TRPCResponse[]
+    | TRPCResponseMessage
+    | TRPCResponseMessage[],
 >(router: AnyRouter, itemOrItems: TResponse) {
   return Array.isArray(itemOrItems)
     ? itemOrItems.map((item) => transformTRPCResponseItem(router, item))

package/src/internals/types.ts

@@ -0,0 +1,24 @@
+import { inferRouterDef } from '../core';
+import { ProcedureType } from '../core';
+import { AnyRouter } from '../core/router';
+import { TRPCError } from '../error/TRPCError';
+
+/**
+ * Base interface for any response handler
+ */
+export interface BaseHandlerOptions<TRouter extends AnyRouter, TRequest> {
+  onError?: OnErrorFunction<TRouter, TRequest>;
+  batching?: {
+    enabled: boolean;
+  };
+  router: TRouter;
+}
+
+export type OnErrorFunction<TRouter extends AnyRouter, TRequest> = (opts: {
+  error: TRPCError;
+  type: ProcedureType | 'unknown';
+  path: string | undefined;
+  req: TRequest;
+  input: unknown;
+  ctx: undefined | inferRouterDef<TRouter>['_ctx'];
+}) => void;

package/src/observable/index.ts

@@ -0,0 +1,4 @@
+export * from './observable';
+export * from './types';
+export * from './operators';
+export { observableToPromise } from './internals/observableToPromise';

package/src/observable/internals/identity.ts

@@ -0,0 +1,3 @@
+export function identity<T>(x: T): T {
+  return x;
+}

package/src/observable/internals/observableToPromise.ts

@@ -0,0 +1,49 @@
+import { Observable } from '../types';
+
+export 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 cancelled.'));
+      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/internals/pipe.ts

@@ -0,0 +1,22 @@
+import { UnaryFunction } from '../types';
+import { identity } from './identity';
+
+/** @internal */
+export function pipeFromArray<T, R>(
+  fns: Array<UnaryFunction<T, R>>,
+): UnaryFunction<T, R> {
+  if (fns.length === 0) {
+    return identity as UnaryFunction<any, any>;
+  }
+
+  if (fns.length === 1) {
+    return fns[0];
+  }
+
+  return function piped(input: T): R {
+    return fns.reduce(
+      (prev: any, fn: UnaryFunction<T, R>) => fn(prev),
+      input as any,
+    );
+  };
+}

package/src/observable/observable.test.ts

@@ -0,0 +1,101 @@
+/* eslint-disable @typescript-eslint/no-empty-function */
+import { observable, share, tap } from '.';
+
+test('vanilla observable - complete()', () => {
+  const obs = observable<number, Error>((observer) => {
+    observer.next(1);
+    observer.complete();
+  });
+
+  const next = jest.fn();
+  const error = jest.fn();
+  const complete = jest.fn();
+  obs.subscribe({
+    next,
+    error,
+    complete,
+  });
+  expect(next.mock.calls).toHaveLength(1);
+  expect(complete.mock.calls).toHaveLength(1);
+  expect(error.mock.calls).toHaveLength(0);
+  expect(next.mock.calls[0][0]).toBe(1);
+});
+
+test('vanilla observable - unsubscribe()', () => {
+  const obs$ = observable<number, Error>((observer) => {
+    observer.next(1);
+  });
+
+  const next = jest.fn();
+  const error = jest.fn();
+  const complete = jest.fn();
+  const sub = obs$.subscribe({
+    next,
+    error,
+    complete,
+  });
+  sub.unsubscribe();
+  expect(next.mock.calls).toHaveLength(1);
+  expect(complete.mock.calls).toHaveLength(0);
+  expect(error.mock.calls).toHaveLength(0);
+  expect(next.mock.calls[0][0]).toBe(1);
+});
+
+test('pipe - combine operators', () => {
+  const taps = {
+    next: jest.fn(),
+    complete: jest.fn(),
+    error: jest.fn(),
+  };
+  const obs = observable<number, Error>((observer) => {
+    observer.next(1);
+  }).pipe(
+    // operators:
+    share(),
+    tap(taps),
+  );
+  {
+    const next = jest.fn();
+    const error = jest.fn();
+    const complete = jest.fn();
+    obs.subscribe({
+      next,
+      error,
+      complete,
+    });
+    expect(next.mock.calls).toHaveLength(1);
+    expect(complete.mock.calls).toHaveLength(0);
+    expect(error.mock.calls).toHaveLength(0);
+    expect(next.mock.calls[0][0]).toBe(1);
+  }
+
+  {
+    const next = jest.fn();
+    const error = jest.fn();
+    const complete = jest.fn();
+    obs.subscribe({
+      next,
+      error,
+      complete,
+    });
+    expect(next.mock.calls).toHaveLength(0);
+    expect(complete.mock.calls).toHaveLength(0);
+    expect(error.mock.calls).toHaveLength(0);
+  }
+
+  expect({
+    next: taps.next.mock.calls,
+    error: taps.error.mock.calls,
+    complete: taps.complete.mock.calls,
+  }).toMatchInlineSnapshot(`
+    Object {
+      "complete": Array [],
+      "error": Array [],
+      "next": Array [
+        Array [
+          1,
+        ],
+      ],
+    }
+  `);
+});

package/src/observable/observable.ts

@@ -0,0 +1,78 @@
+import { pipeFromArray } from './internals/pipe';
+import { Observable, Observer, OperatorFunction, TeardownLogic } from './types';
+
+export type inferObservableValue<TObservable> = TObservable extends Observable<
+  infer TValue,
+  unknown
+>
+  ? TValue
+  : never;
+
+export function isObservable(x: unknown): x is Observable<unknown, unknown> {
+  return typeof x === 'object' && x !== null && 'subscribe' in x;
+}
+
+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;
+}

package/src/observable/operators/index.ts

@@ -0,0 +1,3 @@
+export * from './share';
+export * from './map';
+export * from './tap';