arri 0.36.1 → 0.37.1

package/dist/shared/{arri.8e96548e.cjs → arri.bba0eea2.cjs}

@@ -1,27 +1,22 @@
 'use strict';
 
 const arriCodegenUtils = require('arri-codegen-utils');
-const consola = require('consola');
 const h3 = require('h3');
 const arriValidate = require('arri-validate');
 const h3Sse = require('h3-sse');
 const scule = require('scule');
 
-function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
-
-const consola__default = /*#__PURE__*/_interopDefaultCompat(consola);
-
-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;
 };
 class ArriServerError extends Error {
   constructor(err) {
     super(err.message);
-    __publicField$3(this, "code");
-    __publicField$3(this, "data");
+    __publicField$4(this, "code");
+    __publicField$4(this, "data");
     this.code = err.code;
     this.data = err.data;
     if (err.stack) {
@@ -267,6 +262,7 @@ function isRpc(input) {
   return typeof input === "object" && input !== null && "method" in input && arriCodegenUtils.isRpcHttpMethod(input.method) && "handler" in input && typeof input.handler === "function";
 }
 function defineRpc(config) {
+  config.transport = "http";
   return config;
 }
 function createHttpRpcDefinition(rpcName, httpPath, procedure) {
@@ -478,17 +474,18 @@ async function validateRpcRequestInput(event, httpMethod, schema) {
   }
 }
 
-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);
+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;
 };
 function defineEventStreamRpc(config) {
   return {
     ...config,
     method: config.method ?? "get",
-    isEventStream: true
+    isEventStream: true,
+    transport: "http"
   };
 }
 function isEventStreamRpc(input) {
@@ -496,14 +493,14 @@ function isEventStreamRpc(input) {
 }
 class EventStreamConnection {
   constructor(event, opts) {
-    __publicField$2(this, "lastEventId");
-    __publicField$2(this, "validationErrors");
-    __publicField$2(this, "validator");
-    __publicField$2(this, "serializer");
+    __publicField$3(this, "lastEventId");
+    __publicField$3(this, "validationErrors");
+    __publicField$3(this, "validator");
+    __publicField$3(this, "serializer");
     // for some reason Rollup cannot output DTS when this is set to NodeJS.Timeout
-    __publicField$2(this, "pingInterval");
-    __publicField$2(this, "pingIntervalMs");
-    __publicField$2(this, "eventStream");
+    __publicField$3(this, "pingInterval");
+    __publicField$3(this, "pingIntervalMs");
+    __publicField$3(this, "eventStream");
     this.eventStream = h3Sse.createEventStream(event);
     this.lastEventId = this.eventStream.lastEventId;
     this.pingIntervalMs = opts.pingInterval ?? 6e4;
@@ -817,19 +814,24 @@ function handleRoute(router, method, route, opts) {
   }
 }
 
-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;
-var __publicField$1 = (obj, key, value) => {
-  __defNormalProp$1(obj, typeof key !== "symbol" ? key + "" : key, value);
+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() {
-    __publicField$1(this, "procedures", []);
-    __publicField$1(this, "routes", []);
-    __publicField$1(this, "models", {});
+    __publicField$2(this, "procedures", []);
+    __publicField$2(this, "routes", []);
+    __publicField$2(this, "models", {});
   }
   rpc(procedure) {
+    procedure.transport = "http";
+    this.procedures.push(procedure);
+  }
+  wsRpc(procedure) {
+    procedure.transport = "ws";
     this.procedures.push(procedure);
   }
   route(route) {
@@ -851,6 +853,145 @@ class ArriRouter {
   }
 }
 
+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;
+var __publicField$1 = (obj, key, value) => {
+  __defNormalProp$1(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class WsPeer {
+  constructor(peer, opts) {
+    __publicField$1(this, "_peer");
+    __publicField$1(this, "_validator");
+    __publicField$1(this, "context");
+    __publicField$1(this, "url");
+    this._peer = peer;
+    this._validator = opts.validator;
+    this.url = peer.url;
+    this.context = opts.context;
+  }
+  send(data) {
+    if (!this._validator) {
+      return;
+    }
+    if (!this._validator.validate(data)) {
+      return;
+    }
+    const payload = this._validator.serialize(data);
+    return this._peer.send(`type: message
+data: ${payload}`);
+  }
+  sendError(err) {
+    return this._peer.send(`type: error
+data: ${JSON.stringify(err)}`);
+  }
+  close() {
+    throw new Error("close() is not yet implemented on WsPeer");
+  }
+  subscribe(channel) {
+    this._peer.subscribe(channel);
+  }
+  unsubscribe(channel) {
+    this._peer.unsubscribe(channel);
+  }
+  publish(channel, message) {
+    if (!this._validator) {
+      return;
+    }
+    if (!this._validator.validate(message)) {
+      const err = {
+        code: 500,
+        message: `Error serializing message on server. The payload doesn't match the specified schema.`,
+        data: {
+          payload: message
+        }
+      };
+      this.sendError(err);
+      return;
+    }
+    const payload = this._validator.serialize(message);
+    this._peer.publish(channel, payload);
+  }
+  readyState() {
+    return this._peer.readyState;
+  }
+}
+function defineWebsocketRpc(def) {
+  def.transport = "ws";
+  return def;
+}
+function registerWebsocketRpc(router, path, rpc) {
+  let responseValidator;
+  let paramValidator;
+  try {
+    responseValidator = rpc.response ? arriValidate.a.compile(rpc.response) : void 0;
+  } catch (err) {
+    console.error("ERROR COMPILING VALIDATOR", err);
+  }
+  try {
+    paramValidator = rpc.params ? arriValidate.a.compile(rpc.params) : void 0;
+  } catch (err) {
+    console.error("ERROR COMPILING PARAMS", err);
+  }
+  const handler = h3.defineWebSocketHandler({
+    upgrade(req) {
+    },
+    open(peer) {
+      const urlParts = peer.url.split("?");
+      const context = {
+        rpcName: rpc.name,
+        clientAddress: peer.addr
+      };
+      if (urlParts.length > 1) {
+        urlParts.shift();
+        const queryStr = new URLSearchParams(urlParts.join("?"));
+        const query = {};
+        for (const [key, val] of queryStr.entries()) {
+          query[key] = val;
+        }
+        context.queryParams = query;
+      }
+      const wsPeer = new WsPeer(peer, {
+        validator: responseValidator,
+        context
+      });
+      peer.ctx.__wsPeer = wsPeer;
+      rpc.handler.onOpen(peer.ctx.__wsPeer);
+    },
+    message(peer, message) {
+      if (!paramValidator) {
+        return;
+      }
+      const data = paramValidator.safeParse(message.text());
+      if (!data.success) {
+        const errorResponse = {
+          code: 400,
+          message: data.error.message,
+          data: data.error.errors,
+          stack: data.error.stack?.split("\n")
+        };
+        peer.ctx.__wsPeer.sendError(errorResponse);
+        return;
+      }
+      rpc.handler.onMessage(peer.ctx.__wsPeer, data.value);
+    },
+    close(peer, details) {
+      rpc.handler.onClose(peer.ctx.__wsPeer, details);
+    }
+  });
+  router.use(path, handler);
+}
+function createWsRpcDefinition(rpcName, path, rpc) {
+  return {
+    transport: "ws",
+    path,
+    params: getRpcParamName(rpcName, rpc),
+    response: getRpcResponseName(rpcName, rpc),
+    isDeprecated: rpc.isDeprecated,
+    description: rpc.description
+  };
+}
+
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField = (obj, key, value) => {
@@ -894,10 +1035,27 @@ class ArriApp {
       this.definitionPath,
       h3.eventHandler(() => this.getAppDefinition())
     );
+    if (!opts.disableDefaultRoute) {
+      this.route({
+        method: ["get", "head"],
+        path: "/",
+        handler: (_) => {
+          let schemaPath;
+          if (this._rpcRoutePrefix) {
+            schemaPath = `/${this._rpcRoutePrefix}/${this._rpcDefinitionPath}`;
+          } else {
+            schemaPath = `/${this._rpcDefinitionPath}`;
+          }
+          return {
+            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.",
+            schemaPath,
+            ...this.appInfo
+          };
+        }
+      });
+    }
     if (process.env.ARRI_DEV_MODE === "true") {
-      consola__default.info(
-        `Arri definition available at \`http://<host>${this.definitionPath}\``
-      );
       this.h3Router.get(
         DEV_DEFINITION_ENDPOINT,
         h3.eventHandler(() => this.getAppDefinition())
@@ -928,7 +1086,11 @@ class ArriApp {
         this.route(route);
       }
       for (const rpc of input.getProcedures()) {
-        this.rpc(rpc);
+        if (rpc.transport === "http") {
+          this.rpc(rpc);
+        } else {
+          this.wsRpc(rpc);
+        }
       }
       this.registerModels(input.getModels());
       return;
@@ -936,26 +1098,24 @@ class ArriApp {
     this._middlewares.push(input);
   }
   rpc(procedure) {
-    const path = procedure.path ?? getRpcPath(procedure.name, this._rpcRoutePrefix);
-    this._procedures[procedure.name] = createHttpRpcDefinition(
-      procedure.name,
-      path,
-      procedure
-    );
-    if (isRpcParamSchema(procedure.params)) {
-      const paramName = getRpcParamName(procedure.name, procedure);
+    procedure.transport = "http";
+    const p = procedure;
+    const path = p.path ?? getRpcPath(p.name, this._rpcRoutePrefix);
+    this._procedures[p.name] = createHttpRpcDefinition(p.name, path, p);
+    if (isRpcParamSchema(p.params)) {
+      const paramName = getRpcParamName(p.name, p);
       if (paramName) {
-        this._models[paramName] = procedure.params;
+        this._models[paramName] = p.params;
       }
     }
-    if (isRpcParamSchema(procedure.response)) {
-      const responseName = getRpcResponseName(procedure.name, procedure);
+    if (isRpcParamSchema(p.response)) {
+      const responseName = getRpcResponseName(p.name, p);
       if (responseName) {
-        this._models[responseName] = procedure.response;
+        this._models[responseName] = p.response;
       }
     }
-    if (isEventStreamRpc(procedure)) {
-      registerEventStreamRpc(this.h3Router, path, procedure, {
+    if (isEventStreamRpc(p)) {
+      registerEventStreamRpc(this.h3Router, path, p, {
         middleware: this._middlewares,
         onRequest: this._onRequest,
         onError: this._onError,
@@ -965,7 +1125,7 @@ class ArriApp {
       });
       return;
     }
-    registerRpc(this.h3Router, path, procedure, {
+    registerRpc(this.h3Router, path, p, {
       middleware: this._middlewares,
       onRequest: this._onRequest,
       onError: this._onError,
@@ -974,6 +1134,29 @@ class ArriApp {
       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._models[paramName] = procedure.params;
+      }
+    }
+    if (isRpcParamSchema(procedure.response)) {
+      const responseName = getRpcResponseName(procedure.name, p);
+      if (responseName) {
+        this._models[responseName] = procedure.response;
+      }
+    }
+    registerWebsocketRpc(this.h3Router, path, p);
+  }
   route(route) {
     registerRoute(this.h3Router, route, {
       middleware: this._middlewares,
@@ -1070,14 +1253,17 @@ exports.ArriServerErrorResponse = ArriServerErrorResponse;
 exports.DEV_DEFINITION_ENDPOINT = DEV_DEFINITION_ENDPOINT;
 exports.DEV_ENDPOINT_ROOT = DEV_ENDPOINT_ROOT;
 exports.EventStreamConnection = EventStreamConnection;
+exports.WsPeer = WsPeer;
 exports.createAppDefinition = createAppDefinition;
 exports.createHttpRpcDefinition = createHttpRpcDefinition;
+exports.createWsRpcDefinition = createWsRpcDefinition;
 exports.defaultConfig = defaultConfig;
 exports.defineConfig = defineConfig;
 exports.defineError = defineError;
 exports.defineEventStreamRpc = defineEventStreamRpc;
 exports.defineRoute = defineRoute;
 exports.defineRpc = defineRpc;
+exports.defineWebsocketRpc = defineWebsocketRpc;
 exports.errorResponseFromValidationErrors = errorResponseFromValidationErrors;
 exports.getRpcParamName = getRpcParamName;
 exports.getRpcPath = getRpcPath;
@@ -1092,4 +1278,5 @@ exports.isRpcParamSchema = isRpcParamSchema;
 exports.registerEventStreamRpc = registerEventStreamRpc;
 exports.registerRoute = registerRoute;
 exports.registerRpc = registerRpc;
+exports.registerWebsocketRpc = registerWebsocketRpc;
 exports.validateRpcRequestInput = validateRpcRequestInput;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "arri",
-  "version": "0.36.1",
+  "version": "0.37.1",
   "type": "module",
   "license": "MIT",
   "author": {
@@ -30,6 +30,7 @@
     "chokidar": "^3.6.0",
     "citty": "^0.1.6",
     "consola": "^3.2.3",
+    "crossws": "^0.2.4",
     "degit": "^2.8.4",
     "enquirer": "^2.4.1",
     "esbuild": "^0.20.2",
@@ -43,13 +44,13 @@
     "prettier": "^3.2.5",
     "scule": "^1.3.0",
     "uncrypto": "^0.1.3",
-    "arri-codegen-utils": "0.36.1",
-    "arri-validate": "0.36.1",
-    "arri-codegen-ts": "0.36.1",
-    "arri-codegen-dart": "0.36.1"
+    "arri-codegen-dart": "0.37.1",
+    "arri-codegen-ts": "0.37.1",
+    "arri-validate": "0.37.1",
+    "arri-codegen-utils": "0.37.1"
   },
   "devDependencies": {
     "@types/degit": "^2.8.6",
-    "bun-types": "^1.0.35"
+    "bun-types": "^1.1.1"
   }
 }