@trpc/server 10.0.0-alpha.8 → 10.0.0-proxy-alpha.53

package/src/adapters/next.ts

@@ -1,9 +1,12 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-import type { NextApiHandler, NextApiRequest, NextApiResponse } from 'next';
-import { AnyRouter } from '../router';
-import { TRPCErrorResponse } from '../rpc';
-import { TRPCError } from '../TRPCError';
+import type {
+  NextApiHandler,
+  NextApiRequest,
+  NextApiResponse,
+} from 'next/types';
+import { AnyRouter } from '../core';
+import { TRPCError } from '../error/TRPCError';
 import { nodeHTTPRequestHandler } from './node-http';
 import {
   NodeHTTPCreateContextFnOptions,
@@ -42,12 +45,11 @@ export function createNextApiHandler<TRouter extends AnyRouter>(
         path: undefined,
         input: undefined,
       });
-      const json: TRPCErrorResponse = {
+      res.statusCode = 500;
+      res.json({
         id: -1,
         error,
-      };
-      res.statusCode = 500;
-      res.json(json);
+      });
       return;
     }
 

package/src/adapters/node-http/internals/getPostBody.test.ts

@@ -1,5 +1,6 @@
-import { getPostBody } from './getPostBody';
 import { EventEmitter } from 'events';
+import { getPostBody } from './getPostBody';
+
 test('has body', async () => {
   const body = {};
   const resolvedBody = await getPostBody({ req: { body } } as any);

package/src/adapters/node-http/internals/getPostBody.ts

@@ -1,4 +1,4 @@
-import { TRPCError } from '../../../TRPCError';
+import { TRPCError } from '../../../error/TRPCError';
 import { NodeHTTPRequest } from '../types';
 
 export async function getPostBody({

package/src/adapters/node-http/nodeHTTPRequestHandler.ts

@@ -1,15 +1,15 @@
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
-import { URLSearchParams } from 'url';
 import { assertNotBrowser } from '../../assertNotBrowser';
+import { AnyRouter } from '../../core';
+import { inferRouterDef } from '../../core/types';
+import { HTTPRequest } from '../../http/internals/types';
+import { resolveHTTPResponse } from '../../http/resolveHTTPResponse';
+import { getPostBody } from './internals/getPostBody';
 import {
+  NodeHTTPHandlerOptions,
   NodeHTTPRequest,
   NodeHTTPResponse,
-  NodeHTTPHandlerOptions,
 } from './types';
-import { AnyRouter, inferRouterContext } from '../../router';
-import { getPostBody } from './internals/getPostBody';
-import { HTTPRequest } from '../../http/internals/types';
-import { resolveHTTPResponse } from '../../http/resolveHTTPResponse';
 
 assertNotBrowser();
 
@@ -29,7 +29,7 @@ export async function nodeHTTPRequestHandler<
   TResponse extends NodeHTTPResponse,
 >(opts: NodeHTTPRequestHandlerOptions<TRouter, TRequest, TResponse>) {
   const createContext = async function _createContext(): Promise<
-    inferRouterContext<TRouter>
+    inferRouterDef<TRouter>['_ctx']
   > {
     return await opts.createContext?.(opts);
   };

package/src/adapters/node-http/types.ts

@@ -1,15 +1,17 @@
-import http from 'http';
-import qs from 'qs';
-import { inferRouterContext } from '../..';
+import { IncomingMessage, ServerResponse } from 'http';
+import { AnyRouter, inferRouterContext } from '../../core';
+import { inferRouterDef } from '../../core';
 import { HTTPBaseHandlerOptions } from '../../http/internals/types';
-import { AnyRouter } from '../../router';
 
-export type NodeHTTPRequest = http.IncomingMessage & {
-  method?: string;
-  query?: qs.ParsedQs;
+interface ParsedQs {
+  [key: string]: undefined | string | string[] | ParsedQs | ParsedQs[];
+}
+
+export type NodeHTTPRequest = IncomingMessage & {
+  query?: ParsedQs;
   body?: unknown;
 };
-export type NodeHTTPResponse = http.ServerResponse;
+export type NodeHTTPResponse = ServerResponse;
 
 export type NodeHTTPCreateContextOption<
   TRouter extends AnyRouter,
@@ -48,4 +50,4 @@ export type NodeHTTPCreateContextFn<
   TResponse,
 > = (
   opts: NodeHTTPCreateContextFnOptions<TRequest, TResponse>,
-) => inferRouterContext<TRouter> | Promise<inferRouterContext<TRouter>>;
+) => inferRouterDef<TRouter>['_ctx'] | Promise<inferRouterDef<TRouter>['_ctx']>;

package/src/adapters/standalone.ts

@@ -1,8 +1,8 @@
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
+
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import http from 'http';
-import url from 'url';
-import { AnyRouter } from '../router';
+import { AnyRouter } from '../core';
 import {
   NodeHTTPCreateContextFnOptions,
   NodeHTTPHandlerOptions,
@@ -21,12 +21,20 @@ export function createHTTPHandler<TRouter extends AnyRouter>(
   opts: CreateHTTPHandlerOptions<TRouter>,
 ) {
   return async (req: http.IncomingMessage, res: http.ServerResponse) => {
-    const endpoint = url.parse(req.url!).pathname!.substr(1);
+    // if no hostname, set a dummy one
+    const href = req.url!.startsWith('/')
+      ? `http://127.0.0.1${req.url}`
+      : req.url!;
+
+    // get procedure path and remove the leading slash
+    // /procedure -> procedure
+    const path = new URL(href).pathname.slice(1);
+
     await nodeHTTPRequestHandler({
       ...opts,
       req,
       res,
-      path: endpoint,
+      path,
     });
   };
 }

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({
@@ -245,9 +290,24 @@ export function applyWSSHandler<TRouter extends AnyRouter>(
       }
     });
 
+    // WebSocket errors should be handled, as otherwise unhandled exceptions will crash Node.js.
+    // This line was introduced after the following error brought down production systems:
+    // "RangeError: Invalid WebSocket frame: RSV2 and RSV3 must be clear"
+    // Here is the relevant discussion: https://github.com/websockets/ws/issues/1354#issuecomment-774616962
+    client.on('error', (cause) => {
+      opts.onError?.({
+        ctx,
+        error: getErrorFromUnknown(cause),
+        input: undefined,
+        path: undefined,
+        type: 'unknown',
+        req,
+      });
+    });
+
     client.once('close', () => {
       for (const sub of clientSubscriptions.values()) {
-        sub.destroy();
+        sub.unsubscribe();
       }
       clientSubscriptions.clear();
     });
@@ -256,7 +316,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 +333,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 +341,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,15 @@
+export type {
+  AnyRouter,
+  ProcedureRecord,
+  ProcedureRouterRecord,
+} from './router';
+export { callProcedure } from './router';
+export type {
+  Procedure,
+  ProcedureParams,
+  ProcedureArgs,
+  ProcedureOptions,
+} from './procedure';
+
+export { initTRPC } from './initTRPC';
+export * from './types';

package/src/core/initTRPC.ts

@@ -0,0 +1,94 @@
+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,
+    };
+  };
+}