@bonsae/nrg 0.5.2 → 0.5.4

package/build/vite/index.js

@@ -1594,7 +1594,9 @@ async function build2(clientBuildOptions, buildContext) {
     throw new BuildError("client", error);
   } finally {
     if (generatedEntry) {
-      fs10.unlinkSync(entryPath);
+      if (fs10.existsSync(entryPath)) {
+        fs10.unlinkSync(entryPath);
+      }
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bonsae/nrg",
-  "version": "0.5.2",
+  "version": "0.5.4",
   "description": "NRG framework — build Node-RED nodes with Vue 3, TypeScript, and JSON Schema",
   "author": "Allan Oricil <allanoricil@duck.com>",
   "license": "MIT",
@@ -17,6 +17,10 @@
     "pnpm": ">=10.11.0"
   },
   "scripts": {
+    "test": "vitest run && vitest run --config vitest.e2e.config.ts",
+    "test:unit": "vitest run",
+    "test:unit:watch": "vitest",
+    "test:e2e": "vitest run --config vitest.e2e.config.ts",
     "build": "node build.mjs",
     "typecheck": "tsc -p src/core/server/tsconfig.json --noEmit && tsc -p src/core/client/tsconfig.json --noEmit",
     "lint": "eslint src/",
@@ -103,6 +107,7 @@
     "@types/node": "^22.15.18",
     "@typescript-eslint/eslint-plugin": "^8.32.1",
     "@typescript-eslint/parser": "^8.32.1",
+    "@vitest/coverage-v8": "^4.1.5",
     "eslint": "^9.27.0",
     "eslint-config-prettier": "^10.1.8",
     "eslint-plugin-vue": "^10.1.0",
@@ -113,6 +118,7 @@
     "semantic-release": "^24.2.4",
     "typescript-eslint": "^8.32.1",
     "vite": "^6.3.4",
+    "vitest": "^4.1.5",
     "vue": "^3.5.14"
   }
 }

package/src/core/client/app.vue

