@bonsae/nrg 0.10.0 → 0.10.1

package/README.md

@@ -155,6 +155,9 @@ src/
 │   │   └── 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
@@ -167,6 +170,37 @@ src/
     └── server.json
 ```
 
+## Testing
+
+Test your nodes' server-side logic with `@bonsae/nrg/test`:
+
+```bash
+pnpm add -D vitest
+```
+
+```typescript
+// tests/my-node.test.ts
+import { describe, it, expect } from "vitest";
+import { createNode } from "@bonsae/nrg/test";
+import MyNode from "../src/server/nodes/my-node";
+
+describe("my-node", () => {
+  it("should process messages", async () => {
+    const { node } = await createNode(MyNode, {
+      config: { greeting: "hello" },
+    });
+
+    await node.receive({ payload: "world" });
+
+    expect(node.sent(0)).toEqual([{ payload: "hello world" }]);
+  });
+});
+```
+
+```bash
+npx vitest run
+```
+
 ## Development
 
 ```bash

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bonsae/nrg",
-  "version": "0.10.0",
+  "version": "0.10.1",
   "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

@@ -39,6 +39,7 @@ __export(index_exports, {
   defineIONode: () => defineIONode,
   defineModule: () => defineModule,
   defineSchema: () => defineSchema,
+  initValidator: () => initValidator,
   registerType: () => registerType,
   registerTypes: () => registerTypes
 });
@@ -1043,6 +1044,7 @@ function defineModule(definition) {
   defineIONode,
   defineModule,
   defineSchema,
+  initValidator,
   registerType,
   registerTypes
 });

package/test/index.js

@@ -145,175 +145,8 @@ function createMockNodeRedNode(options = {}) {
   };
 }
 
-// src/core/validator.ts
-import Ajv from "ajv";
-import addFormats from "ajv-formats";
-import addErrors from "ajv-errors";
-var Validator = class {
-  ajv;
-  constructor(options) {
-    const { customKeywords, customFormats, ...ajvOptions } = options || {};
-    this.ajv = new Ajv({
-      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
-    });
-    addFormats(this.ajv);
-    addErrors(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/test/index.ts
+import { initValidator } from "@bonsae/nrg/server";
 function buildConfig(NodeClass, userConfig = {}) {
   const defaults = {};
   if (NodeClass.configSchema?.properties) {