@bonsae/nrg 0.5.1 → 0.5.3

package/build/server/index.cjs

@@ -33,6 +33,7 @@ __export(index_exports, {
   ConfigNode: () => ConfigNode,
   IONode: () => IONode,
   Node: () => Node,
+  NrgError: () => NrgError,
   SchemaType: () => SchemaType,
   defineSchema: () => defineSchema,
   registerType: () => registerType,
@@ -231,6 +232,15 @@ function initValidator(RED) {
   validator2 = new NodeRedValidator(RED);
 }
 
+// src/core/errors.ts
+var NrgError = class _NrgError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "NrgError";
+    Object.setPrototypeOf(this, _NrgError.prototype);
+  }
+};
+
 // src/core/server/nodes/utils.ts
 function setupContext(context, store) {
   return {
@@ -254,40 +264,51 @@ function setupContext(context, store) {
     )
   };
 }
-function setupConfigProxy(RED, config) {
+function setupConfigProxy(RED, config, schema) {
   const SKIP_PROPS = /* @__PURE__ */ new Set(["id", "_id", "_users"]);
+  const nodeRefProps = /* @__PURE__ */ new Set();
+  if (schema?.properties) {
+    for (const [key, propSchema] of Object.entries(schema.properties)) {
+      if (propSchema?.["x-nrg-node-type"]) {
+        nodeRefProps.add(key);
+      }
+    }
+  }
+  const cache = /* @__PURE__ */ new WeakMap();
   const createProxy = (obj) => {
-    return new Proxy(obj, {
-      get(target, prop) {
-        if (typeof prop === "symbol") {
-          return target[prop];
-        }
-        if (SKIP_PROPS.has(prop)) {
-          return target[prop];
+    const cached = cache.get(obj);
+    if (cached) return cached;
+    if (Array.isArray(obj)) {
+      const mapped = obj.map((item) => {
+        if (item && typeof item === "object") {
+          return createProxy(item);
         }
+        return item;
+      });
+      cache.set(obj, mapped);
+      return mapped;
+    }
+    const proxy = new Proxy(obj, {
+      get(target, prop) {
+        if (typeof prop === "symbol") return target[prop];
+        if (SKIP_PROPS.has(prop)) return target[prop];
         const value = target[prop];
-        if (typeof value === "string" && value.length > 0) {
-          const node = RED.nodes.getNode(value)?._node;
-          return node || value;
-        }
-        if (Array.isArray(value)) {
-          return value.map((item) => {
-            if (typeof item === "string") {
-              const node = RED.nodes.getNode(item)?._node;
-              return node || item;
-            }
-            if (item && typeof item === "object") {
-              return createProxy(item);
-            }
-            return item;
-          });
+        if (typeof value === "string" && value.length > 0 && nodeRefProps.has(prop)) {
+          return RED.nodes.getNode(value)?._node ?? value;
         }
         if (value && typeof value === "object") {
           return createProxy(value);
         }
         return value;
+      },
+      set(_target, prop) {
+        throw new NrgError(
+          `Cannot set property '${String(prop)}' on read-only node config`
+        );
       }
     });
+    cache.set(obj, proxy);
+    return proxy;
   };
   return createProxy(config);
 }
@@ -369,7 +390,11 @@ var Node = class {
         );
       }
     }
-    this.config = setupConfigProxy(RED, config);
+    this.config = setupConfigProxy(
+      RED,
+      config,
+      constructor.configSchema
+    );
     if (constructor.credentialsSchema && credentials) {
       this.log("Validating credentials");
       const credResult = validator2.validate(
@@ -785,9 +810,16 @@ function serveNrgResources(RED) {
   httpAdmin.use(function(req, res, next) {
     const prefix = "/nrg/assets/";
     if (!req.path.startsWith(prefix)) return next();
-    const reqPath = req.path.slice(prefix.length).replace(/\.\./g, "");
+    let reqPath = req.path.slice(prefix.length);
+    if (reqPath === "vue.esm-browser.prod.js" && process.env.NODE_ENV !== "production") {
+      const devPath = import_path.default.resolve(clientDir, "vue.esm-browser.js");
+      if (import_fs.default.existsSync(devPath)) {
+        reqPath = "vue.esm-browser.js";
+      }
+    }
     const filePath = import_path.default.resolve(clientDir, reqPath);
-    if (!filePath.startsWith(clientDir)) return next();
+    const rel = import_path.default.relative(clientDir, filePath);
+    if (rel.startsWith("..") || import_path.default.isAbsolute(rel)) return next();
     if (!import_fs.default.existsSync(filePath) || !import_fs.default.statSync(filePath).isFile())
       return next();
     const ext = import_path.default.extname(filePath);
@@ -799,23 +831,23 @@ async function registerType(RED, NodeClass) {
   const NC = NodeClass;
   RED.log.debug(`Registering Type: ${NC.type}`);
   if (!(NC.prototype instanceof Node)) {
-    throw new Error(`${NC.name} must extend IONode or ConfigNode classes`);
+    throw new NrgError(`${NC.name} must extend IONode or ConfigNode classes`);
   }
   if (!NC.type) {
-    throw new Error("type must be provided when registering the node");
+    throw new NrgError("type must be provided when registering the node");
   }
   if (NC.color && !/^#[0-9A-Fa-f]{6}$/.test(NC.color)) {
-    throw new Error(
+    throw new NrgError(
       `Invalid color for ${NodeClass.type}: ${NC.color} color must be in hex format`
     );
   }
-  if (NC.inputs !== void 0 && (!Number.isInteger(NC.inputs) || NC.inputs != 0 && NC.inputs != 1)) {
-    throw new Error(
+  if (NC.inputs !== void 0 && (!Number.isInteger(NC.inputs) || NC.inputs !== 0 && NC.inputs !== 1)) {
+    throw new NrgError(
       `Invalid number of inputs for ${NodeClass.type}: inputs must be 0 or 1`
     );
   }
   if (NC.outputs !== void 0 && (!Number.isInteger(NC.outputs) || NC.outputs < 0)) {
-    throw new Error(
+    throw new NrgError(
       `Invalid number of outputs for ${NodeClass.type}: outputs must be a positive integer`
     );
   }
@@ -824,7 +856,12 @@ async function registerType(RED, NodeClass) {
     function(config) {
       RED.nodes.createNode(this, config);
       const node = new NC(RED, this, config, this.credentials);
-      this._node = node;
+      Object.defineProperty(this, "_node", {
+        value: node,
+        writable: false,
+        configurable: false,
+        enumerable: false
+      });
       const createdPromise = Promise.resolve(node.created?.()).catch(
         (error) => {
           this.error("Error during created hook: " + error.message);
@@ -907,6 +944,7 @@ function registerTypes(nodes) {
   ConfigNode,
   IONode,
   Node,
+  NrgError,
   SchemaType,
   defineSchema,
   registerType,