@lowerdeck/rpc-server 1.0.0

package/src/rpcMux.ts

@@ -0,0 +1,303 @@
+import {
+  internalServerError,
+  notAcceptableError,
+  notFoundError,
+  validationError
+} from '@lowerdeck/error';
+import { createExecutionContext, provideExecutionContext } from '@lowerdeck/execution-context';
+import { generateCustomId } from '@lowerdeck/id';
+import { memo } from '@lowerdeck/memo';
+import { getSentry } from '@lowerdeck/sentry';
+import { serialize } from '@lowerdeck/serialize';
+import { v } from '@lowerdeck/validation';
+import * as Cookie from 'cookie';
+import { ServiceRequest } from './controller';
+import { parseForwardedFor } from './extractIp';
+
+let Sentry = getSentry();
+
+let validation = v.object({
+  calls: v.array(
+    v.object({
+      id: v.string(),
+      name: v.string(),
+      payload: v.any()
+    })
+  )
+});
+
+export let rpcMux = (
+  opts: {
+    path: string;
+    cors?: {
+      headers?: string[];
+    } & ({ domains: string[] } | { check: (origin: string) => boolean });
+  },
+  rpcs: {
+    handlerNames: string[];
+    runMany: (
+      req: ServiceRequest,
+      body: {
+        requestId: string;
+        calls: {
+          id: string;
+          name: string;
+          payload: any;
+        }[];
+      }
+    ) => Promise<{
+      status: number;
+      body: {
+        calls: any[];
+      };
+    }>;
+  }[]
+) => {
+  let handlerNameToRpcMap = new Map<string, number>(
+    rpcs.flatMap((rpc, i) => rpc.handlerNames.map(name => [name, i]))
+  );
+
+  return {
+    path: opts.path,
+
+    fetch: async (req: any): Promise<any> => {
+      let origin = req.headers.get('origin') ?? '';
+      let corsOk = false;
+
+      if (opts.cors && 'domains' in opts.cors) {
+        try {
+          let url = new URL(origin);
+          let rootDomain = url.hostname.split('.').slice(-2).join('.');
+          corsOk = opts.cors.domains.includes(rootDomain);
+        } catch (e) {
+          // Ignore -> no cors
+        }
+      } else if (opts.cors && 'check' in opts.cors) {
+        corsOk = opts.cors.check(origin);
+      }
+
+      let url = new URL(req.url);
+
+      let additionalCorsHeaders = opts.cors?.headers?.join(', ');
+      if (additionalCorsHeaders) additionalCorsHeaders = `, ${additionalCorsHeaders}`.trim();
+
+      let corsHeaders: Record<string, string> = corsOk
+        ? {
+            'access-control-allow-origin': origin,
+            'access-control-allow-methods': 'POST, OPTIONS',
+            'access-control-allow-headers': `Content-Type, Authorization, Baggage, Sentry-Trace${
+              additionalCorsHeaders ?? ''
+            }`,
+            'access-control-max-age': '604800',
+            'access-control-allow-credentials': 'true'
+          }
+        : {};
+
+      if (req.method == 'OPTIONS') {
+        if (corsOk) {
+          return new Response(null, {
+            status: 204,
+            headers: corsHeaders
+          });
+        }
+
+        return new Response(null, { status: 403 });
+      }
+
+      let body: any = null;
+
+      try {
+        body = serialize.decode(await req.text());
+      } catch (e) {
+        return new Response(
+          JSON.stringify(notAcceptableError({ message: 'Invalid JSON' }).toResponse()),
+          { status: 406 }
+        );
+      }
+
+      let sentryTraceHeaders = req.headers.get('sentry-trace');
+      let sentryTrace =
+        (Array.isArray(sentryTraceHeaders)
+          ? sentryTraceHeaders.join(',')
+          : sentryTraceHeaders) ?? undefined;
+      let baggage = req.headers.get('baggage');
+
+      let ip = parseForwardedFor(
+        req.headers.get('lowerdeck-connecting-ip') ??
+          req.headers.get('cf-connecting-ip') ??
+          req.headers.get('x-forwarded-for') ??
+          req.headers.get('x-real-ip')
+      );
+
+      let headers = new Headers();
+
+      if (corsOk) {
+        for (let [key, value] of Object.entries(corsHeaders)) {
+          headers.append(key, value);
+        }
+      }
+
+      return await Sentry.withIsolationScope(
+        async () =>
+          await Sentry.continueTrace(
+            { sentryTrace, baggage },
+            async () =>
+              await Sentry.startSpan(
+                {
+                  name: 'rpc request',
+                  op: 'rpc.server',
+                  attributes: {
+                    ip,
+                    transport: 'http',
+                    ua: req.headers.get('user-agent') ?? '',
+                    origin: req.headers.get('origin') ?? ''
+                  }
+                },
+                async () => {
+                  try {
+                    let beforeSends: Array<() => Promise<any>> = [];
+                    let id = generateCustomId('req_');
+
+                    let parseCookies = memo(() =>
+                      Cookie.parse(req.headers.get('cookie') ?? '')
+                    );
+
+                    let request: ServiceRequest = {
+                      url: req.url,
+                      headers: req.headers,
+                      query: url.searchParams,
+                      body,
+                      rawBody: body,
+                      ip,
+                      requestId: id,
+
+                      getCookies: () => parseCookies(),
+                      getCookie: (name: string) => parseCookies()[name],
+                      setCookie: (name: string, value: string, opts?: any) => {
+                        let cookie = Cookie.serialize(name, value, opts);
+                        // @ts-ignore
+                        headers.append('Set-Cookie', cookie);
+                      },
+
+                      beforeSend: (handler: () => Promise<any>) => {
+                        beforeSends.push(handler);
+                      },
+
+                      sharedMiddlewareMemo: new Map<string, Promise<any>>(),
+
+                      appendHeaders: (newHeaders: Record<string, string | string[]>) => {
+                        for (let [key, value] of Object.entries(newHeaders)) {
+                          if (Array.isArray(value)) {
+                            for (let v of value) headers.append(key, v);
+                          } else {
+                            headers.append(key, value);
+                          }
+                        }
+                      }
+                    };
+
+                    Sentry.getCurrentScope().setContext('rpc.request', {
+                      url: req.url,
+                      query: Object.fromEntries(url.searchParams.entries())
+                    });
+
+                    Sentry.getCurrentScope().addAttachment({
+                      filename: 'rpc.request.body.json',
+                      data: body,
+                      contentType: 'application/json'
+                    });
+
+                    let valRes = validation.validate(body);
+                    if (!valRes.success) {
+                      return new Response(
+                        JSON.stringify(
+                          validationError({
+                            errors: valRes.errors,
+                            entity: 'request_data'
+                          }).toResponse()
+                        ),
+                        { status: 406, headers }
+                      );
+                    }
+
+                    return provideExecutionContext(
+                      createExecutionContext({
+                        type: 'request',
+                        contextId: id,
+                        ip: ip ?? '0.0.0.0',
+                        userAgent: req.headers.get('user-agent') ?? ''
+                      }),
+                      async () => {
+                        let callsByRpc = new Map<
+                          number,
+                          { id: string; name: string; payload: any }[]
+                        >();
+
+                        for (let call of body.calls) {
+                          let rpcIndex = handlerNameToRpcMap.get(call.name);
+                          if (rpcIndex == undefined) {
+                            return new Response(
+                              JSON.stringify(
+                                notFoundError({ entity: 'handler' }).toResponse()
+                              ),
+                              { status: 404, headers }
+                            );
+                          }
+
+                          let calls = callsByRpc.get(rpcIndex) ?? [];
+                          calls.push(call);
+                          callsByRpc.set(rpcIndex, calls);
+                        }
+
+                        // let res = await runMany(request);
+
+                        let resRef = {
+                          body: {
+                            __typename: 'rpc.response',
+                            calls: [] as any[]
+                          },
+                          status: 200
+                        };
+
+                        await Promise.all(
+                          Array.from(callsByRpc.entries()).map(async ([rpcIndex, calls]) => {
+                            let rpc = rpcs[rpcIndex];
+                            let res = await rpc.runMany(request, {
+                              requestId: id,
+                              calls
+                            });
+
+                            resRef.status = Math.max(resRef.status, res.status);
+                            resRef.body.calls.push(...res.body.calls);
+                          })
+                        );
+
+                        headers.append('x-req-id', id);
+                        headers.append('content-type', 'application/rpc+json');
+                        headers.append('x-powered-by', 'lowerdeck RPC');
+
+                        await Promise.all(beforeSends.map(s => s()));
+
+                        return new Response(serialize.encode(resRef.body), {
+                          status: resRef.status,
+                          headers
+                        });
+                      }
+                    );
+                  } catch (e) {
+                    console.error(e);
+
+                    Sentry.captureException(e);
+
+                    return new Response(JSON.stringify(internalServerError().toResponse()), {
+                      status: 500,
+                      headers
+                    });
+                  }
+                }
+              )
+          )
+      );
+    }
+  };
+};

