@trpc/server 10.0.0-alpha.20 → 10.0.0-alpha.23

package/src/internals/procedure.ts

@@ -2,9 +2,13 @@
 import { TRPCError } from '../TRPCError';
 import { assertNotBrowser } from '../assertNotBrowser';
 import { ProcedureType } from '../router';
-import { getErrorFromUnknown } from './errors';
-import { MiddlewareFunction, middlewareMarker } from './middlewares';
-import { wrapCallSafe } from './wrapCallSafe';
+import { InferLast } from '../types';
+import { getCauseFromUnknown, getErrorFromUnknown } from './errors';
+import {
+  MiddlewareFunction,
+  MiddlewareResult,
+  middlewareMarker,
+} from './middlewares';
 
 assertNotBrowser();
 
@@ -44,11 +48,12 @@ export type ProcedureResolver<TContext, TInput, TOutput> = (opts: {
   type: ProcedureType;
 }) => Promise<TOutput> | TOutput;
 
-interface ProcedureOptions<TContext, TInput, TOutput, TParsedOutput> {
-  middlewares: Array<MiddlewareFunction<any, any>>;
+interface ProcedureOptions<TContext, TMeta, TInput, TOutput, TParsedOutput> {
+  middlewares: Array<MiddlewareFunction<any, any, any>>;
   resolver: ProcedureResolver<TContext, TInput, TOutput>;
   inputParser: ProcedureParser<TInput>;
   outputParser: ProcedureParser<TParsedOutput>;
+  meta: TMeta;
 }
 
 /**
@@ -100,21 +105,29 @@ function getParseFn<T>(procedureParser: ProcedureParser<T>): ParseFn<T> {
 export class Procedure<
   TInputContext,
   TContext,
+  TMeta,
   TInput,
   TParsedInput,
   TOutput,
   TParsedOutput,
   TFinalOutput = unknown extends TParsedOutput ? TOutput : TParsedOutput,
 > {
-  private middlewares: Readonly<Array<MiddlewareFunction<any, any>>>;
+  private middlewares: Readonly<Array<MiddlewareFunction<any, any, any>>>;
   private resolver: ProcedureResolver<TContext, TParsedInput, TOutput>;
   private readonly inputParser: ProcedureParser<TParsedInput>;
   private parseInputFn: ParseFn<TParsedInput>;
   private readonly outputParser: ProcedureParser<TFinalOutput>;
   private parseOutputFn: ParseFn<TFinalOutput>;
+  public readonly meta: TMeta;
 
   constructor(
-    opts: ProcedureOptions<TContext, TParsedInput, TOutput, TFinalOutput>,
+    opts: ProcedureOptions<
+      TContext,
+      TMeta,
+      TParsedInput,
+      TOutput,
+      TFinalOutput
+    >,
   ) {
     this.middlewares = opts.middlewares;
     this.resolver = opts.resolver;
@@ -122,6 +135,7 @@ export class Procedure<
     this.parseInputFn = getParseFn(this.inputParser);
     this.outputParser = opts.outputParser;
     this.parseOutputFn = getParseFn(this.outputParser);
+    this.meta = opts.meta;
   }
 
   private async parseInput(rawInput: unknown): Promise<TParsedInput> {
@@ -130,7 +144,7 @@ export class Procedure<
     } catch (cause) {
       throw new TRPCError({
         code: 'BAD_REQUEST',
-        cause,
+        cause: getCauseFromUnknown(cause),
       });
     }
   }
@@ -141,7 +155,7 @@ export class Procedure<
     } catch (cause) {
       throw new TRPCError({
         code: 'INTERNAL_SERVER_ERROR',
-        cause,
+        cause: getCauseFromUnknown(cause),
         message: 'Output validation failed',
       });
     }
@@ -156,9 +170,13 @@ export class Procedure<
   ): Promise<TFinalOutput> {
     // wrap the actual resolver and treat as the last "middleware"
     const middlewaresWithResolver = this.middlewares.concat([
-      async ({ ctx }: { ctx: TContext }) => {
+      async ({ ctx }: { ctx: any }) => {
         const input = await this.parseInput(opts.rawInput);
-        const rawOutput = await this.resolver({ ...opts, ctx, input });
+        const rawOutput = await this.resolver({
+          ...opts,
+          ctx,
+          input,
+        });
         const data = await this.parseOutput(rawOutput);
         return {
           marker: middlewareMarker,
@@ -169,30 +187,40 @@ export class Procedure<
       },
     ]);
 
-    // create `next()` calls in resolvers
-    const nextFns = middlewaresWithResolver.map((fn, index) => {
-      return async (nextOpts?: { ctx: TContext }) => {
-        const res = await wrapCallSafe(() =>
-          fn({
-            ctx: nextOpts ? nextOpts.ctx : opts.ctx,
-            type: opts.type,
-            path: opts.path,
-            rawInput: opts.rawInput,
-            next: nextFns[index + 1],
-          }),
-        );
-        if (res.ok) {
-          return res.data;
-        }
+    // run the middlewares recursively with the resolver as the last one
+    const callRecursive = async (
+      callOpts: { ctx: any; index: number } = {
+        index: 0,
+        ctx: opts.ctx,
+      },
+    ): Promise<MiddlewareResult<any>> => {
+      try {
+        const result = await middlewaresWithResolver[callOpts.index]({
+          ctx: callOpts.ctx,
+          type: opts.type,
+          path: opts.path,
+          rawInput: opts.rawInput,
+          meta: this.meta,
+          next: async (nextOpts?: { ctx: any }) => {
+            return await callRecursive({
+              index: callOpts.index + 1,
+              ctx: nextOpts ? nextOpts.ctx : callOpts.ctx,
+            });
+          },
+        });
+        return result;
+      } catch (cause) {
         return {
-          ok: false as const,
-          error: getErrorFromUnknown(res.error),
+          ctx: callOpts.ctx,
+          ok: false,
+          error: getErrorFromUnknown(cause),
+          marker: middlewareMarker,
         };
-      };
-    });
+      }
+    };
 
     // there's always at least one "next" since we wrap this.resolver in a middleware
-    const result = await nextFns[0]();
+    const result = await callRecursive();
     if (!result) {
       throw new TRPCError({
         code: 'INTERNAL_SERVER_ERROR',
@@ -213,14 +241,21 @@ export class Procedure<
    * @param middlewares
    */
   public inheritMiddlewares(
-    middlewares: MiddlewareFunction<TInputContext, TContext>[],
+    middlewares: MiddlewareFunction<TInputContext, TContext, TMeta>[],
   ): this {
     const Constructor: {
       new (
-        opts: ProcedureOptions<TContext, TParsedInput, TOutput, TFinalOutput>,
+        opts: ProcedureOptions<
+          TContext,
+          TMeta,
+          TParsedInput,
+          TOutput,
+          TFinalOutput
+        >,
       ): Procedure<
         TInputContext,
         TContext,
+        TMeta,
         TInput,
         TParsedInput,
         TOutput,
@@ -233,20 +268,23 @@ export class Procedure<
       resolver: this.resolver,
       inputParser: this.inputParser,
       outputParser: this.outputParser,
+      meta: this.meta,
     });
 
     return instance as any;
   }
 }
 
