@trpc/server 9.18.0 → 9.19.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trpc/server",
-  "version": "9.18.0",
+  "version": "9.19.0",
   "description": "tRPC Server",
   "author": "KATT",
   "license": "MIT",
@@ -19,6 +19,7 @@
     "entrypoints": [
       "index.ts",
       "adapters/express.ts",
+      "adapters/fastify/index.ts",
       "adapters/next.ts",
       "adapters/node-http/index.ts",
       "adapters/standalone.ts",
@@ -51,21 +52,25 @@
     "@types/express": "^4.17.12",
     "@types/hash-sum": "^1.0.0",
     "@types/ws": "^8.2.0",
+    "abort-controller": "^3.0.0",
     "devalue": "^2.0.1",
     "express": "^4.17.1",
-    "fastify": "^3.17.0",
+    "fastify": "^3.27.1",
+    "fastify-plugin": "^3.0.1",
+    "fastify-websocket": "^4.0.0",
     "hash-sum": "^2.0.0",
     "jest": "^27.1.0",
     "konn": "^0.7.0",
     "myzod": "^1.3.1",
     "next": "^12.0.1",
+    "node-fetch": "^2.6.1",
     "superstruct": "^0.15.2",
     "typescript": "4.4.4",
     "ws": "^8.0.0",
     "yup": "^0.32.8",
     "zod": "^3.0.0"
   },
-  "gitHead": "e8468a50b289b0231cf1ee92d0f5195fe20c0d44",
+  "gitHead": "6eb1642a4a0aba9eb5fe4c1aa2648f5bdf65fcde",
   "dependencies": {
     "tslib": "^2.1.0"
   }

package/src/adapters/fastify/fastifyRequestHandler.ts

@@ -0,0 +1,79 @@
+import { URLSearchParams } from 'url';
+import { FastifyReply, FastifyRequest } from 'fastify';
+import { assertNotBrowser } from '../../assertNotBrowser';
+import { NodeHTTPCreateContextOption } from '../node-http';
+import { AnyRouter, inferRouterContext } from '../../router';
+import { resolveHTTPResponse } from '../../http/resolveHTTPResponse';
+import {
+  HTTPBaseHandlerOptions,
+  HTTPRequest,
+} from '../../http/internals/types';
+
+assertNotBrowser();
+
+export type FastifyHandlerOptions<
+  TRouter extends AnyRouter,
+  TRequest extends FastifyRequest,
+  TResponse extends FastifyReply,
+> = HTTPBaseHandlerOptions<TRouter, TRequest> &
+  NodeHTTPCreateContextOption<TRouter, TRequest, TResponse>;
+
+type FastifyRequestHandlerOptions<
+  TRouter extends AnyRouter,
+  TRequest extends FastifyRequest,
+  TResponse extends FastifyReply,
+> = {
+  req: TRequest;
+  res: TResponse;
+  path: string;
+} & FastifyHandlerOptions<TRouter, TRequest, TResponse>;
+
+export async function fastifyRequestHandler<
+  TRouter extends AnyRouter,
+  TRequest extends FastifyRequest,
+  TResponse extends FastifyReply,
+>(opts: FastifyRequestHandlerOptions<TRouter, TRequest, TResponse>) {
+  const createContext = async function _createContext(): Promise<
+    inferRouterContext<TRouter>
+  > {
+    return opts.createContext?.(opts);
+  };
+
+  const query = opts.req.query
+    ? new URLSearchParams(opts.req.query as any)
+    : new URLSearchParams(opts.req.url.split('?')[1]);
+
+  const req: HTTPRequest = {
+    query,
+    method: opts.req.method,
+    headers: opts.req.headers,
+    body: opts.req.body ?? 'null',
+  };
+
+  const result = await resolveHTTPResponse({
+    req,
+    createContext,
+    path: opts.path,
+    router: opts.router,
+    batching: opts.batching,
+    responseMeta: opts.responseMeta,
+    onError(o) {
+      opts?.onError?.({ ...o, req: opts.req });
+    },
+  });
+
+  const { res } = opts;
+
+  if ('status' in result && (!res.statusCode || res.statusCode === 200)) {
+    res.statusCode = result.status;
+  }
+
+  for (const [key, value] of Object.entries(result.headers ?? {})) {
+    if (typeof value === 'undefined') {
+      continue;
+    }
+    res.header(key, value);
+  }
+
+  res.send(result.body);
+}

package/src/adapters/fastify/fastifyTRPCPlugin.ts

@@ -0,0 +1,48 @@
+/// <reference types="fastify-websocket" />
+import { FastifyInstance, FastifyReply, FastifyRequest } from 'fastify';
+import { fastifyRequestHandler } from './fastifyRequestHandler';
+import { NodeHTTPCreateContextFnOptions } from '../node-http';
+import { applyWSSHandler, WSSHandlerOptions } from '../ws';
+import { FastifyHandlerOptions } from '.';
+import { AnyRouter } from '../..';
+
+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);
+    },
+  );
+
+  fastify.all(`${opts.prefix ?? ''}/:path`, (req, res) => {
+    const path = (req.params as any).path;
+    fastifyRequestHandler({ ...opts.trpcOptions, req, res, path });
+  });
+
+  if (opts.useWSS) {
+    applyWSSHandler<TRouter>({
+      ...(opts.trpcOptions as WSSHandlerOptions<TRouter>),
+      wss: fastify.websocketServer,
+    });
+    // eslint-disable-next-line @typescript-eslint/no-empty-function
+    fastify.get(opts.prefix ?? '/', { websocket: true }, () => {});
+  }
+
+  done();
+}

package/src/adapters/fastify/index.ts

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