package/src/server.ts

@@ -0,0 +1,204 @@
+import { internalServerError, isServiceError, notFoundError } from '@lowerdeck/error';
+import { getSentry } from '@lowerdeck/sentry';
+import { Controller, Handler, ServiceRequest } from './controller';
+
+let Sentry = getSentry();
+
+export let createServer =
+  (opts: {
+    onError?: (opts: {
+      request: ServiceRequest;
+      error: any;
+      reqId: string;
+      callId: string;
+      callName: string;
+    }) => void;
+    onRequest?: (opts: {
+      reqId: string;
+      callId: string;
+      callName: string;
+      request: ServiceRequest;
+      response: { status: number; body: any };
+    }) => void;
+  }) =>
+  (controller: Controller<any>) => {
+    let findHandler = (name: string): Handler<any, any, any> | null => {
+      let parts = name.split(':');
+      let current = controller;
+
+      while (current && parts.length > 0) {
+        current = current[parts.shift()!];
+        if (!current) return null;
+      }
+
+      if (current && current instanceof Handler) return current;
+
+      return null;
+    };
+
+    let getSupportedHandlerNames = (controller: Controller<any>): string[] =>
+      Object.entries(controller).flatMap(([key, value]) => {
+        if (value instanceof Handler) return [key];
+        if (typeof value == 'object')
+          return getSupportedHandlerNames(value).map(name => `${key}:${name}`);
+        return [];
+      });
+
+    let handlerNames = getSupportedHandlerNames(controller);
+
+    let run = async (
+      req: ServiceRequest,
+      call: { id: string; name: string; payload: any },
+      reqId: string
+    ): Promise<{
+      response: any;
+      status: number;
+      request: ServiceRequest;
+    }> => {
+      let request = { ...req, body: call.payload };
+
+      try {
+        let handler = findHandler(call.name);
+
+        if (!handler) {
+          return {
+            request,
+            status: 404,
+            response: notFoundError({ entity: 'handler' }).toResponse()
+          };
+        }
+
+        let response = await handler.run(request, {});
+
+        return {
+          status: 200,
+          request: req,
+          response: response.response
+        };
+      } catch (e) {
+        console.error(e);
+
+        if (isServiceError(e)) {
+          if (e.data.status >= 500) {
+            Sentry.captureException(e, {
+              tags: { reqId }
+            });
+          }
+
+          return {
+            request,
+            status: e.data.status,
+            response: e.toResponse()
+          };
+        }
+
+        Sentry.captureException(e, {
+          tags: { reqId }
+        });
+
+        opts.onError?.({
+          callName: call.name,
+          callId: call.id,
+          request: req,
+          error: e,
+          reqId
+        });
+
+        return {
+          request,
+          status: 500,
+          response: internalServerError().toResponse()
+        };
+      }
+    };
+
+    let runMany = async (
+      req: ServiceRequest,
+      body: {
+        calls: {
+          id: string;
+          name: string;
+          payload: any;
+        }[];
+        requestId: string;
+      }
+    ): Promise<{
+      status: number;
+      body: any;
+    }> => {
+      let callRes = await Promise.all(
+        body.calls.map(async (call, i) => {
+          let res = await run(req, call as any, body.requestId);
+
+          try {
+            opts.onRequest?.({
+              reqId: body.requestId,
+              callId: call.id,
+              callName: call.name,
+              request: res.request,
+              response: { status: res.status, body: res.response }
+            });
+          } catch (e) {
+            Sentry.captureException(e);
+            console.error(e);
+          }
+
+          return {
+            __typename: 'rpc.response.call',
+            id: call.id,
+            name: call.name,
+            status: res.status,
+            result: res.response
+          };
+        })
+      );
+
+      return {
+        status: Math.max(...callRes.map(c => c.status)),
+        body: {
+          __typename: 'rpc.response',
+          calls: callRes
+        }
+      };
+    };
+
+    return {
+      handlerNames,
+      runMany
+
+      // fetch,
+
+      // http: async (
+      //   req: IncomingMessage & {
+      //     body: any;
+      //   },
+      //   res: ServerResponse & { send: (body: any) => void }
+      // ) => {
+      //   let headers = new Headers(
+      //     Object.fromEntries(
+      //       Object.entries(req.headers).map(([key, value]) => [
+      //         key,
+      //         value === undefined ? '' : String(value)
+      //       ])
+      //     )
+      //   );
+      //   let url = new URL(req.url ?? '', `http://${req.headers.host}`);
+
+      //   let request = new Request(url.toString(), {
+      //     method: req.method,
+      //     headers,
+      //     body: JSON.stringify(req.body)
+      //   });
+
+      //   let response = await fetch(request);
+
+      //   res.statusCode = response.status;
+
+      //   for (let [key, value] of response.headers.entries()) {
+      //     res.setHeader(key, value);
+      //   }
+
+      //   res.send(response.body);
+      // }
+    };
+  };

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "$schema": "https://json.schemastore.org/tsconfig",
+  "extends": "@lowerdeck/tsconfig/base.json",
+  "exclude": [
+    "dist"
+  ],
+  "include": [
+    "src"
+  ],
+  "compilerOptions": {
+    "outDir": "dist"
+  }
+}

package/tsup.config.js

@@ -0,0 +1,11 @@
+import { defineConfig } from 'tsup';
+
+export default defineConfig({
+  entry: ['src/index.ts'],
+  format: ['esm', 'cjs'],
+  splitting: false,
+  sourcemap: true,
+  clean: true,
+  bundle: true,
+  dts: true
+});