@@ -162,7 +162,7 @@ export default defineComponent({
             error.instancePath,
           );
           if (
-            error.parentSchema.format === "password" &&
+            error.parentSchema?.format === "password" &&
             errorValue === "__PWD__"
           ) {
             return acc;

package/src/core/client/components/node-red-json-schema-form.vue

@@ -197,7 +197,8 @@ interface FormField {
     | "select"
     | "typed"
     | "config"
-    | "editor";
+    | "editor"
+    | "array-text";
   required: boolean;
   htmlType?: "text" | "number" | "password";
   options?: Array<{ value: string; label: string }>;

package/src/core/client/components/node-red-typed-input.vue

@@ -136,6 +136,12 @@ export default defineComponent({
       this.onChange();
     });
   },
+  beforeUnmount() {
+    if (this._observer) {
+      this._observer.disconnect();
+      this._observer = null;
+    }
+  },
   methods: {
     onChange() {
       const newValue = this.$input.typedInput("value");

package/src/core/client/index.ts

@@ -203,7 +203,7 @@ function getNodeState(node: Node): NodeState {
   const state: NodeState = {
     credentials: {},
   };
-  Object.keys(node._def.defaults).forEach((prop) => {
+  Object.keys(node._def.defaults ?? {}).forEach((prop) => {
     state[prop] = node[prop];
   });
   if (node._def.credentials) {
@@ -300,8 +300,6 @@ function defineNode<T extends NodeDefinition>(options: T): T {
 async function registerType(definition: NodeDefinition): Promise<void> {
   const { type } = definition;
   try {
-    console.log(`Registering node type: ${type}`);
-
     const nodeDefinition = {
       ...(_schemas[type] ?? {}),
       ...definition,
@@ -311,9 +309,6 @@ async function registerType(definition: NodeDefinition): Promise<void> {
     const defaults = nodeDefinition.defaults ?? undefined;
     const credentials = nodeDefinition.credentials ?? undefined;
 
-    console.log("defaults", defaults);
-    console.log("credentials", credentials);
-
     const appContainerId = `nrg-app-${type}`;
 
     $("<script>", {
@@ -323,21 +318,20 @@ async function registerType(definition: NodeDefinition): Promise<void> {
     }).appendTo("body");
 
     function oneditprepare(this: Node) {
-      console.log("oneditprepare");
-      console.log(this);
-
-      const validationSchema = nodeDefinition.credentialsSchema?.properties
-        ? {
-            ...nodeDefinition.configSchema,
-            properties: {
-              ...nodeDefinition.configSchema.properties,
-              credentials: {
-                type: "object",
-                properties: nodeDefinition.credentialsSchema.properties,
+      const validationSchema =
+        nodeDefinition.configSchema &&
+        nodeDefinition.credentialsSchema?.properties
+          ? {
+              ...nodeDefinition.configSchema,
+              properties: {
+                ...nodeDefinition.configSchema.properties,
+                credentials: {
+                  type: "object",
+                  properties: nodeDefinition.credentialsSchema.properties,
+                },
               },
-            },
-          }
-        : nodeDefinition.configSchema;
+            }
+          : nodeDefinition.configSchema;
 
       const form =
         definition.form ??
@@ -360,7 +354,7 @@ async function registerType(definition: NodeDefinition): Promise<void> {
       const changed = !!Object.keys(changes)?.length;
       if (!changed) return false;
 
-      Object.keys(node._def.defaults).forEach((prop) => {
+      Object.keys(node._def.defaults ?? {}).forEach((prop) => {
         if (!node._def.defaults?.[prop]?.type) return;
         const oldConfigNodeId: string = node[prop] as string;
         const newConfigNodeId: string = node._newState![prop] as string;
@@ -376,7 +370,7 @@ async function registerType(definition: NodeDefinition): Promise<void> {
         }
       });
 
-      Object.keys(node._def.defaults).forEach((prop) => {
+      Object.keys(node._def.defaults ?? {}).forEach((prop) => {
         if (!node._def.defaults?.[prop]?.type) return;
         const newConfigNodeId: string = node._newState![prop] as string;
         if (!newConfigNodeId) return;
@@ -400,7 +394,7 @@ async function registerType(definition: NodeDefinition): Promise<void> {
       // overwriting the correctly-typed values already set by merge() above.
       const isConfigNode = definition.category === "config";
       if (isConfigNode) {
-        Object.keys(node._def.defaults).forEach((prop) => {
+        Object.keys(node._def.defaults ?? {}).forEach((prop) => {
           if (node._def.defaults[prop].type) return; // config-node refs handled separately
           const inputId = `node-config-input-${prop}`;
           let input = $(`#${inputId}`);
@@ -484,9 +478,7 @@ async function registerType(definition: NodeDefinition): Promise<void> {
  */
 async function registerTypes(nodes: NodeDefinition[]): Promise<void> {
   try {
-    console.log("Registering node types in parallel");
     await Promise.all(nodes.map((definition) => registerType(definition)));
-    console.log("All node types registered in parallel");
   } catch (error) {
     console.error("Error registering node types:", error);
     throw error;

package/src/core/errors.ts

@@ -0,0 +1,9 @@
+class NrgError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "NrgError";
+    Object.setPrototypeOf(this, NrgError.prototype);
+  }
+}
+
+export { NrgError };

package/src/core/server/index.ts

@@ -4,6 +4,7 @@ import { getCredentialsFromSchema } from "./utils";
 import { Node } from "./nodes";
 import { type RED } from "./types";
 import { initValidator } from "./validator";
+import { NrgError } from "../errors";
 
 const MIME: Record<string, string> = {
   ".js": "application/javascript",
@@ -32,9 +33,7 @@ function serveNrgResources(RED: RED): void {
   httpAdmin.use(function (req: any, res: any, next: any) {
     const prefix = "/nrg/assets/";
     if (!(req.path as string).startsWith(prefix)) return next();
-    let reqPath = (req.path as string)
-      .slice(prefix.length)
-      .replace(/\.\./g, "");
+    let reqPath = (req.path as string).slice(prefix.length);
     // Serve the Vue dev build in development for devtools support
     if (
       reqPath === "vue.esm-browser.prod.js" &&
@@ -46,7 +45,8 @@ function serveNrgResources(RED: RED): void {
       }
     }
     const filePath = path.resolve(clientDir, reqPath);
-    if (!filePath.startsWith(clientDir)) return next();
+    const rel = path.relative(clientDir, filePath);
+    if (rel.startsWith("..") || path.isAbsolute(rel)) return next();
     if (!fs.existsSync(filePath) || !fs.statSync(filePath).isFile())
       return next();
     const ext = path.extname(filePath);
@@ -70,24 +70,24 @@ async function registerType(RED: RED, NodeClass: AnyNodeClass) {
   const NC = NodeClass as any;
   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 !== undefined &&
-    (!Number.isInteger(NC.inputs) || (NC.inputs != 0 && NC.inputs != 1))
+    (!Number.isInteger(NC.inputs) || (NC.inputs !== 0 && NC.inputs !== 1))
   ) {
-    throw new Error(
+    throw new NrgError(
       `Invalid number of inputs for ${NodeClass.type}: inputs must be 0 or 1`,
     );
   }
@@ -96,7 +96,7 @@ async function registerType(RED: RED, NodeClass: AnyNodeClass) {
     NC.outputs !== undefined &&
     (!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`,
     );
   }
@@ -106,8 +106,14 @@ async function registerType(RED: RED, NodeClass: AnyNodeClass) {
     function (this: any, config: any) {
       RED.nodes.createNode(this, config);
       const node = new NC(RED, this, config, this.credentials);
-      // NOTE: save node intance inside node-red's node so that the proxy can resolve it lazyly
-      this._node = node;
+      // NOTE: save node instance inside node-red's node so that the proxy can resolve it lazily.
+      // Non-writable to prevent accidental clobbering by other code in the process.
+      Object.defineProperty(this, "_node", {
+        value: node,
+        writable: false,
+        configurable: false,
+        enumerable: false,
+      });
 
       // NOTE: created promise must be here because we only want it to start after the whole object creation chain has been completed: child -> IONode -> Node -> IONode -> child -> done
       const createdPromise = Promise.resolve(node.created?.()).catch(
@@ -214,6 +220,7 @@ function registerTypes(nodes: AnyNodeClass[]): NodeRedPackageFunction {
 
 export { registerType, registerTypes };
 export { Node, IONode, ConfigNode } from "./nodes";
+export { NrgError } from "../errors";
 export type { RED } from "./types";
 export { SchemaType, defineSchema } from "./schemas";
 export type { Schema, Infer } from "./schemas/types";

package/src/core/server/nodes/node.ts

@@ -115,7 +115,11 @@ abstract class Node<TConfig = any, TCredentials = any, TSettings = any> {
         );
       }
     }
-    (this as any).config = setupConfigProxy(RED, config);
+    (this as any).config = setupConfigProxy(
+      RED,
+      config,
+      constructor.configSchema,
+    );
 
     if (constructor.credentialsSchema && credentials) {
       this.log("Validating credentials");

package/src/core/server/nodes/utils.ts

@@ -1,6 +1,7 @@
 import type { ResolveNodeRefs } from "../schemas/types";
 import type { RED, NodeRedContextStore } from "../types";
 import type { NodeContextStore } from "./types";
+import { NrgError } from "../../errors";
 
 function setupContext(
   context: NodeRedContextStore,
@@ -31,50 +32,72 @@ function setupContext(
 function setupConfigProxy<T extends object>(
   RED: RED,
   config: T,
+  schema?: any,
 ): ResolveNodeRefs<T> {
-  // NOTE: must not proxy its own id or parents ids
   const SKIP_PROPS = new Set(["id", "_id", "_users"]);
 
+  // Build a set of property names that are node references based on the schema.
+  // Only these properties will have their string values resolved via RED.nodes.getNode().
+  const nodeRefProps = new Set<string>();
+  if (schema?.properties) {
+    for (const [key, propSchema] of Object.entries(schema.properties)) {
+      if ((propSchema as any)?.["x-nrg-node-type"]) {
+        nodeRefProps.add(key);
+      }
+    }
+  }
+
+  // Per-node-instance cache: original object/array -> proxy or mapped array.
+  // This preserves reference equality: config.server === config.server
+  const cache = new WeakMap<object, any>();
+
   const createProxy = <O extends object>(obj: O): any => {
-    return new Proxy(obj, {
-      get(target: any, prop: string | symbol): any {
-        if (typeof prop === "symbol") {
-          return target[prop];
-        }
+    const cached = cache.get(obj);
+    if (cached) return cached;
 
-        if (SKIP_PROPS.has(prop)) {
-          return target[prop];
+    if (Array.isArray(obj)) {
+      // Map once, cache the result array so identity is stable across reads
+      const mapped = obj.map((item) => {
+        if (item && typeof item === "object") {
+          return createProxy(item);
         }
+        return item;
+      });
+      cache.set(obj, mapped);
+      return mapped;
+    }
 
-        const value = target[prop];
+    const proxy = new Proxy(obj, {
+      get(target: any, prop: string | symbol): any {
+        if (typeof prop === "symbol") return target[prop];
+        if (SKIP_PROPS.has(prop)) return target[prop];
 
-        if (typeof value === "string" && value.length > 0) {
-          // NOTE: using the instance provided by the user instead of node-red's internal one
-          const node = RED.nodes.getNode(value)?._node;
-          return node || value;
-        }
+        const value = target[prop];
 
-        if (Array.isArray(value)) {
-          return value.map((item) => {
-            if (typeof item === "string") {
-              // NOTE: using the instance provided by the user instead of node-red's internal one
-              const node = RED.nodes.getNode(item)?._node;
-              return node || item;
-            }
-            if (item && typeof item === "object") {
-              return createProxy(item);
-            }
-            return item;
-          });
+        // Only resolve strings as node references if the schema marks the property
+        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 createProxy(value); // hits the cache on repeat access
         }
 
         return value;
       },
+      set(_target: any, prop: string | symbol): boolean {
+        throw new NrgError(
+          `Cannot set property '${String(prop)}' on read-only node config`,
+        );
+      },
     });
+
+    cache.set(obj, proxy);
+    return proxy;
   };
 
   return createProxy(config) as ResolveNodeRefs<T>;

package/src/vite/client/build.ts

@@ -217,7 +217,9 @@ async function build(
     throw new BuildError("client", error as Error);
   } finally {
     if (generatedEntry) {
-      fs.unlinkSync(entryPath);
+      if (fs.existsSync(entryPath)) {
+        fs.unlinkSync(entryPath);
+      }
     }
   }
 }