hypha-rpc 0.20.66 → 0.20.67

package/dist/hypha-rpc-websocket.js

@@ -58,6 +58,8 @@ function indexObject(obj, is) {
   else return indexObject(obj[is[0]], is.slice(1));
 }
 
+// Simple fallback schema generation - no docstring parsing for JS
+
 function _get_schema(obj, name = null, skipContext = false) {
   if (Array.isArray(obj)) {
     return obj.map((v, i) => _get_schema(v, null, skipContext));
@@ -78,10 +80,23 @@ function _get_schema(obj, name = null, skipContext = false) {
         if (schema.parameters && schema.parameters.properties) {
           delete schema.parameters.properties["context"];
         }
+        if (schema.parameters && schema.parameters.required) {
+          const contextIndex = schema.parameters.required.indexOf("context");
+          if (contextIndex > -1) {
+            schema.parameters.required.splice(contextIndex, 1);
+          }
+        }
       }
       return { type: "function", function: schema };
     } else {
-      return { type: "function" };
+      // Simple fallback for JavaScript - just return basic function schema with name
+      const funcName = name || obj.name || "function";
+      return {
+        type: "function",
+        function: {
+          name: funcName,
+        },
+      };
     }
   } else if (typeof obj === "number") {
     return { type: "number" };
@@ -696,7 +711,10 @@ class RPC extends _utils_index_js__WEBPACK_IMPORTED_MODULE_0__.MessageEmitter {
 
     service.config["workspace"] = context["ws"];
     // allow access for the same workspace
-    if (service.config.visibility == "public") {
+    if (
+      service.config.visibility == "public" ||
+      service.config.visibility == "unlisted"
+    ) {
       return service;
     }
 
@@ -849,7 +867,7 @@ class RPC extends _utils_index_js__WEBPACK_IMPORTED_MODULE_0__.MessageEmitter {
       require_context = api.config.require_context;
     if (api.config.run_in_executor) run_in_executor = true;
     const visibility = api.config.visibility || "protected";
-    (0,_utils_index_js__WEBPACK_IMPORTED_MODULE_0__.assert)(["protected", "public"].includes(visibility));
+    (0,_utils_index_js__WEBPACK_IMPORTED_MODULE_0__.assert)(["protected", "public", "unlisted"].includes(visibility));
     this._annotate_service_methods(
       api,
       api["id"],
@@ -2799,11 +2817,44 @@ function isAsyncGenerator(obj) {
 
 __webpack_require__.r(__webpack_exports__);
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
-/* harmony export */   schemaFunction: () => (/* binding */ schemaFunction)
+/* harmony export */   schemaFunction: () => (/* binding */ schemaFunction),
+/* harmony export */   z: () => (/* binding */ z)
 /* harmony export */ });
 /* harmony import */ var _index_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./index.js */ "./src/utils/index.js");
 
 
+// Schema builder utility inspired by Zod for consistent API with Python
+const z = {
+  object: (properties) => ({
+    type: "object",
+    properties,
+    required: Object.keys(properties).filter(
+      (key) => !properties[key]._optional,
+    ),
+  }),
+
+  string: () => ({ type: "string", _optional: false }),
+  number: () => ({ type: "number", _optional: false }),
+  integer: () => ({ type: "integer", _optional: false }),
+  boolean: () => ({ type: "boolean", _optional: false }),
+  array: (items) => ({ type: "array", items, _optional: false }),
+
+  // Make field optional
+  optional: (schema) => ({ ...schema, _optional: true }),
+};
+
+// Add description method to schema types
+["string", "number", "integer", "boolean", "array"].forEach((type) => {
+  z[type] = () => {
+    const schema = {
+      type: type === "integer" ? "integer" : type,
+      _optional: false,
+    };
+    schema.describe = (description) => ({ ...schema, description });
+    return schema;
+  };
+});
+
 function schemaFunction(
   func,
   { schema_type = "auto", name = null, description = null, parameters = null },
@@ -2812,15 +2863,43 @@ function schemaFunction(
     throw Error("func should be a function");
   }
   (0,_index_js__WEBPACK_IMPORTED_MODULE_0__.assert)(schema_type === "auto", "schema_type should be auto");
-  (0,_index_js__WEBPACK_IMPORTED_MODULE_0__.assert)(name, "name should not be null");
+
+  // If no name provided, try to get it from function
+  const funcName = name || func.name;
+  (0,_index_js__WEBPACK_IMPORTED_MODULE_0__.assert)(funcName, "name should not be null");
+
+  // If parameters is a z.object result, convert it properly
+  let processedParameters = parameters;
+  if (
+    parameters &&
+    typeof parameters === "object" &&
+    parameters.type === "object"
+  ) {
+    processedParameters = {
+      type: "object",
+      properties: parameters.properties || {},
+      required: parameters.required || [],
+    };
+
+    // Clean up internal _optional flags
+    for (const [key, schema] of Object.entries(
+      processedParameters.properties,
+    )) {
+      if (schema._optional !== undefined) {
+        delete schema._optional;
+      }
+    }
+  }
+
   (0,_index_js__WEBPACK_IMPORTED_MODULE_0__.assert)(
-    parameters && parameters.type === "object",
-    "parameters should be an object",
+    processedParameters && processedParameters.type === "object",
+    "parameters should be an object schema",
   );
+
   func.__schema__ = {
-    name: name,
-    description: description,
-    parameters: parameters || [],
+    name: funcName,
+    description: description || "",
+    parameters: processedParameters,
   };
   return func;
 }
@@ -5428,7 +5507,7 @@ class WebsocketRPCConnection {
           // Check if the message is a reconnection token
           if (parsedData.type === "reconnection_token") {
             this._reconnection_token = parsedData.reconnection_token;
-            console.log("Reconnection token received");
+            // console.log("Reconnection token received");
           } else {
             console.log("Received message from the server:", parsedData);
           }
@@ -5465,7 +5544,7 @@ class WebsocketRPCConnection {
     if (this._websocket && this._websocket.readyState === WebSocket.OPEN) {
       const refreshMessage = JSON.stringify({ type: "refresh_token" });
       this._websocket.send(refreshMessage);
-      console.log("Requested refresh token");
+      // console.log("Requested refresh token");
     }
   }