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

package/test/index.spec.ts

@@ -1,93 +1,77 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import AbortController from 'abort-controller';
 import fetch from 'node-fetch';
-import { UWebSocketsCreateContextOptions } from '../src/types';
+import { CreateContextOptions } from '../src/types';
 import uWs from 'uWebSockets.js';
 import z from 'zod';
-import * as trpc from '@trpc/server';
-import { inferAsyncReturnType, TRPCError } from '@trpc/server';
 import { createUWebSocketsHandler } from '../src/index';
-import { createTRPCClient, HTTPHeaders } from '@trpc/client';
+import {
+  createTRPCProxyClient,
+  httpBatchLink,
+  TRPCClientError,
+} from '@trpc/client';
+import { inferAsyncReturnType, initTRPC, TRPCError } from '@trpc/server';
 
 const testPort = 8799;
 
 function makeRouter() {
-  const router = trpc
-    .router<Context>()
-    .query('hello', {
-      input: z
-        .object({
-          who: z.string().nullish(),
-        })
-        .nullish(),
-      resolve({ input, ctx }) {
+  const t = initTRPC.context<Context>().create();
+
+  const router = t.router({
+    hello: t.procedure
+      .input(
+        z
+          .object({
+            who: z.string().nullish(),
+          })
+          .nullish()
+      )
+      .query(({ input, ctx }) => {
         return {
           text: `hello ${input?.who ?? ctx.user?.name ?? 'world'}`,
         };
-      },
-    })
-    .query('error', {
-      resolve() {
-        throw new TRPCError({
-          code: 'BAD_REQUEST',
-          message: 'error as expected',
-        });
-      },
-    })
-    .mutation('test', {
-      input: z.object({
-        value: z.string(),
       }),
-      resolve({ input, ctx }) {
+    error: t.procedure.query(() => {
+      throw new TRPCError({
+        code: 'BAD_REQUEST',
+        message: 'error as expected',
+      });
+    }),
+    test: t.procedure
+      .input(
+        z.object({
+          value: z.string(),
+        })
+      )
+      .mutation(({ input, ctx }) => {
         return {
           originalValue: input.value,
           user: ctx.user,
         };
-      },
-    })
-    .query('cookie-monster', {
-      resolve({ input, ctx }) {
-        const cookies = ctx.req.getCookies();
-
-        const combined = cookies['cookie1'] + cookies['cookie2'];
-        ctx.res.setCookie('one', 'nom');
-        ctx.res.setCookie('two', 'nom nom');
-        ctx.res.setHeader('x-spooked', 'true');
-        ctx.res.setStatus(201);
-        return {
-          combined,
-          user: ctx.user,
-        };
-      },
-    });
-
+      }),
+    manualRes: t.procedure.query(({ ctx }) => {
+      ctx.res.setStatus(400);
+      ctx.res.setHeader('manual', 'header');
+      return 'status 400';
+    }),
+  });
   return router;
 }
 export type Router = ReturnType<typeof makeRouter>;
 
 function makeContext() {
-  const createContext = ({
-    req,
-    res,
-    uWs,
-  }: UWebSocketsCreateContextOptions) => {
+  const createContext = ({ req, res }: CreateContextOptions) => {
     const getUser = () => {
       if (req.headers.authorization === 'meow') {
         return {
           name: 'KATT',
         };
       }
-      if (req.getCookies()?.user === 'romanzy')
-        return {
-          name: 'romanzy',
-        };
       return null;
     };
-
     return {
       req,
       res,
-      uWs,
+      // uWs,
       user: getUser(),
     };
   };
@@ -95,46 +79,25 @@ function makeContext() {
   return createContext;
 }
 export type Context = inferAsyncReturnType<ReturnType<typeof makeContext>>;
+
+// export type Context = inferAsyncReturnType<ReturnType<typeof makeContext>>;
 async function startServer() {
   const app = uWs.App();
 
-  // Handle CORS
-  app.options('/trpc/*', (res) => {
-    res.writeHeader('Access-Control-Allow-Origin', '*');
-    res.writeStatus('200 OK');
-    res.end();
-  });
-
-  app.get('/', (res) => {
-    res.writeStatus('200 OK');
-
-    res.end();
-  });
-
-  // need to register everything on the app object,
-  // as uWebSockets does not have middleware
   createUWebSocketsHandler(app, '/trpc', {
-    onRequest: (req, res) => {
-      // allows for prerequest handling
-      const origin = req.headers.origin ?? '*';
-      res.setHeader('Access-Control-Allow-Origin', origin);
+    responseMeta({ ctx, paths, type, errors }) {
+      return {
+        headers: {
+          hello: 'world',
+        },
+      };
     },
     router: makeRouter(),
     createContext: makeContext(),
   });
 
-  app.put('/trpc/put', (res) => {
-    res.writeStatus('204');
-    res.end();
-  });
-
-  app.any('/*', (res) => {
-    res.writeStatus('404 NOT FOUND');
-    res.end();
-  });
-
-  const { socket } = await new Promise<{
-    socket: uWs.us_listen_socket;
+  let { socket } = await new Promise<{
+    socket: uWs.us_listen_socket | any;
   }>((resolve) => {
     app.listen('0.0.0.0', testPort, (socket) => {
       resolve({
@@ -148,6 +111,7 @@ async function startServer() {
       new Promise<void>((resolve, reject) => {
         try {
           uWs.us_listen_socket_close(socket);
+          socket = null;
           resolve();
         } catch (error) {
           reject();
@@ -157,16 +121,28 @@ async function startServer() {
 }
 
 function makeClient(headers) {
-  return createTRPCClient<Router>({
-    url: `http://localhost:${testPort}/trpc`,
-
-    AbortController: AbortController as any,
-    fetch: fetch as any,
-    headers,
+  const client = createTRPCProxyClient<Router>({
+    links: [
+      httpBatchLink({
+        url: `http://localhost:${testPort}/trpc`,
+        fetch: fetch as any,
+        headers,
+      }),
+    ],
   });
+  return client;
+  // client.
+
+  // return createTRPCClient<Router>({
+  //   url: `http://localhost:${testPort}/trpc`,
+
+  //   AbortController: AbortController as any,
+  //   fetch: fetch as any,
+  //   headers,
+  // });
 }
 
-let t!: trpc.inferAsyncReturnType<typeof startServer>;
+let t!: Awaited<ReturnType<typeof startServer>>;
 beforeEach(async () => {
   t = await startServer();
 });
@@ -174,12 +150,13 @@ afterEach(async () => {
   await t.close();
 });
 
-test('simple query', async () => {
+test('query simple success and error handling', async () => {
   // t.client.runtime.headers = ()
   const client = makeClient({});
 
+  // client.
   expect(
-    await client.query('hello', {
+    await client.hello.query({
       who: 'test',
     })
   ).toMatchInlineSnapshot(`
@@ -188,16 +165,16 @@ test('simple query', async () => {
     }
   `);
 
-  expect(client.query('error', null)).rejects.toThrowError('error as expected');
+  await expect(client.error.query()).rejects.toThrowError('error as expected');
 });
 
-test('mutation with header', async () => {
+test('mutation and reading headers', async () => {
   const client = makeClient({
     authorization: 'meow',
   });
 
   expect(
-    await client.mutation('test', {
+    await client.test.mutate({
       value: 'lala',
     })
   ).toMatchInlineSnapshot(`
@@ -210,54 +187,38 @@ test('mutation with header', async () => {
   `);
 });
 
-// Error status codes are correct
-test('reads cookies', async () => {
-  const client = makeClient({
-    cookie: 'cookie1=abc; cookie2=d.e; user=romanzy',
-  });
-
-  expect(await client.query('cookie-monster')).toMatchInlineSnapshot(`
-    Object {
-      "combined": "abcd.e",
-      "user": Object {
-        "name": "romanzy",
-      },
-    }
-  `);
-});
-
-test('setting cookies and headers', async () => {
-  const monsterRes = await fetch(
-    `http://localhost:${testPort}/trpc/cookie-monster`
-  );
-  expect(monsterRes.status).toEqual(201);
-  expect(monsterRes.headers.get('set-cookie')).toEqual(
-    'one=nom, two=nom%20nom'
+test('manually sets status and headers', async () => {
+  const fetcher = await fetch(
+    `http://localhost:${testPort}/trpc/manualRes?input=${encodeURI('{}')}`
   );
-  expect(monsterRes.headers.get('x-spooked')).toEqual('true');
+  const body = await fetcher.json();
+  expect(fetcher.status).toEqual(400);
+  expect(body.result.data).toEqual('status 400');
+  expect(fetcher.headers.get('hello')).toEqual('world'); // from the meta
+  expect(fetcher.headers.get('manual')).toEqual('header'); //from the result
 });
 
-test('error handling', async () => {
-  const indexRes = await fetch(`http://localhost:${testPort}`);
-  expect(indexRes.status).toEqual(200);
-
-  const putRes = await fetch(`http://localhost:${testPort}/trpc/put`, {
-    method: 'PUT',
-  });
-  expect(putRes.status).toEqual(204);
-
-  const badInput = '{"who": "test';
-  const badRes = await fetch(
-    `http://localhost:${testPort}/trpc/hello?input=${badInput}`
-  );
-  expect(badRes.status).toEqual(400);
-
-  const badPath = await fetch(
-    `http://localhost:${testPort}/trpc/nonexisting?input=${badInput}`
-  );
-  expect(badPath.status).toEqual(400);
-
-  const uncaught = await fetch(`http://localhost:${testPort}/badurl`);
-
-  expect(uncaught.status).toEqual(404);
-});
+// this needs to be tested
+// test('abort works okay', async () => {
+//   const ac = new AbortController();
+//   const client = makeClient({});
+
+//   setTimeout(() => {
+//     ac.abort();
+//   }, 3);
+//   const res = await client.test.mutate(
+//     {
+//       value: 'haha',
+//     },
+//     {
+//       signal: ac.signal as any,
+//     }
+//   );
+
+//   expect(res).toMatchInlineSnapshot(`
+//     Object {
+//       "originalValue": "haha",
+//       "user": null,
+//     }
+// 	`);
+// });

package/types/index.d.ts

@@ -1,10 +1,9 @@
 import { AnyRouter } from '@trpc/server';
 import type { TemplatedApp } from 'uWebSockets.js';
-import { UWebSocketsCreateHandlerOptions } from './types';
-export * from './types';
+import { uHTTPHandlerOptions } 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 declare function createUWebSocketsHandler<TRouter extends AnyRouter>(uWsApp: TemplatedApp, pathPrefix: string, opts: UWebSocketsCreateHandlerOptions<TRouter>): void;
+export declare function createUWebSocketsHandler<TRouter extends AnyRouter>(uWsApp: TemplatedApp, prefix: string, opts: uHTTPHandlerOptions<TRouter>): void;

package/types/requestHandler.d.ts

@@ -0,0 +1,3 @@
+import { AnyRouter } from '@trpc/server';
+import { uHTTPRequestHandlerOptions } from './types';
+export declare function uWsHTTPRequestHandler<TRouter extends AnyRouter>(opts: uHTTPRequestHandlerOptions<TRouter>): Promise<void>;

package/types/types.d.ts

@@ -1,25 +1,23 @@
-import { AnyRouter, inferRouterContext } from '@trpc/server';
-import { TemplatedApp } from 'uWebSockets.js';
-import { CookieParseOptions, CookieSerializeOptions } from 'cookie';
-export declare type UWebSocketsCreateHandlerOptions<TRouter extends AnyRouter> = {
-    router: TRouter;
-    createContext?: (opts: UWebSocketsCreateContextOptions) => Promise<inferRouterContext<TRouter>> | inferRouterContext<TRouter>;
-    onRequest?: (req: UWebSocketsRequestObject, res: UWebSocketsResponseObject) => void;
-};
-export declare type UWebSocketsRequestObject = {
+import { HttpResponse } from 'uWebSockets.js';
+import { AnyRouter } from '@trpc/server';
+import { NodeHTTPCreateContextFnOptions, NodeHTTPCreateContextOption } from '@trpc/server/adapters/node-http';
+import { HTTPBaseHandlerOptions } from '@trpc/server/dist/http/internals/types';
+export declare type WrappedHTTPRequest = {
     headers: Record<string, string>;
     method: 'POST' | 'GET';
-    query: URLSearchParams;
-    path: string;
-    getCookies: (opts?: CookieParseOptions) => Record<string, string>;
+    query: string;
+    url: string;
 };
-export declare type UWebSocketsResponseObject = {
-    setCookie(key: string, value: string, opts?: CookieSerializeOptions): void;
+export declare type WrappedHTTPResponse = {
     setStatus(status: number): void;
     setHeader(key: string, value: string): void;
 };
-export declare type UWebSocketsCreateContextOptions = {
-    req: UWebSocketsRequestObject;
-    uWs: TemplatedApp;
-    res: UWebSocketsResponseObject;
-};
+export declare type uHTTPHandlerOptions<TRouter extends AnyRouter> = HTTPBaseHandlerOptions<TRouter, WrappedHTTPRequest> & {
+    maxBodySize?: number;
+} & NodeHTTPCreateContextOption<TRouter, WrappedHTTPRequest, WrappedHTTPResponse>;
+export declare type uHTTPRequestHandlerOptions<TRouter extends AnyRouter> = {
+    req: WrappedHTTPRequest;
+    uRes: HttpResponse;
+    path: string;
+} & uHTTPHandlerOptions<TRouter>;
+export declare type CreateContextOptions = NodeHTTPCreateContextFnOptions<WrappedHTTPRequest, WrappedHTTPResponse>;

package/types/utils.d.ts

@@ -1,11 +1,11 @@
-import { TRPCError } from '@trpc/server';
 import { HttpResponse } from 'uWebSockets.js';
-import { CookieParseOptions } from 'cookie';
-export declare const getCookieFn: (headers: Record<string, string>) => (opts?: CookieParseOptions) => Record<string, string>;
-export declare function readPostBody(method: string, res: HttpResponse): Promise<{
+import { WrappedHTTPRequest, WrappedHTTPResponse } from './types';
+import { AnyRouter, TRPCError } from '@trpc/server';
+export declare function getPostBody<TRouter extends AnyRouter, TRequest extends WrappedHTTPRequest, TResponse extends WrappedHTTPResponse>(method: any, res: HttpResponse, maxBodySize?: number): Promise<{
     ok: true;
     data: unknown;
 } | {
     ok: false;
     error: TRPCError;
 }>;
+export declare function sendResponse(res: HttpResponse, payload?: string): void;