-export type CreateProcedureWithInput<TContext, TInput, TOutput> = {
+export type CreateProcedureWithInput<TContext, TMeta, TInput, TOutput> = {
   input: ProcedureParser<TInput>;
   output?: ProcedureParser<TOutput>;
-  resolve: ProcedureResolver<TContext, TInput, TOutput>;
+  meta?: TMeta;
+  resolve: ProcedureResolver<TContext, TInput, InferLast<TOutput>>;
 };
 
 export type CreateProcedureWithInputOutputParser<
   TContext,
+  TMeta,
   TInput,
   TParsedInput,
   TOutput,
@@ -254,18 +292,26 @@ export type CreateProcedureWithInputOutputParser<
 > = {
   input: ProcedureParserWithInputOutput<TInput, TParsedInput>;
   output?: ProcedureParserWithInputOutput<TOutput, TParsedOutput>;
-  resolve: ProcedureResolver<TContext, TParsedInput, TOutput>;
+  meta?: TMeta;
+  resolve: ProcedureResolver<TContext, TParsedInput, InferLast<TOutput>>;
 };
 
-export type CreateProcedureWithoutInput<TContext, TOutput, TParsedOutput> = {
+export type CreateProcedureWithoutInput<
+  TContext,
+  TMeta,
+  TOutput,
+  TParsedOutput,
+> = {
   output?:
     | ProcedureParserWithInputOutput<TOutput, TParsedOutput>
     | ProcedureParser<TOutput>;
-  resolve: ProcedureResolver<TContext, undefined, TOutput>;
+  meta?: TMeta;
+  resolve: ProcedureResolver<TContext, undefined, InferLast<TOutput>>;
 };
 
 export type CreateProcedureOptions<
   TContext,
+  TMeta = undefined,
   TInput = undefined,
   TParsedInput = undefined,
   TOutput = undefined,
@@ -273,16 +319,18 @@ export type CreateProcedureOptions<
 > =
   | CreateProcedureWithInputOutputParser<
       TContext,
+      TMeta,
       TInput,
       TParsedInput,
       TOutput,
       TParsedOutput
     >
-  | CreateProcedureWithInput<TContext, TInput, TOutput>
-  | CreateProcedureWithoutInput<TContext, TOutput, TParsedOutput>;
+  | CreateProcedureWithInput<TContext, TMeta, TInput, TOutput>
+  | CreateProcedureWithoutInput<TContext, TMeta, TOutput, TParsedOutput>;
 
 export function createProcedure<
   TContext,
+  TMeta,
   TInput,
   TParsedInput,
   TOutput,
@@ -290,12 +338,21 @@ export function createProcedure<
 >(
   opts: CreateProcedureOptions<
     TContext,
+    TMeta,
     TInput,
     TParsedInput,
     TOutput,
     TParsedOutput
   >,
-): Procedure<unknown, TContext, TInput, TParsedInput, TOutput, TParsedOutput> {
+): Procedure<
+  unknown,
+  TContext,
+  TMeta,
+  TInput,
+  TParsedInput,
+  TOutput,
+  TParsedOutput
+> {
   const inputParser =
     'input' in opts
       ? opts.input
@@ -319,14 +376,16 @@ export function createProcedure<
     resolver: opts.resolve as any,
     middlewares: [],
     outputParser: outputParser as any,
+    meta: opts.meta as any,
   });
 }
 
 export type inferProcedureFromOptions<
   TInputContext,
-  TOptions extends CreateProcedureOptions<any, any, any, any, any>,
+  TOptions extends CreateProcedureOptions<any, any, any, any, any, any>,
 > = TOptions extends CreateProcedureOptions<
   infer TContext,
+  infer TMeta,
   infer TInput,
   infer TParsedInput,
   infer TOutput,
@@ -335,6 +394,7 @@ export type inferProcedureFromOptions<
   ? Procedure<
       TInputContext,
       TContext,
+      TMeta,
       unknown extends TInput ? undefined : TInput,
       unknown extends TParsedInput ? undefined : TParsedInput,
       TOutput,

package/src/internals/transformTRPCResponse.ts

@@ -1,33 +1,38 @@
 import { AnyRouter } from '../router';
-import { TRPCResponse } from '../rpc';
+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/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,75 @@
+import { pipeFromArray } from './internals/pipe';
+import { Observable, Observer, OperatorFunction, TeardownLogic } from './types';
+
+export type inferObservableValue<
+  TObservable extends Observable<unknown, unknown>,
+> = 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';