@bonsae/nrg 0.6.3 → 0.8.0

package/README.md

@@ -14,10 +14,12 @@ Build Node-RED nodes with Vue 3, TypeScript, and JSON Schema validation.
 ## Install
 
 ```bash
-pnpm add @bonsae/nrg vue
-pnpm add -D vite
+pnpm add @bonsae/nrg
+pnpm add -D vite vue
 ```
 
+> `vite` and `vue` are dev dependencies because they are only needed at build time. The Vue runtime is bundled by nrg and served automatically — your published package does not need them at runtime.
+
 ## Package Exports
 
 | Export | Description |
@@ -32,8 +34,8 @@ pnpm add -D vite
 
 ```bash
 # In your Node-RED package project
-pnpm add @bonsae/nrg vue
-pnpm add -D vite
+pnpm add @bonsae/nrg
+pnpm add -D vite vue
 ```
 
 **vite.config.ts**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bonsae/nrg",
-  "version": "0.6.3",
+  "version": "0.8.0",
   "description": "NRG framework — build Node-RED nodes with Vue 3, TypeScript, and JSON Schema",
   "author": "Allan Oricil <allanoricil@duck.com>",
   "license": "MIT",

package/server/index.cjs

@@ -103,11 +103,11 @@ var Validator = class {
    */
   addCustomFormats(formats) {
     if (!formats) return;
-    Object.entries(formats).forEach(([name, validator3]) => {
-      if (validator3 instanceof RegExp) {
-        this.ajv.addFormat(name, validator3);
+    Object.entries(formats).forEach(([name, validator2]) => {
+      if (validator2 instanceof RegExp) {
+        this.ajv.addFormat(name, validator2);
       } else {
-        this.ajv.addFormat(name, { validate: validator3 });
+        this.ajv.addFormat(name, { validate: validator2 });
       }
     });
   }
@@ -124,23 +124,23 @@ var Validator = class {
       const cached = this.ajv.getSchema(schema.$id);
       if (cached) return cached;
     }
-    const validator3 = this.ajv.compile(schema);
-    return validator3;
+    const validator2 = this.ajv.compile(schema);
+    return validator2;
   }
   /**
    * Validate data against a schema and return a structured result
    */
   validate(data, schema, options) {
-    const validator3 = this.createValidator(schema, options?.cacheKey);
-    const valid = validator3(data);
+    const validator2 = this.createValidator(schema, options?.cacheKey);
+    const valid = validator2(data);
     if (!valid) {
-      const errorMessage = this.formatErrors(validator3.errors);
+      const errorMessage = this.formatErrors(validator2.errors);
       if (options?.throwOnError) {
-        throw new ValidationError(errorMessage, validator3.errors || []);
+        throw new ValidationError(errorMessage, validator2.errors || []);
       }
       return {
         valid: false,
-        errors: validator3.errors || void 0,
+        errors: validator2.errors || void 0,
         errorMessage
       };
     }
@@ -198,39 +198,33 @@ var ValidationError = class _ValidationError extends Error {
     Object.setPrototypeOf(this, _ValidationError.prototype);
   }
 };
-var validator = new Validator();
 
-// src/core/server/validator.ts
-var NodeRedValidator = class extends Validator {
-  constructor(RED) {
-    super({
-      customKeywords: [
-        {
-          keyword: "x-nrg-skip-validation",
-          schemaType: "boolean",
-          valid: true
-        },
-        {
-          keyword: "x-nrg-node-type",
-          type: "string",
-          validate: (schemaValue, dataValue) => {
-            if (!dataValue) return true;
-            const node = RED.nodes.getNode(dataValue);
-            return node?.type === schemaValue;
-          }
+// src/core/server/validation.ts
+var validator = void 0;
+function initValidator(RED) {
+  validator = new Validator({
+    customKeywords: [
+      {
+        keyword: "x-nrg-skip-validation",
+        schemaType: "boolean",
+        valid: true
+      },
+      {
+        keyword: "x-nrg-node-type",
+        type: "string",
+        validate: (schemaValue, dataValue) => {
+          if (!dataValue) return true;
+          const node = RED.nodes.getNode(dataValue);
+          return node?.type === schemaValue;
         }
-      ],
-      customFormats: {
-        "node-id": /^[a-zA-Z0-9-_]+$/,
-        "flow-id": /^[a-f0-9]{16}$/,
-        "topic-path": (data) => /^[a-zA-Z0-9/_-]+$/.test(data)
       }
-    });
-  }
-};
-var validator2 = void 0;
-function initValidator(RED) {
-  validator2 = new NodeRedValidator(RED);
+    ],
+    customFormats: {
+      "node-id": /^[a-zA-Z0-9-_]+$/,
+      "flow-id": /^[a-f0-9]{16}$/,
+      "topic-path": (data) => /^[a-zA-Z0-9/_-]+$/.test(data)
+    }
+  });
 }
 
 // src/core/errors.ts
@@ -242,6 +236,40 @@ var NrgError = class _NrgError extends Error {
   }
 };
 
+// src/core/server/typed-input.ts
+var TypedInput = class {
+  constructor(RED, node, input) {
+    this.RED = RED;
+    this.node = node;
+    this.input = input;
+  }
+  resolvers = {
+    // NOTE: NRG nodes are wrapped — surface the NRG instance, fall back to raw NodeRedNode
+    node: (raw) => raw?._node ?? raw
+  };
+  get type() {
+    return this.input.type;
+  }
+  get value() {
+    return this.input.value;
+  }
+  resolve(msg) {
+    return new Promise((resolve, reject) => {
+      this.RED.util.evaluateNodeProperty(
+        this.input.value,
+        this.input.type,
+        this.node,
+        msg,
+        (err, raw) => {
+          if (err) return reject(err);
+          const post = this.resolvers[this.input.type];
+          resolve(post ? post(raw) : raw);
+        }
+      );
+    });
+  }
+};
+
 // src/core/server/nodes/utils.ts
 function setupContext(context, store) {
   return {
@@ -265,14 +293,16 @@ function setupContext(context, store) {
     )
   };
 }
-function setupConfigProxy(RED, config, schema) {
+function setupConfigProxy(opts) {
+  const { RED, node, config, schema } = opts;
   const SKIP_PROPS = /* @__PURE__ */ new Set(["id", "_id", "_users"]);
   const nodeRefProps = /* @__PURE__ */ new Set();
+  const typedInputProps = /* @__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 s = propSchema;
+      if (s?.["x-nrg-node-type"]) nodeRefProps.add(key);
+      if (s?.["x-nrg-typed-input"]) typedInputProps.add(key);
     }
   }
   const cache = /* @__PURE__ */ new WeakMap();
@@ -280,12 +310,9 @@ function setupConfigProxy(RED, config, schema) {
     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;
-      });
+      const mapped = obj.map(
+        (item) => item && typeof item === "object" ? createProxy(item) : item
+      );
       cache.set(obj, mapped);
       return mapped;
     }
@@ -297,6 +324,14 @@ function setupConfigProxy(RED, config, schema) {
         if (typeof value === "string" && value.length > 0 && nodeRefProps.has(prop)) {
           return RED.nodes.getNode(value)?._node ?? value;
         }
+        if (typedInputProps.has(prop) && value && typeof value === "object" && "type" in value && "value" in value) {
+          let ref = cache.get(value);
+          if (!ref) {
+            ref = new TypedInput(RED, node, value);
+            cache.set(value, ref);
+          }
+          return ref;
+        }
         if (value && typeof value === "object") {
           return createProxy(value);
         }
@@ -358,7 +393,7 @@ var Node = class {
         }
       }
     }
-    validator2.validate(settings, this.settingsSchema, {
+    validator.validate(settings, this.settingsSchema, {
       cacheKey: this.settingsSchema.$id || `${this.type}:settings`,
       throwOnError: true
     });
@@ -377,7 +412,7 @@ var Node = class {
     const constructor = this.constructor;
     if (constructor.configSchema) {
       this.log("Validating configs");
-      const configResult = validator2.validate(
+      const configResult = validator.validate(
         config,
         constructor.configSchema,
         {
@@ -391,14 +426,15 @@ var Node = class {
         );
       }
     }
-    this.config = setupConfigProxy(
+    this.config = setupConfigProxy({
       RED,
+      node,
       config,
-      constructor.configSchema
-    );
+      schema: constructor.configSchema
+    });
     if (constructor.credentialsSchema && credentials) {
       this.log("Validating credentials");
-      const credResult = validator2.validate(
+      const credResult = validator.validate(
         credentials,
         constructor.credentialsSchema,
         {
@@ -438,28 +474,6 @@ var Node = class {
     clearInterval(interval);
     this.intervals.delete(interval);
   }
-  // NOTE: typing msg isnt necessary in this case
-  resolveTypedInput(typedInput, msg) {
-    return new Promise((resolve, reject) => {
-      this.RED.util.evaluateNodeProperty(
-        typedInput.value,
-        typedInput.type,
-        this.node,
-        msg,
-        (error, result) => {
-          if (error) {
-            reject(error);
-            return;
-          }
-          if (typedInput.type === "node" && result) {
-            resolve(result._node ?? result);
-            return;
-          }
-          resolve(result);
-        }
-      );
-    });
-  }
   // NOTE: used by the registered function. Had to be a different one to avoid calling the parent's closed again
   /** @internal */
   async _closed(removed) {
@@ -545,7 +559,7 @@ var IONode = class extends Node {
     const shouldValidateInput = this.config.validateInput ?? NodeClass.validateInput;
     if (shouldValidateInput && NodeClass.inputSchema) {
       this.log("Validating input");
-      validator2.validate(msg, NodeClass.inputSchema, {
+      validator.validate(msg, NodeClass.inputSchema, {
         cacheKey: NodeClass.inputSchema.$id || `${NodeClass.type}:input-schema`,
         throwOnError: true
       });
@@ -568,7 +582,7 @@ var IONode = class extends Node {
         const msgs = msg;
         for (let i = 0; i < schemas.length; i++) {
           if (msgs[i] == null) continue;
-          validator2.validate(msgs[i], schemas[i], {
+          validator.validate(msgs[i], schemas[i], {
             cacheKey: schemas[i].$id || `${NodeClass.type}:output-schema:${i}`,
             throwOnError: true
           });
@@ -576,13 +590,13 @@ var IONode = class extends Node {
       } else if (Array.isArray(msg)) {
         for (let i = 0; i < msg.length; i++) {
           if (msg[i] == null) continue;
-          validator2.validate(msg[i], schemas, {
+          validator.validate(msg[i], schemas, {
             cacheKey: schemas.$id || `${NodeClass.type}:output-schema`,
             throwOnError: true
           });
         }
       } else {
-        validator2.validate(msg, schemas, {
+        validator.validate(msg, schemas, {
           cacheKey: schemas.$id || `${NodeClass.type}:output-schema`,
           throwOnError: true
         });
@@ -801,16 +815,17 @@ function NodeRef(nodeClass, options) {
     [import_typebox.Kind]: "NodeRef"
   };
 }
-function TypedInput(options) {
+function TypedInput2(options) {
   return {
     ...TypedInputSchema,
+    "x-nrg-typed-input": true,
     ...options,
     [import_typebox.Kind]: "TypedInput"
   };
 }
 var SchemaType = Object.assign({}, import_typebox.Type, {
   NodeRef,
-  TypedInput
+  TypedInput: TypedInput2
 });
 function markNonValidatable(schema) {
   const type = schema.type;