@trpc/server 10.0.0-alpha.5 → 10.0.0-alpha.9

package/dist/{nodeHTTPRequestHandler-10e6d2f9.mjs → resolveHTTPResponse-9604d47d.mjs}

@@ -1,4 +1,3 @@
-import { URLSearchParams } from 'url';
 import { T as TRPCError, c as callProcedure, g as getErrorFromUnknown, t as transformTRPCResponse } from './transformTRPCResponse-76e0c91e.mjs';
 import { i as invert, T as TRPC_ERROR_CODES_BY_KEY } from './codes-7a3d4f65.mjs';
 
@@ -290,105 +289,4 @@ async function resolveHTTPResponse(opts) {
   }
 }
 
-async function getPostBody({
-  req,
-  maxBodySize
-}) {
-  return new Promise(resolve => {
-    if ('body' in req) {
-      resolve({
-        ok: true,
-        data: req.body
-      });
-      return;
-    }
-
-    let body = '';
-    let hasBody = false;
-    req.on('data', function (data) {
-      body += data;
-      hasBody = true;
-
-      if (typeof maxBodySize === 'number' && body.length > maxBodySize) {
-        resolve({
-          ok: false,
-          error: new TRPCError({
-            code: 'PAYLOAD_TOO_LARGE'
-          })
-        });
-        req.socket.destroy();
-      }
-    });
-    req.on('end', () => {
-      resolve({
-        ok: true,
-        data: hasBody ? body : undefined
-      });
-    });
-  });
-}
-
-/* eslint-disable @typescript-eslint/no-non-null-assertion */
-assertNotBrowser();
-async function nodeHTTPRequestHandler(opts) {
-  var _opts$teardown;
-
-  const createContext = async function _createContext() {
-    var _opts$createContext;
-
-    return await ((_opts$createContext = opts.createContext) === null || _opts$createContext === void 0 ? void 0 : _opts$createContext.call(opts, opts));
-  };
-
-  const {
-    path,
-    router
-  } = opts;
-  const bodyResult = await getPostBody(opts);
-  const query = opts.req.query ? new URLSearchParams(opts.req.query) : new URLSearchParams(opts.req.url.split('?')[1]);
-  const req = {
-    method: opts.req.method,
-    headers: opts.req.headers,
-    query,
-    body: bodyResult.ok ? bodyResult.data : undefined
-  };
-  const result = await resolveHTTPResponse({
-    batching: opts.batching,
-    responseMeta: opts.responseMeta,
-    path,
-    createContext,
-    router,
-    req,
-    error: bodyResult.ok ? null : bodyResult.error,
-
-    onError(o) {
-      var _opts$onError;
-
-      opts === null || opts === void 0 ? void 0 : (_opts$onError = opts.onError) === null || _opts$onError === void 0 ? void 0 : _opts$onError.call(opts, { ...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 = result.headers) !== null && _result$headers !== void 0 ? _result$headers : {})) {
-    var _result$headers;
-
-    if (typeof value === 'undefined') {
-      continue;
-    }
-
-    res.setHeader(key, value);
-  }
-
-  res.end(result.body);
-  await ((_opts$teardown = opts.teardown) === null || _opts$teardown === void 0 ? void 0 : _opts$teardown.call(opts));
-}
-
-export { assertNotBrowser as a, getHTTPStatusCodeFromError as g, nodeHTTPRequestHandler as n, resolveHTTPResponse as r };
+export { assertNotBrowser as a, getHTTPStatusCodeFromError as g, resolveHTTPResponse as r };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trpc/server",
-  "version": "10.0.0-alpha.5",
+  "version": "10.0.0-alpha.9",
   "description": "tRPC Server",
   "author": "KATT",
   "license": "MIT",
@@ -48,6 +48,11 @@
       "require": "./dist/adapters/standalone.js",
       "default": "./dist/adapters/standalone.js"
     },
+    "./adapters/fastify": {
+      "import": "./dist/adapters/fastify/index.mjs",
+      "require": "./dist/adapters/fastify/index.js",
+      "default": "./dist/adapters/fastify/index.js"
+    },
     "./adapters/ws": {
       "import": "./dist/adapters/ws.mjs",
       "require": "./dist/adapters/ws.js",
@@ -82,21 +87,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": "0e6a2445f0678e4886dee4896a70c2639fa6b55e",
+  "gitHead": "4d4ac63ab25a2b684ac61e905f9067aa201f8b0c",
   "dependencies": {
     "tslib": "^2.1.0"
   }

package/src/adapters/express.ts

@@ -16,7 +16,7 @@ export function createExpressMiddleware<TRouter extends AnyRouter>(
   opts: NodeHTTPHandlerOptions<TRouter, express.Request, express.Response>,
 ): express.Handler {
   return (req, res) => {
-    const endpoint = req.path.substr(1);
+    const endpoint = req.path.slice(1);
 
     nodeHTTPRequestHandler({
       ...opts,

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';

package/src/adapters/standalone.ts

@@ -21,7 +21,7 @@ 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);
+    const endpoint = url.parse(req.url!).pathname!.slice(1);
     await nodeHTTPRequestHandler({
       ...opts,
       req,