@bonsae/nrg 0.13.0 → 0.14.0

package/README.md

@@ -17,10 +17,10 @@ Build Node-RED nodes with Vue 3, TypeScript, and JSON Schema validation.
 
 ```bash
 pnpm add @bonsae/nrg
-pnpm add -D vite vue
+pnpm add -D vite
 ```
 
-> `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.
+> `vite` is a dev dependency because it is only needed at build time. Vue is included as a dependency of nrg and served automatically at runtime.
 
 ## Package Exports
 
@@ -37,7 +37,7 @@ pnpm add -D vite vue
 ```bash
 # In your Node-RED package project
 pnpm add @bonsae/nrg
-pnpm add -D vite vue
+pnpm add -D vite
 ```
 
 **vite.config.ts**
@@ -135,43 +135,6 @@ export default defineModule({
 
 See the [consumer template](https://github.com/AllanOricil/node-red-vue-template) for a complete example.
 
-## Project Structure
-
-```
-src/
-├── core/                        # Runtime framework
-│   ├── client/                  # Vue 3 editor components
-│   │   ├── app.vue              # Root form wrapper (validation, toggles)
-│   │   ├── components/          # Reusable form inputs
-│   │   │   ├── node-red-input.vue
-│   │   │   ├── node-red-typed-input.vue
-│   │   │   ├── node-red-config-input.vue
-│   │   │   ├── node-red-select-input.vue
-│   │   │   ├── node-red-editor-input.vue
-│   │   │   └── node-red-json-schema-form.vue
-│   │   └── index.ts             # registerType, defineNode
-│   ├── server/                  # Node.js server runtime
-│   │   ├── nodes/               # Node, IONode, ConfigNode classes
-│   │   ├── schemas/             # TypeBox schema system
-│   │   ├── types/               # RED, context store types
-│   │   └── index.ts             # registerTypes, exports
-│   ├── constants.ts
-│   └── validator.ts             # AJV-based validation
-├── test/                        # Test utilities for consumers
-│   ├── index.ts                 # createNode, receive, close, reset
-│   └── mocks.ts                 # RED and Node-RED node mocks
-├── vite/                        # Build tooling
-│   ├── plugin.ts                # Vite plugin factory
-│   ├── plugins/                 # Dev server, build orchestration
-│   ├── server/                  # Server build (CJS/ESM + bridge)
-│   ├── client/                  # Client build (Vue + auto-wiring)
-│   └── index.ts                 # nodeRed(), defineRuntimeSettings()
-└── tsconfig/                    # Shared configs for consumers
-    ├── base.json
-    ├── client.json
-    └── server.json
-```
-
 ## Testing
 
 Test your nodes' server-side logic with `@bonsae/nrg/test`:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bonsae/nrg",
-  "version": "0.13.0",
+  "version": "0.14.0",
   "description": "NRG framework — build Node-RED nodes with Vue 3, TypeScript, and JSON Schema",
   "author": "Allan Oricil <allanoricil@duck.com>",
   "license": "MIT",
@@ -62,6 +62,7 @@
     "tree-kill": "^1.2.2",
     "typescript": "^5.8.3",
     "vite-plugin-dts": "^4.5.4",
-    "vite-plugin-static-copy": "^3.1.0"
+    "vite-plugin-static-copy": "^3.1.0",
+    "vue": "^3.5.14"
   }
 }

package/server/index.cjs

@@ -39,7 +39,6 @@ __export(index_exports, {
   defineIONode: () => defineIONode,
   defineModule: () => defineModule,
   defineSchema: () => defineSchema,
-  initValidator: () => initValidator,
   registerType: () => registerType,
   registerTypes: () => registerTypes
 });
@@ -60,174 +59,6 @@ function getCredentialsFromSchema(schema) {
   return result;
 }
 
-// src/core/validator.ts
-var import_ajv = __toESM(require("ajv"), 1);
-var import_ajv_formats = __toESM(require("ajv-formats"), 1);
-var import_ajv_errors = __toESM(require("ajv-errors"), 1);
-var Validator = class {
-  ajv;
-  constructor(options) {
-    const { customKeywords, customFormats, ...ajvOptions } = options || {};
-    this.ajv = new import_ajv.default({
-      allErrors: true,
-      code: {
-        source: false
-      },
-      coerceTypes: true,
-      removeAdditional: false,
-      strict: false,
-      strictSchema: false,
-      useDefaults: true,
-      validateFormats: true,
-      // NOTE: typebox handles validation via typescript
-      // NOTE: if true, types that are not serializable JSON, like Function, would not work
-      validateSchema: false,
-      verbose: true,
-      ...ajvOptions
-    });
-    (0, import_ajv_formats.default)(this.ajv);
-    (0, import_ajv_errors.default)(this.ajv);
-    this.addCustomKeywords(customKeywords || []);
-    this.addCustomFormats(customFormats || {});
-  }
-  /**
-   * Add custom keywords to the validator
-   */
-  addCustomKeywords(keywords) {
-    if (!keywords) return;
-    keywords.forEach((keyword) => {
-      this.ajv.addKeyword(keyword);
-    });
-  }
-  /**
-   * Add custom formats to the validator
-   */
-  addCustomFormats(formats) {
-    if (!formats) return;
-    Object.entries(formats).forEach(([name, validator2]) => {
-      if (validator2 instanceof RegExp) {
-        this.ajv.addFormat(name, validator2);
-      } else {
-        this.ajv.addFormat(name, { validate: validator2 });
-      }
-    });
-  }
-  /**
-   * Create a validator function with caching
-   * @param schema - JSON Schema to validate against
-   * @param cacheKey - Optional cache key for reusing validators
-   */
-  createValidator(schema, cacheKey) {
-    if (cacheKey && !schema.$id) {
-      schema.$id = cacheKey;
-    }
-    if (schema.$id) {
-      const cached = this.ajv.getSchema(schema.$id);
-      if (cached) return cached;
-    }
-    const validator2 = this.ajv.compile(schema);
-    return validator2;
-  }
-  /**
-   * Validate data against a schema and return a structured result
-   */
-  validate(data, schema, options) {
-    const validator2 = this.createValidator(schema, options?.cacheKey);
-    const valid = validator2(data);
-    if (!valid) {
-      const errorMessage = this.formatErrors(validator2.errors);
-      if (options?.throwOnError) {
-        throw new ValidationError(errorMessage, validator2.errors || []);
-      }
-      return {
-        valid: false,
-        errors: validator2.errors || void 0,
-        errorMessage
-      };
-    }
-    return {
-      valid: true,
-      data
-    };
-  }
-  /**
-   * Format errors into a human-readable string
-   */
-  formatErrors(errors, options) {
-    if (!errors || errors.length === 0) {
-      return "No errors";
-    }
-    return this.ajv.errorsText(errors, {
-      separator: "; ",
-      dataVar: "data",
-      ...options
-    });
-  }
-  /**
-   * Get detailed error information
-   */
-  getDetailedErrors(errors) {
-    if (!errors || errors.length === 0) return [];
-    return errors.map((error) => ({
-      field: error.instancePath || "/",
-      message: error.message || "Validation failed",
-      keyword: error.keyword,
-      params: error.params,
-      schemaPath: error.schemaPath
-    }));
-  }
-  /**
-   * Add a schema to the validator for reference
-   */
-  addSchema(schema, key) {
-    this.ajv.addSchema(schema, key);
-    return this;
-  }
-  /**
-   * Remove a schema from the validator
-   */
-  removeSchema(key) {
-    this.ajv.removeSchema(key);
-    return this;
-  }
-};
-var ValidationError = class _ValidationError extends Error {
-  constructor(message, errors) {
-    super(message);
-    this.errors = errors;
-    this.name = "ValidationError";
-    Object.setPrototypeOf(this, _ValidationError.prototype);
-  }
-};
-
-// 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)
-    }
-  });
-}
-
 // src/core/errors.ts
 var NrgError = class _NrgError extends Error {
   constructor(message) {
@@ -402,7 +233,7 @@ var Node = class {
         }
       }
     }
-    validator.validate(settings, this.settingsSchema, {
+    RED.validator.validate(settings, this.settingsSchema, {
       cacheKey: this.settingsSchema.$id || `${this.type}:settings`,
       throwOnError: true
     });
@@ -421,7 +252,7 @@ var Node = class {
     const constructor = this.constructor;
     if (constructor.configSchema) {
       this.log("Validating configs");
-      const configResult = validator.validate(
+      const configResult = this.RED.validator.validate(
         config,
         constructor.configSchema,
         {
@@ -443,7 +274,7 @@ var Node = class {
     });
     if (constructor.credentialsSchema && credentials) {
       this.log("Validating credentials");
-      const credResult = validator.validate(
+      const credResult = this.RED.validator.validate(
         credentials,
         constructor.credentialsSchema,
         {
@@ -572,7 +403,7 @@ var IONode = class extends Node {
     const shouldValidateInput = this.config.validateInput ?? NodeClass.validateInput;
     if (shouldValidateInput && NodeClass.inputSchema) {
       this.log("Validating input");
-      validator.validate(msg, NodeClass.inputSchema, {
+      this.RED.validator.validate(msg, NodeClass.inputSchema, {
         cacheKey: NodeClass.inputSchema.$id || `${NodeClass.type}:input-schema`,
         throwOnError: true
       });
@@ -595,7 +426,7 @@ var IONode = class extends Node {
         const msgs = msg;
         for (let i = 0; i < schemas.length; i++) {
           if (msgs[i] == null) continue;
-          validator.validate(msgs[i], schemas[i], {
+          this.RED.validator.validate(msgs[i], schemas[i], {
             cacheKey: schemas[i].$id || `${NodeClass.type}:output-schema:${i}`,
             throwOnError: true
           });
@@ -603,13 +434,13 @@ var IONode = class extends Node {
       } else if (Array.isArray(msg)) {
         for (let i = 0; i < msg.length; i++) {
           if (msg[i] == null) continue;
-          validator.validate(msg[i], schemas, {
+          this.RED.validator.validate(msg[i], schemas, {
             cacheKey: schemas.$id || `${NodeClass.type}:output-schema`,
             throwOnError: true
           });
         }
       } else {
-        validator.validate(msg, schemas, {
+        this.RED.validator.validate(msg, schemas, {
           cacheKey: schemas.$id || `${NodeClass.type}:output-schema`,
           throwOnError: true
         });
@@ -635,31 +466,40 @@ var IONode = class extends Node {
     if (this.config.emitStatus) count++;
     return count;
   }
+  /**
+   * Send a message to a specific output port by index or name.
+   * Named ports: `"error"`, `"complete"`, `"status"` — resolved automatically
+   * based on the node's emit port configuration.
+   * Numeric indices refer to the base output ports (0-based).
+   */
+  sendToPort(port, msg) {
+    this._sendToPort(port, msg);
+  }
   /** @internal */
-  _sendToPort(portIndex, msg) {
+  _sendToPort(port, msg) {
+    let portIndex;
+    if (typeof port === "number") {
+      portIndex = port;
+    } else {
+      portIndex = this._getEmitPortIndex(port);
+      if (portIndex === null) return;
+    }
     const out = Array(this._totalOutputs).fill(null);
     out[portIndex] = msg;
     this.node.send(out);
   }
-  /** @internal */
-  _getErrorPortIndex() {
-    if (!this.config.emitError) return null;
-    return this._baseOutputs;
-  }
-  /** @internal */
-  _getCompletePortIndex() {
-    if (!this.config.emitComplete) return null;
-    let idx = this._baseOutputs;
-    if (this.config.emitError) idx++;
-    return idx;
-  }
-  /** @internal */
-  _getStatusPortIndex() {
-    if (!this.config.emitStatus) return null;
+  _getEmitPortIndex(name) {
+    const config = this.config;
+    if (name === "error") {
+      return config.emitError ? this._baseOutputs : null;
+    }
     let idx = this._baseOutputs;
-    if (this.config.emitError) idx++;
-    if (this.config.emitComplete) idx++;
-    return idx;
+    if (config.emitError) idx++;
+    if (name === "complete") {
+      return config.emitComplete ? idx : null;
+    }
+    if (config.emitComplete) idx++;
+    return config.emitStatus ? idx : null;
   }
   _nodeSource() {
     return {
@@ -670,19 +510,15 @@ var IONode = class extends Node {
   }
   status(status) {
     this.node.status(status);
-    const portIdx = this._getStatusPortIndex();
-    if (portIdx !== null) {
-      this._sendToPort(portIdx, {
-        status,
-        source: this._nodeSource()
-      });
-    }
+    this._sendToPort("status", {
+      status,
+      source: this._nodeSource()
+    });
   }
   error(message, msg) {
     super.error(message, msg);
-    const portIdx = this._getErrorPortIndex();
-    if (portIdx !== null && msg) {
-      this._sendToPort(portIdx, {
+    if (msg) {
+      this._sendToPort("error", {
         ...msg,
         error: {
           message,
@@ -815,29 +651,208 @@ function defineConfigNode(def) {
   return NodeClass;
 }
 
-// src/core/server/api/nrg-assets.ts
+// src/core/validator.ts
+var import_ajv = __toESM(require("ajv"), 1);
+var import_ajv_formats = __toESM(require("ajv-formats"), 1);
+var import_ajv_errors = __toESM(require("ajv-errors"), 1);
+var Validator = class {
+  ajv;
+  constructor(options) {
+    const { customKeywords, customFormats, ...ajvOptions } = options || {};
+    this.ajv = new import_ajv.default({
+      allErrors: true,
+      code: {
+        source: false
+      },
+      coerceTypes: true,
+      removeAdditional: false,
+      strict: false,
+      strictSchema: false,
+      useDefaults: true,
+      validateFormats: true,
+      // NOTE: typebox handles validation via typescript
+      // NOTE: if true, types that are not serializable JSON, like Function, would not work
+      validateSchema: false,
+      verbose: true,
+      ...ajvOptions
+    });
+    (0, import_ajv_formats.default)(this.ajv);
+    (0, import_ajv_errors.default)(this.ajv);
+    this.addCustomKeywords(customKeywords || []);
+    this.addCustomFormats(customFormats || {});
+  }
+  /**
+   * Add custom keywords to the validator
+   */
+  addCustomKeywords(keywords) {
+    if (!keywords) return;
+    keywords.forEach((keyword) => {
+      this.ajv.addKeyword(keyword);
+    });
+  }
+  /**
+   * Add custom formats to the validator
+   */
+  addCustomFormats(formats) {
+    if (!formats) return;
+    Object.entries(formats).forEach(([name, validator]) => {
+      if (validator instanceof RegExp) {
+        this.ajv.addFormat(name, validator);
+      } else {
+        this.ajv.addFormat(name, { validate: validator });
+      }
+    });
+  }
+  /**
+   * Create a validator function with caching
+   * @param schema - JSON Schema to validate against
+   * @param cacheKey - Optional cache key for reusing validators
+   */
+  createValidator(schema, cacheKey) {
+    if (cacheKey && !schema.$id) {
+      schema.$id = cacheKey;
+    }
+    if (schema.$id) {
+      const cached = this.ajv.getSchema(schema.$id);
+      if (cached) return cached;
+    }
+    const validator = this.ajv.compile(schema);
+    return validator;
+  }
+  /**
+   * Validate data against a schema and return a structured result
+   */
+  validate(data, schema, options) {
+    const validator = this.createValidator(schema, options?.cacheKey);
+    const valid = validator(data);
+    if (!valid) {
+      const errorMessage = this.formatErrors(validator.errors);
+      if (options?.throwOnError) {
+        throw new ValidationError(errorMessage, validator.errors || []);
+      }
+      return {
+        valid: false,
+        errors: validator.errors || void 0,
+        errorMessage
+      };
+    }
+    return {
+      valid: true,
+      data
+    };
+  }
+  /**
+   * Format errors into a human-readable string
+   */
+  formatErrors(errors, options) {
+    if (!errors || errors.length === 0) {
+      return "No errors";
+    }
+    return this.ajv.errorsText(errors, {
+      separator: "; ",
+      dataVar: "data",
+      ...options
+    });
+  }
+  /**
+   * Get detailed error information
+   */
+  getDetailedErrors(errors) {
+    if (!errors || errors.length === 0) return [];
+    return errors.map((error) => ({
+      field: error.instancePath || "/",
+      message: error.message || "Validation failed",
+      keyword: error.keyword,
+      params: error.params,
+      schemaPath: error.schemaPath
+    }));
+  }
+  /**
+   * Add a schema to the validator for reference
+   */
+  addSchema(schema, key) {
+    this.ajv.addSchema(schema, key);
+    return this;
+  }
+  /**
+   * Remove a schema from the validator
+   */
+  removeSchema(key) {
+    this.ajv.removeSchema(key);
+    return this;
+  }
+};
+var ValidationError = class _ValidationError extends Error {
+  constructor(message, errors) {
+    super(message);
+    this.errors = errors;
+    this.name = "ValidationError";
+    Object.setPrototypeOf(this, _ValidationError.prototype);
+  }
+};
+
+// src/core/server/validation.ts
+function initValidator(RED) {
+  const nrg = {
+    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)
+      }
+    })
+  };
+  Object.defineProperty(RED, "_nrg", {
+    value: nrg,
+    writable: false,
+    enumerable: false,
+    configurable: false
+  });
+  Object.defineProperty(RED, "validator", {
+    get: () => nrg.validator,
+    enumerable: false,
+    configurable: false
+  });
+}
+
+// src/core/server/api/assets.ts
 var import_path = __toESM(require("path"), 1);
 var import_fs = __toESM(require("fs"), 1);
-var RESOURCES_DIR = import_path.default.resolve(__dirname, "./resources");
-var ALLOWED_FILES = /* @__PURE__ */ new Set([
-  "nrg-client.js",
-  "vue.esm-browser.prod.js",
-  "vue.esm-browser.js"
-]);
-var handleNrgAsset = (req, res, next) => {
-  let fileName = req.params[0];
-  if (fileName === "vue.esm-browser.prod.js" && process.env.NODE_ENV !== "production") {
-    fileName = "vue.esm-browser.js";
-  }
-  if (!ALLOWED_FILES.has(fileName)) return next();
-  const filePath = import_path.default.join(RESOURCES_DIR, fileName);
-  if (!import_fs.default.existsSync(filePath)) return next();
-  res.setHeader("Content-Type", "application/javascript");
-  import_fs.default.createReadStream(filePath).pipe(res);
-};
-function initNrgAssetsRoute(router) {
-  if (!import_fs.default.existsSync(RESOURCES_DIR)) return;
-  router.get("/nrg/assets/*", handleNrgAsset);
+var import_module = require("module");
+function serveFile(filePath) {
+  return (_req, res, next) => {
+    if (!import_fs.default.existsSync(filePath)) return next();
+    res.setHeader("Content-Type", "application/javascript");
+    import_fs.default.createReadStream(filePath).pipe(res);
+  };
+}
+function initAssetsRoutes(router) {
+  const resourcesDir = import_path.default.resolve(__dirname, "./resources");
+  if (!import_fs.default.existsSync(resourcesDir)) return;
+  const _require = (0, import_module.createRequire)(import_path.default.join(__dirname, "package.json"));
+  const vueFile = process.env.NODE_ENV !== "production" ? _require.resolve("vue/dist/vue.esm-browser.js") : _require.resolve("vue/dist/vue.esm-browser.prod.js");
+  router.get(
+    "/nrg/assets/nrg-client.js",
+    serveFile(import_path.default.join(resourcesDir, "nrg-client.js"))
+  );
+  router.get("/nrg/assets/vue.esm-browser.prod.js", serveFile(vueFile));
+  router.get("/nrg/assets/vue.esm-browser.js", serveFile(vueFile));
 }
 
 // src/core/server/api/routes.ts
@@ -845,7 +860,7 @@ var _initialized = false;
 function initRoutes(RED) {
   if (_initialized) return;
   _initialized = true;
-  initNrgAssetsRoute(RED.httpAdmin);
+  initAssetsRoutes(RED.httpAdmin);
 }
 
 // src/core/constants.ts
@@ -1025,15 +1040,12 @@ async function registerType(RED, NodeClass) {
           try {
             this.log("Calling input");
             await Promise.resolve(node._input(msg, send));
-            const completeIdx = node._getCompletePortIndex();
-            if (completeIdx !== null) {
-              node._sendToPort(completeIdx, {
-                ...msg,
-                complete: {
-                  source: { id: node.id, type: NC.type, name: node.name }
-                }
-              });
-            }
+            node._sendToPort("complete", {
+              ...msg,
+              complete: {
+                source: { id: node.id, type: NC.type, name: node.name }
+              }
+            });
             done();
             this.log("Input processed");
           } catch (error) {
@@ -1118,7 +1130,6 @@ function defineModule(definition) {
   defineIONode,
   defineModule,
   defineSchema,
-  initValidator,
   registerType,
   registerTypes
 });