@trpc/server 10.0.0-alpha.4 → 10.0.0-alpha.40

package/src/adapters/ws.ts

@@ -1,20 +1,22 @@
-import http from 'http';
+import { IncomingMessage } from 'http';
 import ws from 'ws';
-import { BaseHandlerOptions } from '../internals/BaseHandlerOptions';
-import { callProcedure } from '../internals/callProcedure';
-import { getErrorFromUnknown } from '../internals/errors';
+import { AnyRouter, ProcedureType, inferRouterContext } from '../core';
+import { TRPCError } from '../error/TRPCError';
+import { getCauseFromUnknown, getErrorFromUnknown } from '../error/utils';
 import { transformTRPCResponse } from '../internals/transformTRPCResponse';
-import { AnyRouter, inferRouterContext, ProcedureType } from '../router';
+import { BaseHandlerOptions } from '../internals/types';
+import { Unsubscribable, isObservable } from '../observable';
 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';
+import {
+  NodeHTTPCreateContextFnOptions,
+  NodeHTTPCreateContextOption,
+} from './node-http';
 
 /* istanbul ignore next */
 function assertIsObject(obj: unknown): asserts obj is Record<string, unknown> {
@@ -58,7 +60,7 @@ function assertIsJSONRPC2OrUndefined(
 function parseMessage(
   obj: unknown,
   transformer: CombinedDataTransformer,
-): TRPCRequest {
+): TRPCClientOutgoingMessage {
   assertIsObject(obj);
   const { method, params, id, jsonrpc } = obj;
   assertIsRequestId(id);
@@ -66,8 +68,8 @@ function parseMessage(
   if (method === 'subscription.stop') {
     return {
       id,
+      jsonrpc,
       method,
-      params: undefined,
     };
   }
   assertIsProcedureType(method);
@@ -76,7 +78,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 +94,16 @@ 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 type CreateWSSContextFnOptions = NodeHTTPCreateContextFnOptions<
+  IncomingMessage,
+  ws
+>;
 
 export function applyWSSHandler<TRouter extends AnyRouter>(
   opts: WSSHandlerOptions<TRouter>,
@@ -96,22 +111,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 +150,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;
@@ -131,17 +159,22 @@ export function applyWSSHandler<TRouter extends AnyRouter>(
       const type = msg.method;
       try {
         await ctxPromise; // asserts context has been set
-        const result = await callProcedure({
-          path,
-          input,
-          type,
-          router,
-          ctx,
-        });
 
-        if (!(result instanceof Subscription)) {
+        const caller = router.createCaller(ctx);
+        const result = await caller[type](path, input as any);
+
+        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 +183,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 +292,7 @@ export function applyWSSHandler<TRouter extends AnyRouter>(
 
     client.once('close', () => {
       for (const sub of clientSubscriptions.values()) {
-        sub.destroy();
+        sub.unsubscribe();
       }
       clientSubscriptions.clear();
     });
@@ -256,7 +301,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 +318,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 +326,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/core/index.ts

@@ -0,0 +1,6 @@
+export type { AnyRouter, ProcedureRouterRecord } from './router';
+export { callProcedure } from './router';
+export type { Procedure, ProcedureParams, ProcedureArgs } from './procedure';
+
+export { initTRPC } from './initTRPC';
+export * from './types';

package/src/core/initTRPC.ts

@@ -0,0 +1,95 @@
+/* eslint-disable @typescript-eslint/ban-types */
+import { mergeRoutersGeneric } from './internals/__generated__/mergeRoutersGeneric';
+import {
+  DefaultErrorShape,
+  ErrorFormatter,
+  ErrorFormatterShape,
+  defaultFormatter,
+} from '../error/formatter';
+import {
+  CombinedDataTransformer,
+  DataTransformerOptions,
+  DefaultDataTransformer,
+  defaultTransformer,
+  getDataTransformer,
+} from '../transformer';
+import {
+  CreateInitGenerics,
+  CreateRootConfig,
+  InitGenerics,
+  InitOptions,
+} from './internals/config';
+import { createBuilder } from './internals/procedureBuilder';
+import { PickFirstDefined, ValidateShape } from './internals/utils';
+import { createMiddlewareFactory } from './middleware';
+import { createRouterFactory } from './router';
+
+export function initTRPC<TParams extends Partial<InitGenerics> = {}>() {
+  type $Generics = CreateInitGenerics<{
+    ctx: TParams['ctx'] extends undefined ? {} : NonNullable<TParams['ctx']>;
+    meta: TParams['meta'] extends undefined ? {} : NonNullable<TParams['meta']>;
+  }>;
+
+  type $Context = $Generics['ctx'];
+  type $Meta = PickFirstDefined<$Generics['meta'], undefined>;
+  type $Options = Partial<InitOptions<$Generics>>;
+
+  return function initTRPCInner<TOptions extends $Options>(
+    options?: ValidateShape<TOptions, $Options>,
+  ) {
+    type $Formatter = PickFirstDefined<
+      TOptions['errorFormatter'],
+      ErrorFormatter<$Context, DefaultErrorShape>
+    >;
+    type $Transformer = TOptions['transformer'] extends DataTransformerOptions
+      ? TOptions['transformer'] extends DataTransformerOptions
+        ? CombinedDataTransformer
+        : DefaultDataTransformer
+      : DefaultDataTransformer;
+    type $ErrorShape = ErrorFormatterShape<$Formatter>;
+
+    type $Config = CreateRootConfig<{
+      ctx: $Context;
+      meta: $Meta;
+      errorShape: $ErrorShape;
+      transformer: $Transformer;
+    }>;
+
+    const errorFormatter = options?.errorFormatter ?? defaultFormatter;
+    const transformer = getDataTransformer(
+      options?.transformer ?? defaultTransformer,
+    ) as $Transformer;
+    const _config: $Config = {
+      transformer,
+      errorShape: null as any,
+      ctx: null as any,
+      meta: null as any,
+    };
+    return {
+      /**
+       * These are just types, they can't be used
+       * @internal
+       */
+      _config,
+      /**
+       * Builder object for creating procedures
+       */
+      procedure: createBuilder<$Config>(),
+      /**
+       * Create reusable middlewares
+       */
+      middleware: createMiddlewareFactory<$Config>(),
+      /**
+       * Create a router
+       */
+      router: createRouterFactory<$Config>({
+        errorFormatter,
+        transformer,
+      }),
+      /**
+       * Merge Routers
+       */
+      mergeRouters: mergeRoutersGeneric,
+    };
+  };
+}