@bonsae/nrg-runtime 0.25.1 → 0.26.1

package/internal/client/index.mjs

@@ -1,229 +0,0 @@
-// src/client/use-form-node.ts
-import { inject } from "vue";
-function useFormNode() {
-  const node = inject("__nrg_form_node");
-  const schema = inject("__nrg_form_schema");
-  const errors = inject("__nrg_form_errors");
-  if (!node) {
-    throw new Error(
-      "useFormNode() must be called inside a form component mounted by NRG."
-    );
-  }
-  return {
-    node,
-    schema,
-    errors
-  };
-}
-
-// src/client/validation.ts
-import jsonpointer from "jsonpointer";
-
-// src/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/client/validation.ts
-var 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.node(dataValue);
-        return !!node && 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)
-  }
-});
-function composeValidationSchema(configSchema, credentialsSchema) {
-  if (configSchema && credentialsSchema?.properties) {
-    return {
-      ...configSchema,
-      properties: {
-        ...configSchema.properties,
-        credentials: {
-          type: "object",
-          properties: credentialsSchema.properties
-        }
-      }
-    };
-  }
-  return configSchema;
-}
-function runValidation(subject, schema) {
-  const result = validator.validate(subject, schema, {
-    cacheKey: `node-schema-${subject.type}`
-  });
-  return result.valid ? [] : result.errors ?? [];
-}
-function validateForm(subject, schema) {
-  return runValidation(subject, schema).filter((e) => {
-    if (e.parentSchema?.format !== "password") return true;
-    const v = jsonpointer.get(subject, e.instancePath);
-    return v !== "__PWD__";
-  }).reduce(
-    (acc, error) => {
-      let path = error.instancePath;
-      if (error.keyword === "required" && error.params?.missingProperty) {
-        path = `${path}/${error.params.missingProperty}`;
-      }
-      const key = `node${path.replaceAll("/", ".")}`;
-      acc[key] = error.message ?? "Invalid";
-      return acc;
-    },
-    {}
-  );
-}
-export {
-  composeValidationSchema,
-  useFormNode,
-  validateForm
-};

package/internal/server/index.cjs

@@ -1,298 +0,0 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/internal/server/index.ts
-var index_exports = {};
-__export(index_exports, {
-  WIRE_HANDLERS: () => WIRE_HANDLERS,
-  initValidator: () => initValidator,
-  setupContext: () => setupContext
-});
-module.exports = __toCommonJS(index_exports);
-
-// src/server/nodes/symbols.ts
-var WIRE_HANDLERS = Symbol.for("nrg.wireHandlers");
-
-// src/server/nodes/context.ts
-var updateLocks = /* @__PURE__ */ new WeakMap();
-function setupContext(context, store) {
-  const get = (key) => new Promise(
-    (resolve, reject) => context.get(
-      key,
-      store,
-      (error, value) => error ? reject(error) : resolve(value)
-    )
-  );
-  const set = (key, value) => new Promise(
-    (resolve, reject) => context.set(
-      key,
-      value,
-      store,
-      (error) => error ? reject(error) : resolve()
-    )
-  );
-  const keys = () => new Promise(
-    (resolve, reject) => context.keys(store, (error, k) => error ? reject(error) : resolve(k))
-  );
-  const nativeUpdate = context.update;
-  const nativeIncrement = context.increment;
-  const update = (key, fn) => {
-    if (nativeUpdate) {
-      return new Promise(
-        (resolve, reject) => nativeUpdate(
-          key,
-          fn,
-          store,
-          (error, value) => error ? reject(error) : resolve(value)
-        )
-      );
-    }
-    let chains = updateLocks.get(context);
-    if (!chains) updateLocks.set(context, chains = /* @__PURE__ */ new Map());
-    const lockKey = JSON.stringify([store ?? null, key]);
-    const task = async () => {
-      const next = await fn(await get(key));
-      await set(key, next);
-      return next;
-    };
-    const run = (chains.get(lockKey) ?? Promise.resolve()).then(task, task);
-    chains.set(
-      lockKey,
-      run.then(
-        () => void 0,
-        () => void 0
-      )
-    );
-    return run;
-  };
-  const increment = (key, by = 1) => {
-    if (nativeIncrement) {
-      return new Promise(
-        (resolve, reject) => nativeIncrement(
-          key,
-          by,
-          store,
-          (error, value) => error ? reject(error) : resolve(value)
-        )
-      );
-    }
-    return update(
-      key,
-      (current) => typeof current === "number" ? current + by : by
-    );
-  };
-  return { get, set, keys, update, increment };
-}
-
-// src/validator.ts
-var import_ajv = __toESM(require("ajv"));
-var import_ajv_formats = __toESM(require("ajv-formats"));
-var import_ajv_errors = __toESM(require("ajv-errors"));
-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/server/validation.ts
-function initValidator(RED) {
-  if (RED.validator) return;
-  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
-  });
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  WIRE_HANDLERS,
-  initValidator,
-  setupContext
-});