@bonsae/nrg 0.13.0 → 0.13.1

package/package.json

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

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) {

package/types/test.d.ts

@@ -1,49 +1,38 @@
-// Generated by dts-bundle-generator v9.5.1
 
-export interface MockNodeRedNodeOptions {
-	id?: string;
-	type?: string;
-	name?: string;
-	z?: string;
-	wires?: string[][];
-	credentials?: Record<string, any>;
-	[key: string]: any;
-}
 export interface CreateNodeOptions {
-	config?: Record<string, any>;
-	credentials?: Record<string, any>;
-	settings?: Record<string, any>;
-	overrides?: MockNodeRedNodeOptions;
+  config?: Record<string, any>;
+  credentials?: Record<string, any>;
+  settings?: Record<string, any>;
+  overrides?: Record<string, any>;
 }
-export type ExtractInput<T> = T extends {
-	input(msg: infer I): any;
-} ? I : any;
-export type ExtractOutput<T> = T extends {
-	send(msg: infer O): any;
-} ? O : 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[];
+  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;
+  node: T & TestNodeHelpers<ExtractInput<T>, ExtractOutput<T>>;
+  RED: any;
 }
-export 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;
+
+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>>>;
 
-export {};
+export declare function createNode<T extends NodeClass>(NodeClass: T, options?: CreateNodeOptions): Promise<CreateNodeResult<InstanceType<T>>>;