@revisium/schema-toolkit 0.15.0 → 0.16.0

package/dist/FormulaValidator-CKE2kT4C.d.cts

@@ -0,0 +1,10 @@
+import { b as SchemaNode, S as SchemaValidationError, c as SchemaTree, F as FormulaValidationError } from './types-DMzUCve0.cjs';
+
+declare function validateSchema(root: SchemaNode): SchemaValidationError[];
+
+declare const FIELD_NAME_ERROR_MESSAGE = "Must start with a letter or underscore, cannot start with __, and can only include letters, numbers, hyphens, and underscores (max 64 chars)";
+declare function isValidFieldName(name: string): boolean;
+
+declare function validateFormulas(tree: SchemaTree): FormulaValidationError[];
+
+export { FIELD_NAME_ERROR_MESSAGE as F, validateFormulas as a, isValidFieldName as i, validateSchema as v };

package/dist/FormulaValidator-DGGmwqDQ.d.ts

@@ -0,0 +1,10 @@
+import { b as SchemaNode, S as SchemaValidationError, c as SchemaTree, F as FormulaValidationError } from './types-Cnfj5nLO.js';
+
+declare function validateSchema(root: SchemaNode): SchemaValidationError[];
+
+declare const FIELD_NAME_ERROR_MESSAGE = "Must start with a letter or underscore, cannot start with __, and can only include letters, numbers, hyphens, and underscores (max 64 chars)";
+declare function isValidFieldName(name: string): boolean;
+
+declare function validateFormulas(tree: SchemaTree): FormulaValidationError[];
+
+export { FIELD_NAME_ERROR_MESSAGE as F, validateFormulas as a, isValidFieldName as i, validateSchema as v };

package/dist/{chunk-A4E524UU.cjs → chunk-IWRV6QAD.cjs}

