@trpc/server 10.0.0-alpha.21 → 10.0.0-alpha.22

package/src/adapters/ws.ts

@@ -5,14 +5,14 @@ import { BaseHandlerOptions } from '../internals/BaseHandlerOptions';
 import { callProcedure } from '../internals/callProcedure';
 import { getCauseFromUnknown, getErrorFromUnknown } from '../internals/errors';
 import { transformTRPCResponse } from '../internals/transformTRPCResponse';
+import { Unsubscribable, isObservable } from '../observable';
 import { AnyRouter, ProcedureType, inferRouterContext } from '../router';
 import {
-  TRPCErrorResponse,
+  JSONRPC2,
+  TRPCClientOutgoingMessage,
   TRPCReconnectNotification,
-  TRPCRequest,
-  TRPCResponse,
+  TRPCResponseMessage,
 } from '../rpc';
-import { Subscription } from '../subscription';
 import { CombinedDataTransformer } from '../transformer';
 import { NodeHTTPCreateContextOption } from './node-http';
 
@@ -58,7 +58,7 @@ function assertIsJSONRPC2OrUndefined(
 function parseMessage(
   obj: unknown,
   transformer: CombinedDataTransformer,
-): TRPCRequest {
+): TRPCClientOutgoingMessage {
   assertIsObject(obj);
   const { method, params, id, jsonrpc } = obj;
   assertIsRequestId(id);
@@ -66,8 +66,8 @@ function parseMessage(
   if (method === 'subscription.stop') {
     return {
       id,
+      jsonrpc,
       method,
-      params: undefined,
     };
   }
   assertIsProcedureType(method);
@@ -76,7 +76,15 @@ function parseMessage(
   const { input: rawInput, path } = params;
   assertIsString(path);
   const input = transformer.input.deserialize(rawInput);
-  return { jsonrpc, id, method, params: { input, path } };
+  return {
+    id,
+    jsonrpc,
+    method,
+    params: {
+      input,
+      path,
+    },
+  };
 }
 
 /**
@@ -97,21 +105,34 @@ export function applyWSSHandler<TRouter extends AnyRouter>(
 
   const { transformer } = router._def;
   wss.on('connection', async (client, req) => {
-    const clientSubscriptions = new Map<
-      number | string,
-      Subscription<TRouter>
-    >();
+    const clientSubscriptions = new Map<number | string, Unsubscribable>();
 
-    function respond(untransformedJSON: TRPCResponse) {
+    function respond(untransformedJSON: TRPCResponseMessage) {
       client.send(
         JSON.stringify(transformTRPCResponse(router, untransformedJSON)),
       );
     }
+
+    function stopSubscription(
+      subscription: Unsubscribable,
+      { id, jsonrpc }: { id: JSONRPC2.RequestId } & JSONRPC2.BaseEnvelope,
+    ) {
+      subscription.unsubscribe();
+
+      respond({
+        id,
+        jsonrpc,
+        result: {
+          type: 'stopped',
+        },
+      });
+    }
+
     const ctxPromise = createContext?.({ req, res: client });
     let ctx: inferRouterContext<TRouter> | undefined = undefined;
 
-    async function handleRequest(msg: TRPCRequest) {
-      const { id } = msg;
+    async function handleRequest(msg: TRPCClientOutgoingMessage) {
+      const { id, jsonrpc } = msg;
       /* istanbul ignore next */
       if (id === null) {
         throw new TRPCError({
@@ -122,7 +143,7 @@ export function applyWSSHandler<TRouter extends AnyRouter>(
       if (msg.method === 'subscription.stop') {
         const sub = clientSubscriptions.get(id);
         if (sub) {
-          sub.destroy();
+          stopSubscription(sub, { id, jsonrpc });
         }
         clientSubscriptions.delete(id);
         return;
@@ -139,9 +160,18 @@ export function applyWSSHandler<TRouter extends AnyRouter>(
           ctx,
         });
 
-        if (!(result instanceof Subscription)) {
+        if (type === 'subscription') {
+          if (!isObservable(result)) {
+            throw new TRPCError({
+              message: `Subscription ${path} did not return an observable`,
+              code: 'INTERNAL_SERVER_ERROR',
+            });
+          }
+        } else {
+          // send the value as data if the method is not a subscription
           respond({
             id,
+            jsonrpc,
             result: {
               type: 'data',
               data: result,
@@ -150,75 +180,84 @@ export function applyWSSHandler<TRouter extends AnyRouter>(
           return;
         }
 
-        const sub = result;
+        const observable = result;
+        const sub = observable.subscribe({
+          next(data) {
+            respond({
+              id,
+              jsonrpc,
+              result: {
+                type: 'data',
+                data,
+              },
+            });
+          },
+          error(err) {
+            const error = getErrorFromUnknown(err);
+            opts.onError?.({ error, path, type, ctx, req, input });
+            respond({
+              id,
+              jsonrpc,
+              error: router.getErrorShape({
+                error,
+                type,
+                path,
+                input,
+                ctx,
+              }),
+            });
+          },
+          complete() {
+            respond({
+              id,
+              jsonrpc,
+              result: {
+                type: 'stopped',
+              },
+            });
+          },
+        });
         /* istanbul ignore next */
         if (client.readyState !== client.OPEN) {
           // if the client got disconnected whilst initializing the subscription
-          sub.destroy();
+          // no need to send stopped message if the client is disconnected
+          sub.unsubscribe();
           return;
         }
+
         /* istanbul ignore next */
         if (clientSubscriptions.has(id)) {
           // duplicate request ids for client
-          sub.destroy();
+          stopSubscription(sub, { id, jsonrpc });
           throw new TRPCError({
             message: `Duplicate id ${id}`,
             code: 'BAD_REQUEST',
           });
         }
         clientSubscriptions.set(id, sub);
-        sub.on('data', (data: unknown) => {
-          respond({
-            id,
-            result: {
-              type: 'data',
-              data,
-            },
-          });
-        });
-        sub.on('error', (_error: unknown) => {
-          const error = getErrorFromUnknown(_error);
-          const json: TRPCErrorResponse = {
-            id,
-            error: router.getErrorShape({
-              error,
-              type,
-              path,
-              input,
-              ctx,
-            }),
-          };
-          opts.onError?.({ error, path, type, ctx, req, input });
-          respond(json);
-        });
-        sub.on('destroy', () => {
-          respond({
-            id,
-            result: {
-              type: 'stopped',
-            },
-          });
-        });
 
         respond({
           id,
+          jsonrpc,
           result: {
             type: 'started',
           },
         });
-        await sub.start();
       } catch (cause) /* istanbul ignore next */ {
         // procedure threw an error
         const error = getErrorFromUnknown(cause);
-        const json = router.getErrorShape({
-          error,
-          type,
-          path,
-          input,
-          ctx,
-        });
         opts.onError?.({ error, path, type, ctx, req, input });
-        respond({ id, error: json });
+        respond({
+          id,
+          jsonrpc,
+          error: router.getErrorShape({
+            error,
+            type,
+            path,
+            input,
+            ctx,
+          }),
+        });
       }
     }
     client.on('message', async (message) => {
@@ -250,7 +289,7 @@ export function applyWSSHandler<TRouter extends AnyRouter>(
 
     client.once('close', () => {
       for (const sub of clientSubscriptions.values()) {
-        sub.destroy();
+        sub.unsubscribe();
       }
       clientSubscriptions.clear();
     });
@@ -259,7 +298,15 @@ export function applyWSSHandler<TRouter extends AnyRouter>(
         ctx = await ctxPromise;
       } catch (cause) {
         const error = getErrorFromUnknown(cause);
-        const json: TRPCErrorResponse = {
+        opts.onError?.({
+          error,
+          path: undefined,
+          type: 'unknown',
+          ctx,
+          req,
+          input: undefined,
+        });
+        respond({
           id: null,
           error: router.getErrorShape({
             error,
@@ -268,16 +315,7 @@ export function applyWSSHandler<TRouter extends AnyRouter>(
             input: undefined,
             ctx,
           }),
-        };
-        opts.onError?.({
-          error,
-          path: undefined,
-          type: 'unknown',
-          ctx,
-          req,
-          input: undefined,
         });
-        respond(json);
 
         // close in next tick
         (global.setImmediate ?? global.setTimeout)(() => {

package/src/http/resolveHTTPResponse.ts

@@ -9,7 +9,7 @@ import {
   inferRouterContext,
   inferRouterError,
 } from '../router';
-import { TRPCErrorResponse, TRPCResponse, TRPCResultResponse } from '../rpc';
+import { TRPCResponse } from '../rpc';
 import { Maybe } from '../types';
 import { getHTTPStatusCode } from './internals/getHTTPStatusCode';
 import {
@@ -196,12 +196,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 +209,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 +228,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 +236,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,6 +1,5 @@
 export * from './assertNotBrowser';
 export * from './http';
-export * from './subscription';
 export * from './transformer';
 export * from './TRPCError';
 export * from './types';

package/src/internals/callProcedure.ts

@@ -1,5 +1,5 @@
+import { Observable } from '../observable';
 import { AnyRouter, ProcedureType } from '../router';
-import { Subscription } from '../subscription';
 
 export async function callProcedure<
   TRouter extends AnyRouter<TContext>,
@@ -10,7 +10,7 @@ export async function callProcedure<
   router: TRouter;
   ctx: TContext;
   type: ProcedureType;
-}): Promise<unknown | Subscription<TRouter>> {
+}): Promise<unknown | Observable<TRouter, any>> {
   const { type, path, input } = opts;
 
   const caller = opts.router.createCaller(opts.ctx);
@@ -21,7 +21,10 @@ export async function callProcedure<
     return caller.mutation(path, input as any);
   }
   if (type === 'subscription') {
-    const sub = (await caller.subscription(path, input as any)) as Subscription;
+    const sub = (await caller.subscription(path, input as any)) as Observable<
+      any,
+      any
+    >;
     return sub;
   }
   /* istanbul ignore next */

package/src/internals/procedure.ts

@@ -2,9 +2,13 @@
 import { TRPCError } from '../TRPCError';
 import { assertNotBrowser } from '../assertNotBrowser';
 import { ProcedureType } from '../router';
+import { InferLast } from '../types';
 import { getCauseFromUnknown, getErrorFromUnknown } from './errors';
-import { MiddlewareFunction, middlewareMarker } from './middlewares';
-import { wrapCallSafe } from './wrapCallSafe';
+import {
+  MiddlewareFunction,
+  MiddlewareResult,
+  middlewareMarker,
+} from './middlewares';
 
 assertNotBrowser();
 
@@ -166,7 +170,7 @@ 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,
@@ -183,31 +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,
-            meta: this.meta,
-            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',
@@ -266,7 +279,7 @@ export type CreateProcedureWithInput<TContext, TMeta, TInput, TOutput> = {
   input: ProcedureParser<TInput>;
   output?: ProcedureParser<TOutput>;
   meta?: TMeta;
-  resolve: ProcedureResolver<TContext, TInput, TOutput>;
+  resolve: ProcedureResolver<TContext, TInput, InferLast<TOutput>>;
 };
 
 export type CreateProcedureWithInputOutputParser<
@@ -280,7 +293,7 @@ export type CreateProcedureWithInputOutputParser<
   input: ProcedureParserWithInputOutput<TInput, TParsedInput>;
   output?: ProcedureParserWithInputOutput<TOutput, TParsedOutput>;
   meta?: TMeta;
-  resolve: ProcedureResolver<TContext, TParsedInput, TOutput>;
+  resolve: ProcedureResolver<TContext, TParsedInput, InferLast<TOutput>>;
 };
 
 export type CreateProcedureWithoutInput<
@@ -293,7 +306,7 @@ export type CreateProcedureWithoutInput<
     | ProcedureParserWithInputOutput<TOutput, TParsedOutput>
     | ProcedureParser<TOutput>;
   meta?: TMeta;
-  resolve: ProcedureResolver<TContext, undefined, TOutput>;
+  resolve: ProcedureResolver<TContext, undefined, InferLast<TOutput>>;
 };
 
 export type CreateProcedureOptions<

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