@bonsae/nrg 0.13.1 → 0.15.0

package/test/index.js

@@ -3,19 +3,44 @@ import { vi as vi2 } from "vitest";
 
 // src/test/mocks.ts
 import { vi } from "vitest";
-function createMockRED(options = {}) {
-  const { nodes = {}, settings = {} } = options;
-  return {
+function createNodeRedRuntime(options = {}) {
+  const { settings = {} } = options;
+  const nodes = {};
+  const red = {
     log: {
       info: vi.fn(),
       warn: vi.fn(),
       error: vi.fn(),
-      debug: vi.fn()
+      debug: vi.fn(),
+      trace: vi.fn(),
+      log: vi.fn(),
+      metric: vi.fn(() => false),
+      audit: vi.fn(),
+      addHandler: vi.fn(),
+      removeHandler: vi.fn(),
+      FATAL: 10,
+      ERROR: 20,
+      WARN: 30,
+      INFO: 40,
+      DEBUG: 50,
+      TRACE: 60,
+      AUDIT: 98,
+      METRIC: 99
     },
     nodes: {
       getNode: vi.fn((id) => nodes[id]),
       registerType: vi.fn(),
-      createNode: vi.fn()
+      createNode: vi.fn(),
+      getCredentials: vi.fn(),
+      eachNode: vi.fn(),
+      getType: vi.fn(),
+      getNodeInfo: vi.fn(),
+      getNodeList: vi.fn(() => []),
+      getModuleInfo: vi.fn(),
+      installModule: vi.fn(),
+      uninstallModule: vi.fn(),
+      enableNode: vi.fn(),
+      disableNode: vi.fn()
     },
     httpAdmin: {
       get: vi.fn(),
@@ -24,6 +49,25 @@ function createMockRED(options = {}) {
       delete: vi.fn(),
       use: vi.fn()
     },
+    httpNode: {
+      get: vi.fn(),
+      post: vi.fn(),
+      put: vi.fn(),
+      delete: vi.fn(),
+      use: vi.fn()
+    },
+    hooks: {
+      add: vi.fn(),
+      remove: vi.fn(),
+      trigger: vi.fn(),
+      has: vi.fn(() => false),
+      clear: vi.fn()
+    },
+    events: {
+      on: vi.fn(),
+      emit: vi.fn(),
+      removeListener: vi.fn()
+    },
     settings: { ...settings },
     _: vi.fn((key, subs) => {
       if (!subs) return key;
@@ -80,18 +124,34 @@ function createMockRED(options = {}) {
             callback(err, void 0);
           }
         }
-      )
+      ),
+      generateId: vi.fn(() => "mock-id"),
+      cloneMessage: vi.fn((msg) => ({ ...msg })),
+      ensureString: vi.fn((o) => String(o)),
+      ensureBuffer: vi.fn(),
+      compareObjects: vi.fn(),
+      getMessageProperty: vi.fn(),
+      setMessageProperty: vi.fn(),
+      getObjectProperty: vi.fn(),
+      setObjectProperty: vi.fn(),
+      normalisePropertyExpression: vi.fn(),
+      normaliseNodeTypeName: vi.fn(),
+      prepareJSONataExpression: vi.fn(),
+      evaluateJSONataExpression: vi.fn(),
+      parseContextStore: vi.fn(),
+      getSetting: vi.fn(),
+      encodeObject: vi.fn()
     },
-    events: {
-      on: vi.fn(),
-      emit: vi.fn()
+    version: vi.fn(() => "0.0.0-test"),
+    validator: void 0,
+    registerNode(id, nodeRedNode) {
+      nodes[id] = nodeRedNode;
     },
-    hooks: {
-      add: vi.fn(),
-      remove: vi.fn()
-    },
-    version: vi.fn(() => "0.0.0-test")
+    registerNrgNode(id, nrgInstance) {
+      nodes[id] = createNodeRedNode({ id, _node: nrgInstance });
+    }
   };
+  return red;
 }
 function getProperty(obj, path) {
   return path.split(".").reduce((acc, key) => acc?.[key], obj);
@@ -113,7 +173,7 @@ function createContextStore() {
     )
   };
 }
-function createMockNodeRedNode(options = {}) {
+function createNodeRedNode(options = {}) {
   const nodeCtx = createContextStore();
   const flowCtx = createContextStore();
   const globalCtx = createContextStore();
@@ -122,20 +182,29 @@ function createMockNodeRedNode(options = {}) {
     flow: flowCtx,
     global: globalCtx
   };
+  const handlers = /* @__PURE__ */ new Map();
   return {
-    id: options.id ?? `test-${Math.random().toString(36).slice(2, 10)}`,
+    id: options.id ?? `node-${Math.random().toString(36).slice(2, 10)}`,
     type: options.type ?? "test-node",
-    name: options.name ?? "",
+    name: options.name ?? "test-node",
     z: options.z ?? "flow-1",
     x: 100,
     y: 200,
-    g: void 0,
-    wires: options.wires ?? [[]],
+    g: "group-1",
+    wires: options.wires ?? [["node-2"]],
     credentials: options.credentials ?? {},
     log: vi.fn(),
     warn: vi.fn(),
     error: vi.fn(),
-    on: vi.fn(),
+    on: vi.fn((event, handler) => {
+      if (!handlers.has(event)) handlers.set(event, []);
+      handlers.get(event).push(handler);
+    }),
+    emit: vi.fn(async (event, ...args) => {
+      for (const handler of handlers.get(event) ?? []) {
+        await handler(...args);
+      }
+    }),
     send: vi.fn(),
     status: vi.fn(),
     updateWires: vi.fn(),
@@ -145,32 +214,204 @@ 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, 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/nodes/symbols.ts
+var WIRE_HANDLERS = Symbol("wireHandlers");
+
 // src/test/index.ts
-import { initValidator } from "@bonsae/nrg/server";
 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;
+      const schemaProp = prop;
+      if (schemaProp.default !== void 0) {
+        defaults[key] = schemaProp.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 = [];
@@ -180,16 +421,23 @@ function attachHelpers(node, nodeRedNode) {
   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);
+      const doneFn = vi2.fn();
+      await nodeRedNode.emit("input", msg, sendFn, doneFn);
+      if (doneFn.mock.calls[0]?.[0] instanceof Error) {
+        throw doneFn.mock.calls[0][0];
+      }
     },
     async close(removed = false) {
-      await nodeRef._closed(removed);
+      const doneFn = vi2.fn();
+      await nodeRedNode.emit("close", removed, doneFn);
+      if (doneFn.mock.calls[0]?.[0] instanceof Error) {
+        throw doneFn.mock.calls[0][0];
+      }
     },
     reset() {
       sentMessages.length = 0;
@@ -248,9 +496,11 @@ async function createNode(NodeClass, options = {}) {
       resolvedConfig[key] = value;
     }
   }
-  const redNodes = buildNodeRedNodes(configNodes);
-  const RED = createMockRED({ nodes: redNodes, settings });
+  const RED = createNodeRedRuntime({ settings });
   initValidator(RED);
+  for (const [id, value] of Object.entries(configNodes)) {
+    RED.registerNrgNode(id, value);
+  }
   const configDefaults = {
     id: overrideOpts.id ?? `test-${Math.random().toString(36).slice(2, 10)}`,
     type: NodeClass.type
@@ -262,19 +512,20 @@ async function createNode(NodeClass, options = {}) {
     ...configDefaults,
     ...resolvedConfig
   });
-  const nodeRedNode = createMockNodeRedNode({
+  const nodeRedNode = createNodeRedNode({
     id: config.id,
     type: NodeClass.type,
     name: config.name ?? "",
     credentials,
     ...overrideOpts
   });
-  await Promise.resolve(
-    NodeClass._registered?.(RED) ?? NodeClass.registered?.(RED)
-  );
+  NodeClass.validateSettings(RED);
+  await Promise.resolve(NodeClass.registered?.(RED));
   const node = new NodeClass(RED, nodeRedNode, config, credentials);
+  const createdPromise = Promise.resolve(node.created?.());
+  node[WIRE_HANDLERS](nodeRedNode, createdPromise);
+  await createdPromise;
   const augmented = attachHelpers(node, nodeRedNode);
-  await Promise.resolve(augmented.created?.());
   return { node: augmented, RED };
 }
 export {