@trpc/server 10.0.0-alpha.3 → 10.0.0-alpha.30

package/src/adapters/fastify/fastifyTRPCPlugin.ts

@@ -0,0 +1,56 @@
+/// <reference types="@fastify/websocket" />
+import { FastifyInstance, FastifyReply, FastifyRequest } from 'fastify';
+import { FastifyHandlerOptions } from '.';
+import { AnyRouter } from '../../core';
+import { NodeHTTPCreateContextFnOptions } from '../node-http';
+import { WSSHandlerOptions, applyWSSHandler } from '../ws';
+import { fastifyRequestHandler } from './fastifyRequestHandler';
+
+export interface FastifyTRPCPluginOptions<TRouter extends AnyRouter> {
+  prefix?: string;
+  useWSS?: boolean;
+  trpcOptions: FastifyHandlerOptions<TRouter, FastifyRequest, FastifyReply>;
+}
+
+export type CreateFastifyContextOptions = NodeHTTPCreateContextFnOptions<
+  FastifyRequest,
+  FastifyReply
+>;
+
+export function fastifyTRPCPlugin<TRouter extends AnyRouter>(
+  fastify: FastifyInstance,
+  opts: FastifyTRPCPluginOptions<TRouter>,
+  done: (err?: Error) => void,
+) {
+  fastify.addContentTypeParser(
+    'application/json',
+    { parseAs: 'string' },
+    function (_, body, _done) {
+      _done(null, body);
+    },
+  );
+
+  let prefix = opts.prefix ?? '';
+
+  // https://github.com/fastify/fastify-plugin/blob/fe079bef6557a83794bf437e14b9b9edb8a74104/plugin.js#L11
+  // @ts-expect-error property 'default' does not exists on type ...
+  if (typeof fastifyTRPCPlugin.default !== 'function') {
+    prefix = ''; // handled by fastify internally
+  }
+
+  fastify.all(`${prefix}/:path`, async (req, res) => {
+    const path = (req.params as any).path;
+    await fastifyRequestHandler({ ...opts.trpcOptions, req, res, path });
+  });
+
+  if (opts.useWSS) {
+    applyWSSHandler<TRouter>({
+      ...(opts.trpcOptions as unknown as WSSHandlerOptions<TRouter>),
+      wss: fastify.websocketServer,
+    });
+    // eslint-disable-next-line @typescript-eslint/no-empty-function
+    fastify.get(prefix ?? '/', { websocket: true }, () => {});
+  }
+
+  done();
+}

package/src/adapters/fastify/index.ts

@@ -0,0 +1,2 @@
+export * from './fastifyRequestHandler';
+export * from './fastifyTRPCPlugin';

package/src/adapters/fetch/fetchRequestHandler.ts

@@ -0,0 +1,61 @@
+import { assertNotBrowser } from '../../assertNotBrowser';
+import { AnyRouter } from '../../core';
+import { HTTPRequest } from '../../http/internals/types';
+import { resolveHTTPResponse } from '../../http/resolveHTTPResponse';
+import { FetchHandlerOptions } from './types';
+
+assertNotBrowser();
+
+export type FetchHandlerRequestOptions<TRouter extends AnyRouter> = {
+  req: Request;
+  endpoint: string;
+} & FetchHandlerOptions<TRouter>;
+
+export async function fetchRequestHandler<TRouter extends AnyRouter>(
+  opts: FetchHandlerRequestOptions<TRouter>,
+): Promise<Response> {
+  const createContext = async () => {
+    return opts.createContext?.({ req: opts.req });
+  };
+
+  const url = new URL(opts.req.url);
+  const path = url.pathname.slice(opts.endpoint.length + 1);
+  const req: HTTPRequest = {
+    query: url.searchParams,
+    method: opts.req.method,
+    headers: Object.fromEntries(opts.req.headers),
+    body: await opts.req.text(),
+  };
+
+  const result = await resolveHTTPResponse({
+    req,
+    createContext,
+    path,
+    router: opts.router,
+    batching: opts.batching,
+    responseMeta: opts.responseMeta,
+    onError(o) {
+      opts?.onError?.({ ...o, req: opts.req });
+    },
+  });
+
+  const res = new Response(result.body, {
+    status: result.status,
+  });
+
+  for (const [key, value] of Object.entries(result.headers ?? {})) {
+    if (typeof value === 'undefined') {
+      continue;
+    }
+
+    if (typeof value === 'string') {
+      res.headers.set(key, value);
+      continue;
+    }
+
+    for (const v of value) {
+      res.headers.append(key, v);
+    }
+  }
+  return res;
+}

package/src/adapters/fetch/index.ts

@@ -0,0 +1,2 @@
+export * from './fetchRequestHandler';
+export * from './types';

package/src/adapters/fetch/types.ts

@@ -0,0 +1,28 @@
+import { AnyRouter, inferRouterContext } from '../../core';
+import { HTTPBaseHandlerOptions } from '../../http/internals/types';
+
+export type FetchCreateContextFnOptions = {
+  req: Request;
+};
+
+export type FetchCreateContextFn<TRouter extends AnyRouter> = (opts: {
+  req: Request;
+}) => inferRouterContext<TRouter> | Promise<inferRouterContext<TRouter>>;
+
+export type FetchCreateContextOption<TRouter extends AnyRouter> =
+  unknown extends inferRouterContext<TRouter>
+    ? {
+        /**
+         * @link https://trpc.io/docs/context
+         **/
+        createContext?: FetchCreateContextFn<TRouter>;
+      }
+    : {
+        /**
+         * @link https://trpc.io/docs/context
+         **/
+        createContext: FetchCreateContextFn<TRouter>;
+      };
+
+export type FetchHandlerOptions<TRouter extends AnyRouter> =
+  HTTPBaseHandlerOptions<TRouter, Request> & FetchCreateContextOption<TRouter>;

package/src/adapters/lambda/index.ts

@@ -0,0 +1,18 @@
+import {
+  CreateAWSLambdaContextOptions,
+  awsLambdaRequestHandler,
+} from '../aws-lambda';
+import { APIGatewayEvent } from '../aws-lambda/utils';
+
+export * from '../aws-lambda';
+
+/**
+ * @deprecated use `aws-lambda` instead
+ */
+export type CreateLambdaContextOptions<T extends APIGatewayEvent> =
+  CreateAWSLambdaContextOptions<T>;
+
+/**
+ * @deprecated use `aws-lambda` instead
+ */
+export const lambdaRequestHandler = awsLambdaRequestHandler;

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({
@@ -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 {