@arrirpc/server 0.55.0 → 0.57.0

package/README.md

@@ -189,13 +189,17 @@ For those that want to opt out of the file-based routing system you can manually
 ```ts
 // using the app instance
 const app = new ArriApp()
-app.rpc('sayHello', {...})
+app.rpc('sayHello',
+    defineRpc({...})
+);
 
-// using a sub-router
+// defining a service
 const app = new ArriApp();
-const router = new ArriRouter();
-router.rpc('sayHello', {...})
-app.use(router)
+const usersService = defineService("users", {
+    getUser: defineRpc({..}),
+    createUser: defineRpc({..}),
+});
+app.use(usersService);
 ```
 
 #### Creating Event Stream Procedures
@@ -205,7 +209,6 @@ Event stream procedures make use of [Server Sent Events](https://developer.mozil
 Arri Event streams sent the following event types:
 
 -   `message` - A standard message with the response data serialized as JSON
--   `error` - An error message with an `ArriRequestError` sent as JSON
 -   `done` - A message to tell clients that there will be no more events
 -   `ping` - A message periodically sent by the server to keep the connection alive.
 
@@ -215,11 +218,6 @@ id: string | undefined;
 event: "message";
 data: Response; // whatever you have specified as the response serialized to json
 
-/// error event ///
-id: string | undefined;
-event: "error";
-data: ArriRequestError; // serialized to json
-
 /// done event ///
 event: "done";
 data: "this stream has ended";
@@ -268,11 +266,14 @@ export default defineEventStreamRpc({
 #### EventStreamConnection methods
 
 ```ts
-stream.push(data: Data, eventId?: string)
-stream.pushError(error: ArriRequestError, eventId?: string)
+// send the stream to the client. Must be called before pushing any messages
 stream.send()
-stream.end()
-stream.on(e: 'request:close' | 'close', callback: () => any)
+// push a new message to the client
+stream.push(data: Data, eventId?: string)
+// close the stream and tell the client that there will be no more messages
+stream.close()
+// register a callback that will fire after the stream has been close by the server or the connection has been dropped
+stream.onClosed(cb: () => any)
 ```
 
 ### Creating Websocket Procedures (Experimental)
@@ -363,6 +364,16 @@ router.route({
     }
 })
 app.use(router)
+
+// sup-routers can also specify a route prefix
+const router = new ArriRouter("/v1")
+router.route({
+    method: "get",
+    path: "/hello-world", // this will become /v1/hello-world
+    handler(event) {
+        return "hello world"
+    }
+});
 ```
 
 ### Adding Middleware
@@ -440,7 +451,7 @@ export default defineConfig({
 
 For info on what generators are available see [here](/README.md#client-generators)
 
-For info on how to create your own generator see []
+For info on how to create your own generator see [@arrirpc/codegen-utils](/tooling/codegen-utils/README.md)
 
 ## Key Concepts
 

package/dist/index.cjs

@@ -6,17 +6,17 @@ const h3 = require('h3');
 const schema = require('@arrirpc/schema');
 const scule = require('scule');
 
-var __defProp$4 = Object.defineProperty;
-var __defNormalProp$4 = (obj, key, value) => key in obj ? __defProp$4(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$4 = (obj, key, value) => {
-  __defNormalProp$4(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __defProp$5 = Object.defineProperty;
+var __defNormalProp$5 = (obj, key, value) => key in obj ? __defProp$5(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$5 = (obj, key, value) => {
+  __defNormalProp$5(obj, typeof key !== "symbol" ? key + "" : key, value);
   return value;
 };
 class ArriServerError extends Error {
   constructor(err) {
     super(err.message);
-    __publicField$4(this, "code");
-    __publicField$4(this, "data");
+    __publicField$5(this, "code");
+    __publicField$5(this, "data");
     this.code = err.code;
     this.data = err.data;
     if (err.stack) {
@@ -324,12 +324,8 @@ function getRpcResponseDefinition(rpcName, procedure) {
   return name;
 }
 function registerRpc(router, path, procedure, opts) {
-  let responseValidator;
-  try {
-    responseValidator = procedure.response ? schema.a.compile(procedure.response) : void 0;
-  } catch (err) {
-    console.error("ERROR COMPILING VALIDATOR", err);
-  }
+  const paramValidator = procedure.params ? getSchemaValidator(procedure.name, "params", procedure.params) : void 0;
+  const responseValidator = procedure.response ? getSchemaValidator(procedure.name, "response", procedure.response) : void 0;
   const httpMethod = procedure.method ?? "post";
   const handler = h3.eventHandler(async (event) => {
     event.context.rpcName = procedure.name;
@@ -349,7 +345,8 @@ function registerRpc(router, path, procedure, opts) {
         await validateRpcRequestInput(
           event,
           httpMethod,
-          procedure.params
+          procedure.params,
+          paramValidator
         );
       }
       const response = await procedure.handler(
@@ -412,7 +409,7 @@ function registerRpc(router, path, procedure, opts) {
       break;
   }
 }
-async function validateRpcRequestInput(event, httpMethod, schema$1) {
+async function validateRpcRequestInput(event, httpMethod, schema$1, validator) {
   switch (httpMethod) {
     case "get": {
       const parsedParams = await h3.getValidatedQuery(
@@ -451,8 +448,8 @@ async function validateRpcRequestInput(event, httpMethod, schema$1) {
           message: `Invalid request body. Expected object. Got undefined.`
         });
       }
-      const parsedParams = schema.a.safeParse(schema$1, body);
-      if (!parsedParams.success) {
+      const parsedParams = validator.safeParse(body);
+      if (!parsedParams?.success) {
         const errorParts = [];
         for (const err of parsedParams.error.errors) {
           const errPath = err.instancePath.split("/");
@@ -473,11 +470,22 @@ async function validateRpcRequestInput(event, httpMethod, schema$1) {
     }
   }
 }
+function getSchemaValidator(rpcName, type, schema$1) {
+  try {
+    if (schema.isAdaptedSchema(schema$1)) {
+      return schema.validatorFromAdaptedSchema(schema$1);
+    }
+    return schema.a.compile(schema$1);
+  } catch (err) {
+    console.error(`Error compiling ${type} validator for ${rpcName}`);
+    return void 0;
+  }
+}
 
-var __defProp$3 = Object.defineProperty;
-var __defNormalProp$3 = (obj, key, value) => key in obj ? __defProp$3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$3 = (obj, key, value) => {
-  __defNormalProp$3(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __defProp$4 = Object.defineProperty;
+var __defNormalProp$4 = (obj, key, value) => key in obj ? __defProp$4(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$4 = (obj, key, value) => {
+  __defNormalProp$4(obj, typeof key !== "symbol" ? key + "" : key, value);
   return value;
 };
 function defineEventStreamRpc(config) {
@@ -493,14 +501,14 @@ function isEventStreamRpc(input) {
 }
 class EventStreamConnection {
   constructor(event, opts) {
-    __publicField$3(this, "lastEventId");
-    __publicField$3(this, "validationErrors");
-    __publicField$3(this, "validator");
-    __publicField$3(this, "serializer");
+    __publicField$4(this, "lastEventId");
+    __publicField$4(this, "validationErrors");
+    __publicField$4(this, "validator");
+    __publicField$4(this, "serializer");
     // for some reason Rollup cannot output DTS when this is set to NodeJS.Timeout
-    __publicField$3(this, "pingInterval");
-    __publicField$3(this, "pingIntervalMs");
-    __publicField$3(this, "eventStream");
+    __publicField$4(this, "pingInterval");
+    __publicField$4(this, "pingIntervalMs");
+    __publicField$4(this, "eventStream");
     this.eventStream = h3.createEventStream(event);
     this.lastEventId = h3.getHeader(event, "Last-Event-Id");
     this.pingIntervalMs = opts.pingInterval ?? 6e4;
@@ -580,12 +588,8 @@ class EventStreamConnection {
   }
 }
 function registerEventStreamRpc(router, path, procedure, opts) {
-  let responseValidator;
-  try {
-    responseValidator = procedure.response ? schema.a.compile(procedure.response) : void 0;
-  } catch (err) {
-    console.error("ERROR COMPILING VALIDATOR", err);
-  }
+  const paramValidator = procedure.params ? getSchemaValidator(procedure.name, "params", procedure.params) : void 0;
+  const responseValidator = procedure.response ? getSchemaValidator(procedure.name, "response", procedure.response) : void 0;
   const httpMethod = procedure.method ?? "get";
   const handler = h3.eventHandler(async (event) => {
     event.context.rpcName = procedure.name;
@@ -605,7 +609,8 @@ function registerEventStreamRpc(router, path, procedure, opts) {
         await validateRpcRequestInput(
           event,
           httpMethod,
-          procedure.params
+          procedure.params,
+          paramValidator
         );
       }
       const stream = new EventStreamConnection(event, {
@@ -780,29 +785,53 @@ function handleRoute(router, method, route, opts) {
   }
 }
 
+var __defProp$3 = Object.defineProperty;
+var __defNormalProp$3 = (obj, key, value) => key in obj ? __defProp$3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$3 = (obj, key, value) => {
+  __defNormalProp$3(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class ArriRouter {
+  constructor(routePrefix = "") {
+    __publicField$3(this, "routes", []);
+    __publicField$3(this, "definitions", {});
+    __publicField$3(this, "prefix");
+    this.prefix = routePrefix;
+  }
+  route(route) {
+    route.path = `${this.prefix}${route.path}`;
+    this.routes.push(route);
+  }
+  registerDefinitions(models) {
+    for (const key of Object.keys(models)) {
+      this.definitions[key] = models[key];
+    }
+  }
+  getRoutes() {
+    return this.routes;
+  }
+  getDefinitions() {
+    return this.definitions;
+  }
+}
+
 var __defProp$2 = Object.defineProperty;
 var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField$2 = (obj, key, value) => {
   __defNormalProp$2(obj, typeof key !== "symbol" ? key + "" : key, value);
   return value;
 };
-class ArriRouter {
-  constructor() {
+class ArriService {
+  constructor(name) {
+    __publicField$2(this, "name");
     __publicField$2(this, "procedures", []);
-    __publicField$2(this, "routes", []);
     __publicField$2(this, "definitions", {});
+    this.name = name;
   }
-  rpc(procedure) {
-    procedure.transport = "http";
-    this.procedures.push(procedure);
-  }
-  wsRpc(procedure) {
-    procedure.transport = "ws";
+  rpc(name, procedure) {
+    procedure.name = `${this.name}.${name}`;
     this.procedures.push(procedure);
   }
-  route(route) {
-    this.routes.push(route);
-  }
   registerDefinitions(models) {
     for (const key of Object.keys(models)) {
       this.definitions[key] = models[key];
@@ -811,13 +840,17 @@ class ArriRouter {
   getProcedures() {
     return this.procedures;
   }
-  getRoutes() {
-    return this.routes;
-  }
   getDefinitions() {
     return this.definitions;
   }
 }
+function defineService(name, procedures) {
+  const service = new ArriService(name);
+  for (const key of Object.keys(procedures ?? {})) {
+    service.rpc(key, procedures[key]);
+  }
+  return service;
+}
 
 var __defProp$1 = Object.defineProperty;
 var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
@@ -999,14 +1032,21 @@ class ArriApp {
     if (!opts.disableDefinitionRoute) {
       this.h3Router.get(
         this.definitionPath,
-        h3.eventHandler(() => this.getAppDefinition())
+        h3.eventHandler((event) => {
+          h3.setResponseHeader(
+            event,
+            "Content-Type",
+            "application/json"
+          );
+          return this.getAppDefinition();
+        })
       );
     }
     if (!opts.disableDefaultRoute) {
       this.route({
         method: ["get", "head"],
         path: "/",
-        handler: (_) => {
+        handler: async (_) => {
           const response = {
             title: this.appInfo?.title ?? "Arri-RPC Server",
             description: this.appInfo?.description ?? "This server utilizes Arri-RPC. Visit the schema path to see all of the available procedures.",
@@ -1029,7 +1069,14 @@ class ArriApp {
     if (process.env.ARRI_DEV_MODE === "true") {
       this.h3Router.get(
         arri.DEV_DEFINITION_ENDPOINT,
-        h3.eventHandler(() => this.getAppDefinition())
+        h3.eventHandler((event) => {
+          h3.setResponseHeader(
+            event,
+            "Content-Type",
+            "application/json"
+          );
+          return this.getAppDefinition();
+        })
       );
     }
     this.h3Router.use(
@@ -1056,23 +1103,27 @@ class ArriApp {
       for (const route of input.getRoutes()) {
         this.route(route);
       }
+      this.registerDefinitions(input.getDefinitions());
+      return;
+    }
+    if (typeof input === "object" && input instanceof ArriService) {
       for (const rpc of input.getProcedures()) {
-        if (rpc.transport === "http") {
-          this.rpc(rpc);
-        } else {
-          this.wsRpc(rpc);
-        }
+        this.rpc(rpc.name, rpc);
       }
       this.registerDefinitions(input.getDefinitions());
       return;
     }
     this._middlewares.push(input);
   }
-  rpc(procedure) {
-    procedure.transport = "http";
+  rpc(name, procedure) {
+    procedure.name = name;
     const p = procedure;
     const path = p.path ?? getRpcPath(p.name, this._rpcRoutePrefix);
-    this._procedures[p.name] = createHttpRpcDefinition(p.name, path, p);
+    if (p.transport === "http") {
+      this._procedures[p.name] = createHttpRpcDefinition(p.name, path, p);
+    } else if (p.transport === "ws") {
+      this._procedures[p.name] = createWsRpcDefinition(p.name, path, p);
+    }
     if (isRpcParamSchema(p.params)) {
       const paramName = getRpcParamName(p.name, p);
       if (paramName) {
@@ -1085,8 +1136,19 @@ class ArriApp {
         this._definitions[responseName] = p.response;
       }
     }
-    if (isEventStreamRpc(p)) {
-      registerEventStreamRpc(this.h3Router, path, p, {
+    if (p.transport === "http") {
+      if (isEventStreamRpc(p)) {
+        registerEventStreamRpc(this.h3Router, path, p, {
+          middleware: this._middlewares,
+          onRequest: this._onRequest,
+          onError: this._onError,
+          onAfterResponse: this._onAfterResponse,
+          onBeforeResponse: this._onBeforeResponse,
+          debug: this._debug
+        });
+        return;
+      }
+      registerRpc(this.h3Router, path, p, {
         middleware: this._middlewares,
         onRequest: this._onRequest,
         onError: this._onError,
@@ -1096,37 +1158,9 @@ class ArriApp {
       });
       return;
     }
-    registerRpc(this.h3Router, path, p, {
-      middleware: this._middlewares,
-      onRequest: this._onRequest,
-      onError: this._onError,
-      onAfterResponse: this._onAfterResponse,
-      onBeforeResponse: this._onBeforeResponse,
-      debug: this._debug
-    });
-  }
-  wsRpc(procedure) {
-    procedure.transport = "ws";
-    const p = procedure;
-    const path = procedure.path ?? getRpcPath(procedure.name, this._rpcRoutePrefix);
-    this._procedures[procedure.name] = createWsRpcDefinition(
-      procedure.name,
-      path,
-      p
-    );
-    if (isRpcParamSchema(procedure.params)) {
-      const paramName = getRpcParamName(procedure.name, p);
-      if (paramName) {
-        this._definitions[paramName] = procedure.params;
-      }
-    }
-    if (isRpcParamSchema(procedure.response)) {
-      const responseName = getRpcResponseName(procedure.name, p);
-      if (responseName) {
-        this._definitions[responseName] = procedure.response;
-      }
+    if (p.transport === "ws") {
+      registerWebsocketRpc(this.h3Router, path, p);
     }
-    registerWebsocketRpc(this.h3Router, path, p);
   }
   route(route) {
     registerRoute(this.h3Router, route, {
@@ -1164,6 +1198,7 @@ exports.ArriApp = ArriApp;
 exports.ArriRouter = ArriRouter;
 exports.ArriServerError = ArriServerError;
 exports.ArriServerErrorResponse = ArriServerErrorResponse;
+exports.ArriService = ArriService;
 exports.EventStreamConnection = EventStreamConnection;
 exports.WsPeer = WsPeer;
 exports.createAppDefinition = createAppDefinition;
@@ -1174,11 +1209,13 @@ exports.defineEventStreamRpc = defineEventStreamRpc;
 exports.defineMiddleware = defineMiddleware;
 exports.defineRoute = defineRoute;
 exports.defineRpc = defineRpc;
+exports.defineService = defineService;
 exports.defineWebsocketRpc = defineWebsocketRpc;
 exports.errorResponseFromValidationErrors = errorResponseFromValidationErrors;
 exports.getRpcParamName = getRpcParamName;
 exports.getRpcPath = getRpcPath;
 exports.getRpcResponseName = getRpcResponseName;
+exports.getSchemaValidator = getSchemaValidator;
 exports.handleH3Error = handleH3Error;
 exports.handleRoute = handleRoute;
 exports.isEventStreamRpc = isEventStreamRpc;