@bonsae/nrg 0.9.1 → 0.10.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bonsae/nrg",
-  "version": "0.9.1",
+  "version": "0.10.0",
   "description": "NRG framework — build Node-RED nodes with Vue 3, TypeScript, and JSON Schema",
   "author": "Allan Oricil <allanoricil@duck.com>",
   "license": "MIT",
@@ -33,6 +33,10 @@
       "types": "./types/vite.d.ts",
       "default": "./vite/index.js"
     },
+    "./test": {
+      "types": "./types/test.d.ts",
+      "default": "./test/index.js"
+    },
     "./tsconfig/base.json": "./tsconfig/base.json",
     "./tsconfig/client.json": "./tsconfig/client.json",
     "./tsconfig/server.json": "./tsconfig/server.json"

package/test/index.js

@@ -0,0 +1,440 @@
+// src/test/index.ts
+import { vi as vi2 } from "vitest";
+
+// src/test/mocks.ts
+import { vi } from "vitest";
+function createMockRED(options = {}) {
+  const { nodes = {}, settings = {} } = options;
+  return {
+    log: {
+      info: vi.fn(),
+      warn: vi.fn(),
+      error: vi.fn(),
+      debug: vi.fn()
+    },
+    nodes: {
+      getNode: vi.fn((id) => nodes[id]),
+      registerType: vi.fn(),
+      createNode: vi.fn()
+    },
+    httpAdmin: {
+      get: vi.fn(),
+      post: vi.fn(),
+      put: vi.fn(),
+      delete: vi.fn(),
+      use: vi.fn()
+    },
+    settings: { ...settings },
+    _: vi.fn((key, subs) => {
+      if (!subs) return key;
+      return Object.entries(subs).reduce(
+        (str, [k, v]) => str.replace(`__${k}__`, v),
+        key
+      );
+    }),
+    util: {
+      evaluateNodeProperty: vi.fn(
+        (value, type, _node, msg, callback) => {
+          try {
+            let result;
+            switch (type) {
+              case "str":
+                result = String(value);
+                break;
+              case "num":
+                result = Number(value);
+                break;
+              case "bool":
+                result = value === "true" || value === true;
+                break;
+              case "json":
+                result = typeof value === "string" ? JSON.parse(value) : value;
+                break;
+              case "msg":
+                result = msg ? getProperty(msg, value) : void 0;
+                break;
+              case "date":
+                result = Date.now();
+                break;
+              case "bin":
+                result = Buffer.from(value ?? "");
+                break;
+              case "re":
+                result = new RegExp(value);
+                break;
+              case "jsonata":
+              case "flow":
+              case "global":
+              case "env":
+              case "cred":
+                result = void 0;
+                break;
+              case "node":
+                result = value;
+                break;
+              default:
+                result = value;
+            }
+            callback(null, result);
+          } catch (err) {
+            callback(err, void 0);
+          }
+        }
+      )
+    },
+    events: {
+      on: vi.fn(),
+      emit: vi.fn()
+    },
+    hooks: {
+      add: vi.fn(),
+      remove: vi.fn()
+    },
+    version: vi.fn(() => "0.0.0-test")
+  };
+}
+function getProperty(obj, path) {
+  return path.split(".").reduce((acc, key) => acc?.[key], obj);
+}
+function createContextStore() {
+  const store = {};
+  return {
+    get: vi.fn(
+      (key, _store, cb) => cb(null, store[key])
+    ),
+    set: vi.fn(
+      (key, value, _store, cb) => {
+        store[key] = value;
+        cb(null);
+      }
+    ),
+    keys: vi.fn(
+      (_store, cb) => cb(null, Object.keys(store))
+    )
+  };
+}
+function createMockNodeRedNode(options = {}) {
+  const nodeCtx = createContextStore();
+  const flowCtx = createContextStore();
+  const globalCtx = createContextStore();
+  const context = {
+    ...nodeCtx,
+    flow: flowCtx,
+    global: globalCtx
+  };
+  return {
+    id: options.id ?? `test-${Math.random().toString(36).slice(2, 10)}`,
+    type: options.type ?? "test-node",
+    name: options.name ?? "",
+    z: options.z ?? "flow-1",
+    x: 100,
+    y: 200,
+    g: void 0,
+    wires: options.wires ?? [[]],
+    credentials: options.credentials ?? {},
+    log: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+    on: vi.fn(),
+    send: vi.fn(),
+    status: vi.fn(),
+    updateWires: vi.fn(),
+    receive: vi.fn(),
+    context: vi.fn(() => context),
+    ...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
+function buildConfig(NodeClass, userConfig = {}) {
+  const defaults = {};
+  if (NodeClass.configSchema?.properties) {
+    for (const [key, prop] of Object.entries(
+      NodeClass.configSchema.properties
+    )) {
+      if (prop.default !== void 0) {
+        defaults[key] = prop.default;
+      }
+    }
+  }
+  return { ...defaults, ...userConfig };
+}
+function buildNodeRedNodes(configNodes) {
+  const nodes = {};
+  for (const [id, value] of Object.entries(configNodes)) {
+    if (value && typeof value === "object" && "id" in value) {
+      nodes[id] = { _node: value };
+    } else {
+      nodes[id] = value;
+    }
+  }
+  return nodes;
+}
+function attachHelpers(node, nodeRedNode) {
+  const sentMessages = [];
+  const statusCalls = [];
+  nodeRedNode.send.mockImplementation((msg) => {
+    sentMessages.push(msg);
+  });
+  nodeRedNode.status.mockImplementation((status) => {
+    statusCalls.push(status);
+  });
+  const nodeRef = node;
+  const helpers = {
+    async receive(msg) {
+      const sendFn = vi2.fn((outMsg) => {
+        nodeRedNode.send(outMsg);
+      });
+      await nodeRef._input(msg, sendFn);
+    },
+    async close(removed = false) {
+      await nodeRef._closed(removed);
+    },
+    reset() {
+      sentMessages.length = 0;
+      statusCalls.length = 0;
+      nodeRedNode.log.mockClear();
+      nodeRedNode.warn.mockClear();
+      nodeRedNode.error.mockClear();
+    },
+    sent(port) {
+      if (port === void 0) return [...sentMessages];
+      return sentMessages.map(
+        (msg) => Array.isArray(msg) ? msg[port] : port === 0 ? msg : void 0
+      ).filter((msg) => msg != null);
+    },
+    statuses() {
+      return [...statusCalls];
+    },
+    logged(level) {
+      if (level) {
+        return nodeRedNode[level === "info" ? "log" : level].mock.calls.map(
+          (c) => c[0]
+        );
+      }
+      return [
+        ...nodeRedNode.log.mock.calls.map((c) => c[0]),
+        ...nodeRedNode.warn.mock.calls.map((c) => c[0]),
+        ...nodeRedNode.error.mock.calls.map((c) => c[0])
+      ];
+    },
+    warned() {
+      return nodeRedNode.warn.mock.calls.map((c) => c[0]);
+    },
+    errored() {
+      return nodeRedNode.error.mock.calls.map((c) => c[0]);
+    }
+  };
+  return Object.assign(node, helpers);
+}
+function isConfigNode(NodeClass) {
+  return NodeClass.category === "config";
+}
+async function createNode(NodeClass, options = {}) {
+  const {
+    config: userConfig = {},
+    credentials = {},
+    configNodes = {},
+    settings = {},
+    overrides: overrideOpts = {}
+  } = options;
+  const redNodes = buildNodeRedNodes(configNodes);
+  const RED = createMockRED({ nodes: redNodes, settings });
+  initValidator(RED);
+  const configDefaults = {
+    id: overrideOpts.id ?? `test-${Math.random().toString(36).slice(2, 10)}`,
+    type: NodeClass.type
+  };
+  if (isConfigNode(NodeClass)) {
+    configDefaults._users = [];
+  }
+  const config = buildConfig(NodeClass, {
+    ...configDefaults,
+    ...userConfig
+  });
+  const nodeRedNode = createMockNodeRedNode({
+    id: config.id,
+    type: NodeClass.type,
+    name: config.name ?? "",
+    credentials,
+    ...overrideOpts
+  });
+  await Promise.resolve(
+    NodeClass._registered?.(RED) ?? NodeClass.registered?.(RED)
+  );
+  const node = new NodeClass(RED, nodeRedNode, config, credentials);
+  const augmented = attachHelpers(node, nodeRedNode);
+  await Promise.resolve(augmented.created?.());
+  return { node: augmented, RED };
+}
+export {
+  createNode
+};

package/types/test.d.ts

@@ -0,0 +1,39 @@
+
+export interface CreateNodeOptions {
+  config?: Record<string, any>;
+  credentials?: Record<string, any>;
+  configNodes?: Record<string, any>;
+  settings?: Record<string, any>;
+  overrides?: Record<string, any>;
+}
+
+type ExtractInput<T> = T extends { input(msg: infer I): any } ? I : any;
+type ExtractOutput<T> = T extends { send(msg: infer O): any } ? O : any;
+
+export interface TestNodeHelpers<TInput = any, TOutput = any> {
+  receive(msg: TInput): Promise<void>;
+  close(removed?: boolean): Promise<void>;
+  reset(): void;
+  sent(): TOutput[];
+  sent(port: number): any[];
+  statuses(): any[];
+  logged(level?: "info" | "warn" | "error" | "debug"): string[];
+  warned(): string[];
+  errored(): string[];
+}
+
+export interface CreateNodeResult<T> {
+  node: T & TestNodeHelpers<ExtractInput<T>, ExtractOutput<T>>;
+  RED: any;
+}
+
+interface NodeClass {
+  readonly type: string;
+  readonly category?: string;
+  readonly configSchema?: any;
+  registered?(RED: any): void | Promise<void>;
+  _registered?(RED: any): void | Promise<void>;
+  new (...args: any[]): any;
+}
+
+export declare function createNode<T extends NodeClass>(NodeClass: T, options?: CreateNodeOptions): Promise<CreateNodeResult<InstanceType<T>>>;