trpc-uwebsockets 0.9.4 → 0.10.0-proxy-beta.8

package/src/index.ts

@@ -1,161 +1,56 @@
-import {
-  AnyRouter,
-  inferRouterContext,
-  resolveHTTPResponse,
-} from '@trpc/server';
-import { HTTPRequest } from '@trpc/server/dist/declarations/src/http/internals/types';
-import { CookieSerializeOptions } from 'cookie';
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { AnyRouter } from '@trpc/server';
+// import { HTTPRequest } from '@trpc/server/dist/index';
 import type { HttpRequest, HttpResponse, TemplatedApp } from 'uWebSockets.js';
+import { uWsHTTPRequestHandler } from './requestHandler';
+
 import {
-  UWebSocketsCreateHandlerOptions,
-  UWebSocketsRequestObject,
-  UWebSocketsResponseObject,
+  uHTTPHandlerOptions,
+  WrappedHTTPRequest,
+  WrappedHTTPResponse,
 } from './types';
-import { getCookieFn, readPostBody } from './utils';
-import cookie from 'cookie';
-export * from './types';
+
+// export * from './types';
 
 /**
  * @param uWsApp uWebsockets server instance
- * @param pathPrefix The path to trpc without trailing slash (ex: "/trpc")
+ * @param prefix The path to trpc without trailing slash (ex: "/trpc")
  * @param opts handler options
  */
 export function createUWebSocketsHandler<TRouter extends AnyRouter>(
   uWsApp: TemplatedApp,
-  pathPrefix: string,
-  opts: UWebSocketsCreateHandlerOptions<TRouter>
+  prefix: string,
+  opts: uHTTPHandlerOptions<TRouter>
 ) {
-  const prefixTrimLength = pathPrefix.length + 1; // remove /* from url
-
-  const handler = async (res: HttpResponse, req: HttpRequest) => {
-    const method = req.getMethod().toUpperCase();
-    if (method !== 'GET' && method !== 'POST') {
-      // handle only get and post requests, while the rest
-      // will not be captured and propagated further
-      req.setYield(true);
-      return;
-    }
+  const prefixTrimLength = prefix.length + 1; // remove /* from url
 
-    const path = req.getUrl().substring(prefixTrimLength);
-    const query = new URLSearchParams(decodeURIComponent(req.getQuery()));
+  const handler = (res: HttpResponse, req: HttpRequest) => {
+    const method = req.getMethod().toUpperCase() as 'GET' | 'POST';
+    const url = req.getUrl().substring(prefixTrimLength);
+    const query = req.getQuery();
 
     const headers: Record<string, string> = {};
     req.forEach((key, value) => {
+      // TODO handle headers with the same key, potential issue
       headers[key] = value;
     });
 
     // new request object needs to be created, because socket
     // can only be accessed synchronously, after await it cannot be accessed
-    const request: UWebSocketsRequestObject = {
+    const wrappedReq: WrappedHTTPRequest = {
       headers,
       method,
       query,
-      path,
-      getCookies: getCookieFn(headers),
-    };
-
-    const resOverride = {
-      headers: new Map<string, string>(),
-      cookies: [] as string[],
-      status: 0,
-    };
-
-    const response: UWebSocketsResponseObject = {
-      setCookie: (
-        name: string,
-        value: string,
-        opts?: CookieSerializeOptions
-      ) => {
-        const serialized = cookie.serialize(name, value, opts); //.substring(12); //remove the "Set-Cookie: "
-        resOverride.cookies.push(serialized);
-      },
-      setStatus: (status: number) => {
-        resOverride.status = status;
-      },
-      setHeader: (key: string, value: string) => {
-        resOverride.headers.set(key, value);
-      },
+      url,
     };
 
-    const bodyResult = await readPostBody(method, res);
-
-    // req is no longer available!
-
-    const createContext = async function _(): Promise<
-      inferRouterContext<TRouter>
-    > {
-      //res could be proxied here
-      return await opts.createContext?.({
-        uWs: uWsApp,
-        req: request,
-        res: response,
-      });
-    };
-
-    const internalReqObj: HTTPRequest = {
-      method,
-      headers,
-      query,
-      body: bodyResult.ok ? bodyResult.data : undefined,
-    };
-
-    // TODO batching, onError options need implementation.
-    const result = await resolveHTTPResponse({
-      path,
-      createContext,
-      router: opts.router,
-      req: internalReqObj,
-      error: bodyResult.ok ? null : bodyResult.error,
-    });
-
-    // user returned already, do nothing
-    res.cork(() => {
-      if (resOverride.status != 0) {
-        res.writeStatus(resOverride.status.toString());
-      } else if ('status' in result) {
-        res.writeStatus(result.status.toString());
-      } else {
-        // assume something went bad, should never happen?
-        throw new Error('No status to send');
-
-        // res.writeStatus('500 INTERNAL SERVER ERROR');
-        // res.end();
-        // return;
-      }
-
-      if (opts.onRequest) opts.onRequest(request, response);
-
-      //send all cookies
-      resOverride.cookies.forEach((value) => {
-        res.writeHeader('Set-Cookie', value);
-      });
-
-      resOverride.headers.forEach((value, key) => {
-        res.writeHeader(key, value);
-      });
-
-      for (const [key, value] of Object.entries(result.headers ?? {})) {
-        if (typeof value === 'undefined') {
-          continue;
-        }
-        // make sure to never override user defined headers
-        // cookies are an exception
-        if (resOverride.headers.has(key)) continue;
-
-        // not sure why it could be an array. This code path is not tested
-        // maybe its duplicates for the same key? like multiple "Set-Cookie"
-        if (Array.isArray(value))
-          value.forEach((header) => {
-            res.writeHeader(key, header);
-          });
-        else res.writeHeader(key, value);
-      }
-
-      //now send user headers
-      if (result.body) res.write(result.body);
-      res.end();
+    uWsHTTPRequestHandler({
+      req: wrappedReq,
+      uRes: res,
+      path: url,
+      ...opts,
     });
   };
-
-  uWsApp.any(pathPrefix + '/*', handler);
+  uWsApp.get(prefix + '/*', handler);
+  uWsApp.post(prefix + '/*', handler);
 }

package/src/requestHandler.ts

@@ -0,0 +1,99 @@
+import { AnyRouter, inferRouterDef, resolveHTTPResponse } from '@trpc/server';
+import { HTTPRequest } from '@trpc/server/dist/http/internals/types';
+import { getPostBody, sendResponse } from './utils';
+import { uHTTPRequestHandlerOptions, WrappedHTTPResponse } from './types';
+
+type HeaderSet = { name: string; value: string }; //in order to allow multiple of the same header (Set-Cookie) for example
+
+export async function uWsHTTPRequestHandler<TRouter extends AnyRouter>(
+  opts: uHTTPRequestHandlerOptions<TRouter>
+) {
+  const resOverride = {
+    headers: [] as HeaderSet[],
+    status: 0,
+  };
+
+  const wrappedRes: WrappedHTTPResponse = {
+    setStatus: (status: number) => {
+      resOverride.status = status;
+    },
+    setHeader: (name: string, value: string) => {
+      resOverride.headers.push({ name, value });
+      // resOverride.headers.set(key, value);
+    },
+  };
+
+  const createContext = async function _createContext(): Promise<
+    inferRouterDef<TRouter>['_ctx']
+  > {
+    return await opts.createContext?.({
+      req: opts.req,
+      res: wrappedRes,
+    });
+  };
+  const { path, router, uRes, req } = opts;
+  let aborted = false;
+  uRes.onAborted(() => {
+    // console.log('request was aborted');
+    aborted = true;
+  });
+
+  const bodyResult = await getPostBody(req.method, uRes, opts.maxBodySize);
+
+  const query = new URLSearchParams(opts.req.query);
+  const requestObj: HTTPRequest = {
+    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: requestObj,
+    error: bodyResult.ok ? null : bodyResult.error,
+    onError(o) {
+      opts?.onError?.({
+        ...o,
+        req: opts.req,
+      });
+    },
+  });
+
+  if (aborted) {
+    // TODO check this behavior
+    return;
+  }
+
+  uRes.cork(() => {
+    // if ('status' in result && (!res.statusCode || res.statusCode === 200)) {
+    if (resOverride.status > 0) {
+      uRes.writeStatus(resOverride.status.toString()); // TODO convert code to actual message
+    }
+    if ('status' in result) {
+      uRes.writeStatus(result.status.toString());
+    }
+
+    //send our manual headers
+    resOverride.headers.forEach((h) => {
+      uRes.writeHeader(h.name, h.value);
+    });
+
+    for (const [key, value] of Object.entries(result.headers ?? {})) {
+      if (typeof value === 'undefined') {
+        continue;
+      }
+      if (Array.isArray(value))
+        value.forEach((v) => {
+          uRes.writeHeader(key, v);
+        });
+      else uRes.writeHeader(key, value);
+    }
+
+    sendResponse(uRes, result.body);
+  });
+}

package/src/types.ts

@@ -1,38 +1,41 @@
-import { AnyRouter, inferRouterContext } from '@trpc/server';
 import { HttpRequest, HttpResponse, TemplatedApp } from 'uWebSockets.js';
-import { CookieParseOptions, CookieSerializeOptions } from 'cookie';
 
-export type UWebSocketsCreateHandlerOptions<TRouter extends AnyRouter> = {
-  /* trpc router */
-  router: TRouter;
-  /* optional create context */
-  createContext?: (
-    opts: UWebSocketsCreateContextOptions
-  ) => Promise<inferRouterContext<TRouter>> | inferRouterContext<TRouter>;
-  /* optional pre-request handler. Useful for dealing with CORS */
-  onRequest?: (
-    req: UWebSocketsRequestObject,
-    res: UWebSocketsResponseObject
-  ) => void;
-};
+import { AnyRouter } from '@trpc/server';
+import {
+  NodeHTTPCreateContextFnOptions,
+  NodeHTTPCreateContextOption,
+} from '@trpc/server/adapters/node-http';
+import { HTTPBaseHandlerOptions } from '@trpc/server/dist/http/internals/types';
 
-export type UWebSocketsRequestObject = {
+export type WrappedHTTPRequest = {
   headers: Record<string, string>;
   method: 'POST' | 'GET';
-  query: URLSearchParams;
-  path: string;
-  getCookies: (opts?: CookieParseOptions) => Record<string, string>;
+  query: string;
+  url: string;
 };
 
-// if this to be used, it needs to be proxied
-export type UWebSocketsResponseObject = {
-  setCookie(key: string, value: string, opts?: CookieSerializeOptions): void;
+export type WrappedHTTPResponse = {
   setStatus(status: number): void;
   setHeader(key: string, value: string): void;
 };
 
-export type UWebSocketsCreateContextOptions = {
-  req: UWebSocketsRequestObject;
-  uWs: TemplatedApp;
-  res: UWebSocketsResponseObject;
-};
+export type uHTTPHandlerOptions<TRouter extends AnyRouter> =
+  HTTPBaseHandlerOptions<TRouter, WrappedHTTPRequest> & {
+    maxBodySize?: number;
+  } & NodeHTTPCreateContextOption<
+      TRouter,
+      WrappedHTTPRequest,
+      WrappedHTTPResponse
+    >;
+
+export type uHTTPRequestHandlerOptions<TRouter extends AnyRouter> = {
+  req: WrappedHTTPRequest;
+  // res: WrappedHTTPResponse;
+  uRes: HttpResponse;
+  path: string;
+} & uHTTPHandlerOptions<TRouter>;
+
+export type CreateContextOptions = NodeHTTPCreateContextFnOptions<
+  WrappedHTTPRequest,
+  WrappedHTTPResponse
+>;

package/src/utils.ts

@@ -1,18 +1,17 @@
-import { TRPCError } from '@trpc/server';
 import { HttpResponse } from 'uWebSockets.js';
-import cookie, { CookieParseOptions } from 'cookie';
-/*
-cookie: 'cookie1=abc; cookie2=d.e'
-*/
 
-export const getCookieFn =
-  (headers: Record<string, string>) => (opts?: CookieParseOptions) => {
-    if (!('cookie' in headers)) return {};
+import {
+  WrappedHTTPRequest,
+  // uHTTPRequestHandlerOptions,
+  WrappedHTTPResponse,
+} from './types';
+import { AnyRouter, TRPCError } from '@trpc/server';
 
-    return cookie.parse(headers.cookie, opts);
-  };
-
-export function readPostBody(method: string, res: HttpResponse) {
+export function getPostBody<
+  TRouter extends AnyRouter,
+  TRequest extends WrappedHTTPRequest,
+  TResponse extends WrappedHTTPResponse
+>(method, res: HttpResponse, maxBodySize?: number) {
   return new Promise<
     { ok: true; data: unknown } | { ok: false; error: TRPCError }
   >((resolve) => {
@@ -38,8 +37,15 @@ export function readPostBody(method: string, res: HttpResponse) {
 
       const chunk = Buffer.from(ab);
 
-      //else accumulate
-      if (buffer) buffer = Buffer.concat([buffer, chunk]);
+      if (maxBodySize && buffer.length >= maxBodySize) {
+        resolve({
+          ok: false,
+          error: new TRPCError({ code: 'PAYLOAD_TOO_LARGE' }),
+        });
+      }
+      if (buffer)
+        //else accumulate
+        buffer = Buffer.concat([buffer, chunk]);
       else buffer = Buffer.concat([chunk]);
 
       if (isLast) {
@@ -58,3 +64,9 @@ export function readPostBody(method: string, res: HttpResponse) {
     });
   });
 }
+
+// FIXME buffer the output with tryEnd instead
+// https://github.com/uNetworking/uWebSockets.js/blob/master/examples/VideoStreamer.js
+export function sendResponse(res: HttpResponse, payload?: string) {
+  res.end(payload);
+}