@@ -70,6 +70,9 @@ var NullNodeImpl = class {
   removeChild(_name) {
     return false;
   }
+  replaceChild(_name, _node) {
+    return false;
+  }
   setItems(_node) {
   }
   setDefaultValue(_value) {
@@ -149,6 +152,9 @@ var BaseNode = class {
   removeChild(_name) {
     return false;
   }
+  replaceChild(_name, _node) {
+    return false;
+  }
   setItems(_node) {
   }
   setDefaultValue(_value) {
@@ -197,6 +203,14 @@ var ObjectNode = class _ObjectNode extends BaseNode {
     this._children.splice(index, 1);
     return true;
   }
+  replaceChild(name, node) {
+    const index = this._children.findIndex((child) => child.name() === name);
+    if (index === -1) {
+      return false;
+    }
+    this._children[index] = node;
+    return true;
+  }
 };
 function createObjectNode(id, name, children = [], metadata = EMPTY_METADATA) {
   return new ObjectNode(id, name, children, metadata);
@@ -563,14 +577,15 @@ var TreeNodeIndex = class {
 
 // src/core/schema-tree/SchemaTreeImpl.ts
 var SchemaTreeImpl = class _SchemaTreeImpl {
+  index = new TreeNodeIndex();
+  _replacements = /* @__PURE__ */ new Map();
+  _rootNode;
   constructor(rootNode) {
-    this.rootNode = rootNode;
+    this._rootNode = rootNode;
     this.index.rebuild(rootNode);
   }
-  index = new TreeNodeIndex();
-  _replacements = /* @__PURE__ */ new Map();
   root() {
-    return this.rootNode;
+    return this._rootNode;
   }
   nodeById(id) {
     return this.index.getNode(id);
@@ -580,9 +595,9 @@ var SchemaTreeImpl = class _SchemaTreeImpl {
   }
   nodeAt(path) {
     if (path.isEmpty()) {
-      return this.rootNode;
+      return this._rootNode;
     }
-    let current = this.rootNode;
+    let current = this._rootNode;
     for (const segment of path.segments()) {
       if (current.isNull()) {
         return NULL_NODE;
@@ -602,7 +617,7 @@ var SchemaTreeImpl = class _SchemaTreeImpl {
     return this.index.countNodes();
   }
   clone() {
-    const cloned = new _SchemaTreeImpl(this.rootNode.clone());
+    const cloned = new _SchemaTreeImpl(this._rootNode.clone());
     for (const [oldId, newId] of this._replacements) {
       cloned._replacements.set(oldId, newId);
     }
@@ -700,14 +715,18 @@ var SchemaTreeImpl = class _SchemaTreeImpl {
     if (lastSegment.isItems()) {
       parent.setItems(node);
     } else {
-      parent.removeChild(lastSegment.propertyName());
-      node.setName(lastSegment.propertyName());
-      parent.addChild(node);
+      const propertyName = lastSegment.propertyName();
+      node.setName(propertyName);
+      parent.replaceChild(propertyName, node);
     }
     this.rebuildIndex();
   }
+  replaceRoot(newRoot) {
+    this._rootNode = newRoot;
+    this.rebuildIndex();
+  }
   rebuildIndex() {
-    this.index.rebuild(this.rootNode);
+    this.index.rebuild(this._rootNode);
   }
 };
 function createSchemaTree(root) {
@@ -2144,36 +2163,459 @@ var PatchBuilder = class {
   }
 };
 
+// src/core/validation/ValidatorRegistry.ts
+var ValidatorRegistry = class {
+  validators = /* @__PURE__ */ new Map();
+  rules = [];
+  register(type, factory) {
+    this.validators.set(type, factory);
+    return this;
+  }
+  addRule(rule) {
+    this.rules.push(rule);
+    return this;
+  }
+  get(type) {
+    const factory = this.validators.get(type);
+    return factory ? factory() : void 0;
+  }
+  has(type) {
+    return this.validators.has(type);
+  }
+  getRules() {
+    return this.rules;
+  }
+  getValidatorTypes() {
+    return Array.from(this.validators.keys());
+  }
+};
+
+// src/core/validation/ValidatorResolver.ts
+var ValidatorResolver = class {
+  constructor(registry) {
+    this.registry = registry;
+  }
+  resolve(context) {
+    const validators = [];
+    const rules = this.registry.getRules();
+    for (const rule of rules) {
+      if (rule.shouldApply(context)) {
+        const validator = this.registry.get(rule.validatorType);
+        if (validator) {
+          validators.push(validator);
+        }
+      }
+    }
+    return validators;
+  }
+};
+
+// src/core/validation/ValidationEngine.ts
+var ValidationEngine = class {
+  constructor(resolver) {
+    this.resolver = resolver;
+  }
+  validate(context) {
+    const validators = this.resolver.resolve(context);
+    const diagnostics = [];
+    for (const validator of validators) {
+      const diagnostic = validator.validate(context);
+      if (diagnostic) {
+        diagnostics.push(diagnostic);
+      }
+    }
+    return diagnostics;
+  }
+};
+
+// src/core/validation/rules/SchemaBasedRule.ts
+var SchemaPropertyRule = class {
+  constructor(validatorType, propertyName) {
+    this.validatorType = validatorType;
+    this.propertyName = propertyName;
+  }
+  shouldApply(context) {
+    const value = context.schema[this.propertyName];
+    return value !== void 0 && value !== null;
+  }
+};
+var SchemaTruthyRule = class {
+  constructor(validatorType, propertyName) {
+    this.validatorType = validatorType;
+    this.propertyName = propertyName;
+  }
+  shouldApply(context) {
+    return context.schema[this.propertyName] === true;
+  }
+};
+var CompositeRule = class {
+  constructor(validatorType, conditions) {
+    this.validatorType = validatorType;
+    this.conditions = conditions;
+  }
+  shouldApply(context) {
+    return this.conditions.every((condition) => condition(context));
+  }
+};
+
+// src/core/validation/validators/RequiredValidator.ts
+var RequiredValidator = class {
+  type = "required";
+  validate(context) {
+    const { value, nodeName } = context;
+    if (value === "" || value === null || value === void 0) {
+      return {
+        severity: "error",
+        type: this.type,
+        message: "Field is required",
+        path: nodeName
+      };
+    }
+    return null;
+  }
+};
+
+// src/core/validation/validators/PatternValidator.ts
+var PatternValidator = class {
+  type = "pattern";
+  validate(context) {
+    const { value, schema, nodeName } = context;
+    const pattern = schema.pattern;
+    if (!pattern) {
+      return null;
+    }
+    if (typeof value !== "string") {
+      return null;
+    }
+    if (value.length === 0) {
+      return null;
+    }
+    try {
+      if (!new RegExp(pattern).test(value)) {
+        return {
+          severity: "error",
+          type: this.type,
+          message: "Value does not match pattern",
+          path: nodeName,
+          params: { pattern }
+        };
+      }
+    } catch {
+      return {
+        severity: "error",
+        type: "invalidPattern",
+        message: "Invalid regex pattern in schema",
+        path: nodeName,
+        params: { pattern }
+      };
+    }
+    return null;
+  }
+};
+
+// src/core/validation/validators/MinLengthValidator.ts
+var MinLengthValidator = class {
+  type = "minLength";
+  validate(context) {
+    const { value, schema, nodeName } = context;
+    const minLength = schema.minLength;
+    if (minLength === void 0) {
+      return null;
+    }
+    if (typeof value !== "string") {
+      return null;
+    }
+    if (value.length < minLength) {
+      return {
+        severity: "error",
+        type: this.type,
+        message: `Value must be at least ${minLength} characters`,
+        path: nodeName,
+        params: { min: minLength, actual: value.length }
+      };
+    }
+    return null;
+  }
+};
+
+// src/core/validation/validators/MaxLengthValidator.ts
+var MaxLengthValidator = class {
+  type = "maxLength";
+  validate(context) {
+    const { value, schema, nodeName } = context;
+    const maxLength = schema.maxLength;
+    if (maxLength === void 0) {
+      return null;
+    }
+    if (typeof value !== "string") {
+      return null;
+    }
+    if (value.length > maxLength) {
+      return {
+        severity: "error",
+        type: this.type,
+        message: `Value must be at most ${maxLength} characters`,
+        path: nodeName,
+        params: { max: maxLength, actual: value.length }
+      };
+    }
+    return null;
+  }
+};
+
+// src/core/validation/validators/MinimumValidator.ts
+var MinimumValidator = class {
+  type = "minimum";
+  validate(context) {
+    const { value, schema, nodeName } = context;
+    const minimum = schema.minimum;
+    if (minimum === void 0) {
+      return null;
+    }
+    if (typeof value !== "number") {
+      return null;
+    }
+    if (value < minimum) {
+      return {
+        severity: "error",
+        type: this.type,
+        message: `Value must be at least ${minimum}`,
+        path: nodeName,
+        params: { min: minimum, actual: value }
+      };
+    }
+    return null;
+  }
+};
+
+// src/core/validation/validators/MaximumValidator.ts
+var MaximumValidator = class {
+  type = "maximum";
+  validate(context) {
+    const { value, schema, nodeName } = context;
+    const maximum = schema.maximum;
+    if (maximum === void 0) {
+      return null;
+    }
+    if (typeof value !== "number") {
+      return null;
+    }
+    if (value > maximum) {
+      return {
+        severity: "error",
+        type: this.type,
+        message: `Value must be at most ${maximum}`,
+        path: nodeName,
+        params: { max: maximum, actual: value }
+      };
+    }
+    return null;
+  }
+};
+
+// src/core/validation/validators/EnumValidator.ts
+var EnumValidator = class {
+  type = "enum";
+  validate(context) {
+    const { value, schema, nodeName } = context;
+    const enumValues = schema.enum;
+    if (!enumValues || enumValues.length === 0) {
+      return null;
+    }
+    if (!enumValues.includes(value)) {
+      return {
+        severity: "error",
+        type: this.type,
+        message: "Value must be one of the allowed values",
+        path: nodeName,
+        params: { allowed: [...enumValues], actual: value }
+      };
+    }
+    return null;
+  }
+};
+
+// src/core/validation/validators/ForeignKeyValidator.ts
+var ForeignKeyValidator = class {
+  type = "foreignKey";
+  validate(context) {
+    const { value, schema, nodeName } = context;
+    const foreignKey = schema.foreignKey;
+    if (!foreignKey) {
+      return null;
+    }
+    if (value === "" || value === null || value === void 0) {
+      return {
+        severity: "error",
+        type: this.type,
+        message: "Foreign key reference is required",
+        path: nodeName,
+        params: { table: foreignKey }
+      };
+    }
+    return null;
+  }
+};
+
+// src/core/validation/createValidationEngine.ts
+function createDefaultValidatorRegistry() {
+  const registry = new ValidatorRegistry();
+  registry.register("required", () => new RequiredValidator()).register("pattern", () => new PatternValidator()).register("minLength", () => new MinLengthValidator()).register("maxLength", () => new MaxLengthValidator()).register("minimum", () => new MinimumValidator()).register("maximum", () => new MaximumValidator()).register("enum", () => new EnumValidator()).register("foreignKey", () => new ForeignKeyValidator());
+  registry.addRule(new SchemaTruthyRule("required", "required")).addRule(new SchemaPropertyRule("pattern", "pattern")).addRule(new SchemaPropertyRule("minLength", "minLength")).addRule(new SchemaPropertyRule("maxLength", "maxLength")).addRule(new SchemaPropertyRule("minimum", "minimum")).addRule(new SchemaPropertyRule("maximum", "maximum")).addRule(new SchemaPropertyRule("enum", "enum")).addRule(new SchemaPropertyRule("foreignKey", "foreignKey"));
+  return registry;
+}
+function createValidationEngine(registry) {
+  const validatorRegistry = registry ?? createDefaultValidatorRegistry();
+  const resolver = new ValidatorResolver(validatorRegistry);
+  return new ValidationEngine(resolver);
+}
+
+// src/core/validation/schema/FieldNameValidator.ts
+var FIELD_NAME_PATTERN = /^(?!__)[a-zA-Z_][a-zA-Z0-9-_]*$/;
+var FIELD_NAME_MAX_LENGTH = 64;
+var FIELD_NAME_ERROR_MESSAGE = "Must start with a letter or underscore, cannot start with __, and can only include letters, numbers, hyphens, and underscores (max 64 chars)";
+function isValidFieldName(name) {
+  if (name.length === 0 || name.length > FIELD_NAME_MAX_LENGTH) {
+    return false;
+  }
+  return FIELD_NAME_PATTERN.test(name);
+}
+
+// src/core/validation/schema/SchemaValidator.ts
+function validateSchema(root) {
+  const errors = [];
+  collectValidationErrors(root, errors);
+  return errors;
+}
+function collectValidationErrors(node, errors) {
+  if (node.isNull()) {
+    return;
+  }
+  if (node.isObject()) {
+    const children = node.properties();
+    const nameSet = /* @__PURE__ */ new Set();
+    for (const child of children) {
+      const childName = child.name();
+      if (childName === "") {
+        errors.push(createError(child.id(), "empty-name", "Field name cannot be empty"));
+      } else if (nameSet.has(childName)) {
+        errors.push(
+          createError(child.id(), "duplicate-name", `Duplicate field name: ${childName}`)
+        );
+      } else if (!isValidFieldName(childName)) {
+        errors.push(createError(child.id(), "invalid-name", FIELD_NAME_ERROR_MESSAGE));
+      }
+      nameSet.add(childName);
+      collectValidationErrors(child, errors);
+    }
+  } else if (node.isArray()) {
+    collectValidationErrors(node.items(), errors);
+  }
+}
+function createError(nodeId, type, message) {
+  return { nodeId, type, message };
+}
+
+// src/core/validation/formula/FormulaValidator.ts
+function validateFormulas(tree) {
+  const errors = [];
+  collectFormulaErrors(tree.root(), tree, errors, "");
+  return errors;
+}
+function collectFormulaErrors(node, tree, errors, fieldPath) {
+  if (node.isNull()) {
+    return;
+  }
+  validateNodeFormula(node, tree, errors, fieldPath);
+  collectChildErrors(node, tree, errors, fieldPath);
+}
+function validateNodeFormula(node, tree, errors, fieldPath) {
+  if (!node.isPrimitive() || !node.hasFormula()) {
+    return;
+  }
+  const formula = node.formula();
+  if (!formula) {
+    return;
+  }
+  for (const dep of formula.dependencies()) {
+    const targetNode = tree.nodeById(dep.targetNodeId());
+    if (targetNode.isNull()) {
+      errors.push({
+        nodeId: node.id(),
+        message: "Cannot resolve formula dependency: target node not found",
+        fieldPath: fieldPath || node.name()
+      });
+    }
+  }
+}
+function collectChildErrors(node, tree, errors, fieldPath) {
+  if (node.isObject()) {
+    for (const child of node.properties()) {
+      const childPath = buildChildPath(fieldPath, child.name());
+      collectFormulaErrors(child, tree, errors, childPath);
+    }
+  } else if (node.isArray()) {
+    const itemsPath = buildArrayItemsPath(fieldPath);
+    collectFormulaErrors(node.items(), tree, errors, itemsPath);
+  }
+}
+function buildChildPath(parentPath, childName) {
+  return parentPath ? `${parentPath}.${childName}` : childName;
+}
+function buildArrayItemsPath(parentPath) {
+  return parentPath ? `${parentPath}[*]` : "[*]";
+}
+
 exports.AbstractBasePath = AbstractBasePath;
 exports.ChangeCoalescer = ChangeCoalescer;
 exports.ChangeCollector = ChangeCollector;
+exports.CompositeRule = CompositeRule;
 exports.EMPTY_METADATA = EMPTY_METADATA;
 exports.EMPTY_PATH = EMPTY_PATH;
+exports.EnumValidator = EnumValidator;
+exports.FIELD_NAME_ERROR_MESSAGE = FIELD_NAME_ERROR_MESSAGE;
+exports.ForeignKeyValidator = ForeignKeyValidator;
 exports.FormulaDependencyIndex = FormulaDependencyIndex;
 exports.ItemsSegment = ItemsSegment;
+exports.MaxLengthValidator = MaxLengthValidator;
+exports.MaximumValidator = MaximumValidator;
+exports.MinLengthValidator = MinLengthValidator;
+exports.MinimumValidator = MinimumValidator;
 exports.NULL_NODE = NULL_NODE;
 exports.NodePathIndex = NodePathIndex;
 exports.ParsedFormula = ParsedFormula;
 exports.PatchBuilder = PatchBuilder;
 exports.PatchEnricher = PatchEnricher;
 exports.PatchGenerator = PatchGenerator;
+exports.PatternValidator = PatternValidator;
 exports.PropertySegment = PropertySegment;
+exports.RequiredValidator = RequiredValidator;
 exports.SchemaDiff = SchemaDiff;
+exports.SchemaPropertyRule = SchemaPropertyRule;
 exports.SchemaSerializer = SchemaSerializer;
+exports.SchemaTruthyRule = SchemaTruthyRule;
+exports.ValidationEngine = ValidationEngine;
+exports.ValidatorRegistry = ValidatorRegistry;
+exports.ValidatorResolver = ValidatorResolver;
 exports.areNodesContentEqual = areNodesContentEqual;
 exports.areNodesEqual = areNodesEqual;
 exports.coalesceChanges = coalesceChanges;
 exports.collectChanges = collectChanges;
 exports.createArrayNode = createArrayNode;
 exports.createBooleanNode = createBooleanNode;
+exports.createDefaultValidatorRegistry = createDefaultValidatorRegistry;
 exports.createNumberNode = createNumberNode;
 exports.createObjectNode = createObjectNode;
 exports.createPath = createPath;
 exports.createRefNode = createRefNode;
 exports.createSchemaTree = createSchemaTree;
 exports.createStringNode = createStringNode;
+exports.createValidationEngine = createValidationEngine;
+exports.isValidFieldName = isValidFieldName;
 exports.jsonPointerToPath = jsonPointerToPath;
 exports.jsonPointerToSegments = jsonPointerToSegments;
 exports.jsonPointerToSimplePath = jsonPointerToSimplePath;
-//# sourceMappingURL=chunk-A4E524UU.cjs.map
-//# sourceMappingURL=chunk-A4E524UU.cjs.map
+exports.validateFormulas = validateFormulas;
+exports.validateSchema = validateSchema;
+//# sourceMappingURL=chunk-IWRV6QAD.cjs.map
+//# sourceMappingURL=chunk-IWRV6QAD.cjs.map