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

package/src/adapters/ws.ts

@@ -1,19 +1,19 @@
-import http from 'http';
+import { IncomingMessage } from 'http';
 import ws from 'ws';
+import { TRPCError } from '../TRPCError';
 import { BaseHandlerOptions } from '../internals/BaseHandlerOptions';
 import { callProcedure } from '../internals/callProcedure';
-import { getErrorFromUnknown } from '../internals/errors';
+import { getCauseFromUnknown, getErrorFromUnknown } from '../internals/errors';
 import { transformTRPCResponse } from '../internals/transformTRPCResponse';
-import { AnyRouter, inferRouterContext, ProcedureType } from '../router';
+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 { TRPCError } from '../TRPCError';
 import { NodeHTTPCreateContextOption } from './node-http';
 
 /* istanbul ignore next */
@@ -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,
+    },
+  };
 }
 
 /**
@@ -84,11 +92,11 @@ function parseMessage(
  */
 export type WSSHandlerOptions<TRouter extends AnyRouter> = BaseHandlerOptions<
   TRouter,
-  http.IncomingMessage
+  IncomingMessage
 > & {
   wss: ws.Server;
   process?: NodeJS.Process;
-} & NodeHTTPCreateContextOption<TRouter, http.IncomingMessage, ws>;
+} & NodeHTTPCreateContextOption<TRouter, IncomingMessage, ws>;
 
 export function applyWSSHandler<TRouter extends AnyRouter>(
   opts: WSSHandlerOptions<TRouter>,
@@ -96,22 +104,35 @@ export function applyWSSHandler<TRouter extends AnyRouter>(
   const { wss, createContext, router } = opts;
 
   const { transformer } = router._def;
-  wss.on('connection', (client, req) => {
-    const clientSubscriptions = new Map<
-      number | string,
-      Subscription<TRouter>
-    >();
+  wss.on('connection', async (client, req) => {
+    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,86 +180,98 @@ 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) => {
       try {
         const msgJSON: unknown = JSON.parse(message.toString());
         const msgs: unknown[] = Array.isArray(msgJSON) ? msgJSON : [msgJSON];
-        msgs.map((raw) => parseMessage(raw, transformer)).map(handleRequest);
+        const promises = msgs
+          .map((raw) => parseMessage(raw, transformer))
+          .map(handleRequest);
+        await Promise.all(promises);
       } catch (cause) {
         const error = new TRPCError({
           code: 'PARSE_ERROR',
-          cause,
+          cause: getCauseFromUnknown(cause),
         });
 
         respond({
@@ -247,7 +289,7 @@ export function applyWSSHandler<TRouter extends AnyRouter>(
 
     client.once('close', () => {
       for (const sub of clientSubscriptions.values()) {
-        sub.destroy();
+        sub.unsubscribe();
       }
       clientSubscriptions.clear();
     });
@@ -256,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,
@@ -265,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)(() => {
@@ -282,7 +323,7 @@ export function applyWSSHandler<TRouter extends AnyRouter>(
         });
       }
     }
-    createContextAsync();
+    await createContextAsync();
   });
 
   return {

package/src/assertNotBrowser.ts

@@ -3,6 +3,7 @@
 export function assertNotBrowser() {
   if (
     typeof window !== 'undefined' &&
+    !('Deno' in window) &&
     process.env.NODE_ENV !== 'test' &&
     process.env.JEST_WORKER_ID === undefined
   ) {

package/src/http/internals/getHTTPStatusCode.ts

@@ -1,6 +1,6 @@
-import { TRPCResponse, TRPC_ERROR_CODES_BY_KEY } from '../../rpc';
 import { TRPCError } from '../../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,14 @@
+import { TRPCError } from '../../TRPCError';
+import { BaseHandlerOptions } from '../../internals/BaseHandlerOptions';
 import {
   AnyRouter,
-  Dict,
+  ProcedureType,
   inferRouterContext,
   inferRouterError,
-  ProcedureType,
-  ResponseMeta,
-  TRPCError,
-} from '@trpc/server';
-import { URLSearchParams } from 'url';
-import { BaseHandlerOptions } from '../../internals/BaseHandlerOptions';
+} from '../../router';
 import { TRPCResponse } from '../../rpc';
+import { Dict } from '../../types';
+import { ResponseMeta } from '../ResponseMeta';
 
 export type HTTPHeaders = Dict<string | string[]>;
 

package/src/http/resolveHTTPResponse.ts

@@ -1,22 +1,22 @@
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
-import { Maybe } from '@trpc/server';
+import { TRPCError } from '../TRPCError';
 import { callProcedure } from '../internals/callProcedure';
-import { getErrorFromUnknown } from '../internals/errors';
+import { getCauseFromUnknown, 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';
+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 +37,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),
     });
   }
 }
@@ -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,11 +1,6 @@
 export * from './assertNotBrowser';
 export * from './http';
-export * from './subscription';
 export * from './transformer';
 export * from './TRPCError';
 export * from './types';
-
-// deprecated
-export * from './deprecated/createHttpServer';
-export * from './deprecated/requestHandler';
-export * from './deprecated/LegacyRouter';
+export * from './router';

package/src/internals/BaseHandlerOptions.ts

@@ -1,5 +1,5 @@
-import { OnErrorFunction } from './OnErrorFunction';
 import { AnyRouter } from '../router';
+import { OnErrorFunction } from './OnErrorFunction';
 
 /**
  * Base interface for any response handler

package/src/internals/OnErrorFunction.ts

@@ -1,5 +1,5 @@
-import { AnyRouter, inferRouterContext, ProcedureType } from '../router';
 import { TRPCError } from '../TRPCError';
+import { AnyRouter, ProcedureType, inferRouterContext } from '../router';
 
 export type OnErrorFunction<TRouter extends AnyRouter, TRequest> = (opts: {
   error: TRPCError;

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/errors.ts

@@ -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/internals/middlewares.ts

@@ -1,5 +1,5 @@
-import { ProcedureType } from '../router';
 import { TRPCError } from '../TRPCError';
+import { ProcedureType } from '../router';
 
 export const middlewareMarker = Symbol('middlewareMarker');
 interface MiddlewareResultBase<TContext> {
@@ -27,11 +27,12 @@ export type MiddlewareResult<TContext> =
   | MiddlewareOKResult<TContext>
   | MiddlewareErrorResult<TContext>;
 
-export type MiddlewareFunction<TInputContext, TContext> = (opts: {
+export type MiddlewareFunction<TInputContext, TContext, TMeta> = (opts: {
   ctx: TInputContext;
   type: ProcedureType;
   path: string;
   rawInput: unknown;
+  meta?: TMeta;
   next: {
     (): Promise<MiddlewareResult<TInputContext>>;
     <T>(opts: { ctx: T }): Promise<MiddlewareResult<T>>;