@revisium/schema-toolkit 0.11.1 → 0.12.1

package/dist/{chunk-UJBE43WI.cjs → chunk-M6IMV3AN.cjs}

@@ -2,6 +2,8 @@
 
 var chunkEGC32GPY_cjs = require('./chunk-EGC32GPY.cjs');
 var chunkTMWPWGUN_cjs = require('./chunk-TMWPWGUN.cjs');
+var formula = require('@revisium/formula');
+var spec = require('@revisium/formula/spec');
 
 // src/lib/createJsonSchemaStore.ts
 var createJsonSchemaStore = (schema, refs = {}) => {
@@ -571,6 +573,497 @@ function createChange(path, oldValue, newValue, changeType) {
   return { path, oldValue, newValue, changeType };
 }
 
+// src/lib/extract-schema-formulas.ts
+function extractSchemaFormulas(schema) {
+  const formulas = [];
+  extractFormulasRecursive(schema, "", formulas);
+  return formulas;
+}
+function extractFormulasRecursive(schema, pathPrefix, formulas) {
+  if (schema.type === "array" && schema.items) {
+    extractFormulasRecursive(schema.items, `${pathPrefix}[]`, formulas);
+    return;
+  }
+  const properties = schema.properties ?? {};
+  for (const [fieldName, fieldSchema] of Object.entries(properties)) {
+    const fullPath = pathPrefix ? `${pathPrefix}.${fieldName}` : fieldName;
+    const xFormula = fieldSchema["x-formula"];
+    if (xFormula) {
+      formulas.push({
+        fieldName: fullPath,
+        expression: xFormula.expression,
+        fieldType: fieldSchema.type ?? "string"
+      });
+    }
+    if (fieldSchema.type === "object" && fieldSchema.properties) {
+      extractFormulasRecursive(fieldSchema, fullPath, formulas);
+    }
+    if (fieldSchema.type === "array" && fieldSchema.items) {
+      extractFormulasRecursive(fieldSchema.items, `${fullPath}[]`, formulas);
+    }
+  }
+}
+function validateSchemaFormulas(schema) {
+  const errors = [];
+  const formulas = extractSchemaFormulas(schema);
+  for (const formula of formulas) {
+    const error = validateFormulaAgainstSchema(
+      formula.expression,
+      formula.fieldName,
+      schema
+    );
+    if (error) {
+      errors.push(error);
+    }
+  }
+  if (errors.length > 0) {
+    return { isValid: false, errors };
+  }
+  const dependencies = {};
+  for (const formula$1 of formulas) {
+    const parseResult = formula.parseExpression(formula$1.expression);
+    const parentPath = getParentPath(formula$1.fieldName);
+    const prefix = parentPath ? `${parentPath}.` : "";
+    dependencies[formula$1.fieldName] = parseResult.dependencies.map((dep) => {
+      if (dep.startsWith("/")) {
+        return extractFieldRoot(dep.slice(1));
+      }
+      if (dep.startsWith("../")) {
+        const fieldWithoutPrefix = dep.replace(/^(\.\.\/)+/, "");
+        return extractFieldRoot(fieldWithoutPrefix);
+      }
+      const rootField = extractFieldRoot(dep);
+      return `${prefix}${rootField}`;
+    });
+  }
+  const graph = formula.buildDependencyGraph(dependencies);
+  const circularCheck = formula.detectCircularDependencies(graph);
+  const cycle = circularCheck.cycle;
+  if (circularCheck.hasCircular && cycle && cycle.length > 0) {
+    const firstField = cycle[0];
+    if (firstField) {
+      errors.push({
+        field: firstField,
+        error: `Circular dependency: ${cycle.join(" \u2192 ")}`
+      });
+      return { isValid: false, errors };
+    }
+  }
+  return { isValid: true, errors: [] };
+}
+function validateFormulaAgainstSchema(expression, fieldName, schema) {
+  return validateFormulaInContext(expression, fieldName, schema);
+}
+function validateFormulaInContext(expression, fieldPath, rootSchema) {
+  const syntaxResult = formula.validateFormulaSyntax(expression);
+  if (!syntaxResult.isValid) {
+    return {
+      field: fieldPath,
+      error: syntaxResult.error,
+      position: syntaxResult.position
+    };
+  }
+  const parentPath = getParentPath(fieldPath);
+  const localFieldName = getFieldName(fieldPath);
+  const contextSchema = resolveSubSchema(rootSchema, parentPath);
+  if (!contextSchema) {
+    return {
+      field: fieldPath,
+      error: `Cannot resolve schema context for path '${parentPath}'`
+    };
+  }
+  const parseResult = formula.parseExpression(expression);
+  const localSchemaFields = getSchemaFields(contextSchema);
+  const rootSchemaFields = getSchemaFields(rootSchema);
+  for (const dep of parseResult.dependencies) {
+    if (dep.startsWith("/")) {
+      const rootField = extractFieldRoot(dep.slice(1));
+      if (!rootSchemaFields.has(rootField)) {
+        return {
+          field: fieldPath,
+          error: `Unknown root field '${rootField}' in formula`
+        };
+      }
+    } else if (dep.startsWith("../")) {
+      const fieldWithoutPrefix = dep.replace(/^(\.\.\/)+/, "");
+      const rootField = extractFieldRoot(fieldWithoutPrefix);
+      if (!rootSchemaFields.has(rootField)) {
+        return {
+          field: fieldPath,
+          error: `Unknown root field '${rootField}' in formula`
+        };
+      }
+    } else {
+      const rootField = extractFieldRoot(dep);
+      if (!localSchemaFields.has(rootField)) {
+        return {
+          field: fieldPath,
+          error: `Unknown field '${rootField}' in formula`
+        };
+      }
+    }
+  }
+  if (parseResult.dependencies.some((d) => extractFieldRoot(d) === localFieldName)) {
+    return {
+      field: fieldPath,
+      error: `Formula cannot reference itself`
+    };
+  }
+  const fieldSchema = contextSchema.properties?.[localFieldName];
+  const expectedType = schemaTypeToInferred(fieldSchema?.type);
+  const fieldTypes = getSchemaFieldTypes(contextSchema);
+  const inferredType = formula.inferFormulaType(expression, fieldTypes);
+  if (!isTypeCompatible(inferredType, expectedType)) {
+    return {
+      field: fieldPath,
+      error: `Type mismatch: formula returns '${inferredType}' but field expects '${expectedType}'`
+    };
+  }
+  return null;
+}
+function resolveSubSchema(schema, fieldPath) {
+  if (!fieldPath) {
+    return schema;
+  }
+  const segments = parsePathSegments2(fieldPath);
+  let current = schema;
+  for (const segment of segments) {
+    if (segment === "[]") {
+      if (current.type === "array" && current.items) {
+        current = current.items;
+      } else {
+        return null;
+      }
+    } else if (current.properties?.[segment]) {
+      current = current.properties[segment];
+    } else {
+      return null;
+    }
+  }
+  return current;
+}
+function parsePathSegments2(path) {
+  const segments = [];
+  let current = "";
+  let inBracket = false;
+  for (const char of path) {
+    if (char === "[") {
+      if (current) {
+        segments.push(current);
+        current = "";
+      }
+      inBracket = true;
+    } else if (char === "]") {
+      inBracket = false;
+      segments.push("[]");
+    } else if (char === "." && !inBracket) {
+      if (current) {
+        segments.push(current);
+        current = "";
+      }
+    } else if (!inBracket) {
+      current += char;
+    }
+  }
+  if (current) {
+    segments.push(current);
+  }
+  return segments;
+}
+function getParentPath(fieldPath) {
+  const lastDotIndex = fieldPath.lastIndexOf(".");
+  const lastBracketIndex = fieldPath.lastIndexOf("[");
+  const splitIndex = Math.max(lastDotIndex, lastBracketIndex);
+  if (splitIndex <= 0) {
+    return "";
+  }
+  return fieldPath.substring(0, splitIndex);
+}
+function getFieldName(fieldPath) {
+  const lastDotIndex = fieldPath.lastIndexOf(".");
+  const lastBracketIndex = fieldPath.lastIndexOf("]");
+  const splitIndex = Math.max(lastDotIndex, lastBracketIndex);
+  if (splitIndex === -1) {
+    return fieldPath;
+  }
+  return fieldPath.substring(splitIndex + 1);
+}
+function getSchemaFields(schema) {
+  const fields = /* @__PURE__ */ new Set();
+  const properties = schema.properties ?? {};
+  for (const fieldName of Object.keys(properties)) {
+    fields.add(fieldName);
+  }
+  return fields;
+}
+function getSchemaFieldTypes(schema) {
+  const fieldTypes = {};
+  const properties = schema.properties ?? {};
+  for (const [fieldName, fieldSchema] of Object.entries(properties)) {
+    const schemaType = fieldSchema.type;
+    if (schemaType === "integer") {
+      fieldTypes[fieldName] = "number";
+    } else if (schemaType === "number" || schemaType === "string" || schemaType === "boolean" || schemaType === "object" || schemaType === "array") {
+      fieldTypes[fieldName] = schemaType;
+    }
+  }
+  return fieldTypes;
+}
+function schemaTypeToInferred(schemaType) {
+  if (schemaType === "number" || schemaType === "integer") return "number";
+  if (schemaType === "string") return "string";
+  if (schemaType === "boolean") return "boolean";
+  return null;
+}
+function isTypeCompatible(inferredType, expectedType) {
+  if (expectedType === null) return true;
+  if (inferredType === "unknown") return true;
+  return inferredType === expectedType;
+}
+function extractFieldRoot(dependency) {
+  const root = dependency.split(".")[0]?.split("[")[0];
+  return root || dependency;
+}
+
+// src/lib/formula.ts
+function prepareFormulas(schema) {
+  const formulas = extractSchemaFormulas(schema);
+  if (formulas.length === 0) {
+    return [];
+  }
+  const formulasWithMeta = formulas.map((f) => enrichFormula(f));
+  if (formulas.length <= 1) {
+    return formulasWithMeta;
+  }
+  return orderByDependencies(formulasWithMeta);
+}
+function evaluateFormulas(formulas, data, options = {}) {
+  const values = {};
+  const errors = [];
+  const failedFields = /* @__PURE__ */ new Set();
+  for (const formula of formulas) {
+    const hasDependencyFailure = formula.dependencies.some(
+      (dep) => failedFields.has(dep)
+    );
+    if (hasDependencyFailure) {
+      failedFields.add(formula.fieldName);
+      if (options.useDefaults) {
+        const defaultValue = getDefaultValue(formula, options.defaults);
+        setValueByPath2(values, formula.fieldName, defaultValue);
+        setValueByPath2(data, formula.fieldName, defaultValue);
+      }
+      errors.push(
+        createError(formula, "Dependency formula failed", options.useDefaults ?? false)
+      );
+      continue;
+    }
+    const formulaErrors = evaluateFormula(formula, data, values, options);
+    if (formulaErrors.length > 0) {
+      errors.push(...formulaErrors);
+      failedFields.add(formula.fieldName);
+    }
+  }
+  return { values, errors };
+}
+function enrichFormula(formula) {
+  const dependencies = parseDependencies(formula.expression);
+  const pathInfo = parseArrayItemPath(formula.fieldName);
+  return { ...formula, dependencies, ...pathInfo };
+}
+function parseDependencies(expression) {
+  try {
+    return formula.parseFormula(expression).dependencies;
+  } catch {
+    return [];
+  }
+}
+function parseArrayItemPath(fieldName) {
+  const bracketIndex = fieldName.indexOf("[]");
+  if (bracketIndex === -1) {
+    return { isArrayItem: false, arrayPath: null, localFieldPath: fieldName };
+  }
+  const arrayPath = fieldName.slice(0, bracketIndex);
+  const afterBrackets = fieldName.slice(bracketIndex + 2);
+  const localFieldPath = afterBrackets.startsWith(".") ? afterBrackets.slice(1) : afterBrackets;
+  return { isArrayItem: true, arrayPath, localFieldPath };
+}
+function orderByDependencies(formulas) {
+  const dependencies = Object.fromEntries(
+    formulas.map((f) => [f.fieldName, f.dependencies])
+  );
+  const result = formula.getTopologicalOrder(formula.buildDependencyGraph(dependencies));
+  if (!result.success) {
+    throw new Error(
+      `Cyclic dependency detected in formulas: ${result.error ?? "unknown error"}`
+    );
+  }
+  const formulaMap = new Map(formulas.map((f) => [f.fieldName, f]));
+  return result.order.map((name) => formulaMap.get(name)).filter((f) => f !== void 0);
+}
+function evaluateFormula(formula, data, values, options) {
+  if (formula.isArrayItem && formula.arrayPath) {
+    return evaluateArrayFormula(formula, data, values, options);
+  }
+  return evaluateSingleFormula(formula, data, values, options);
+}
+function evaluateSingleFormula(formula$1, data, values, options) {
+  const parentPath = getParentPath2(formula$1.fieldName);
+  const itemData = parentPath ? getValueByPath2(data, parentPath) : void 0;
+  const context = {
+    rootData: data,
+    ...itemData && { itemData, currentPath: parentPath }
+  };
+  try {
+    const result = formula.evaluateWithContext(formula$1.expression, context);
+    if (result === void 0) {
+      if (options.useDefaults) {
+        const defaultValue = getDefaultValue(formula$1, options.defaults);
+        setValueByPath2(values, formula$1.fieldName, defaultValue);
+        setValueByPath2(data, formula$1.fieldName, defaultValue);
+      }
+      return [
+        createError(
+          formula$1,
+          "Formula returned undefined",
+          options.useDefaults ?? false
+        )
+      ];
+    }
+    setValueByPath2(values, formula$1.fieldName, result);
+    setValueByPath2(data, formula$1.fieldName, result);
+    return [];
+  } catch (error) {
+    if (options.useDefaults) {
+      const defaultValue = getDefaultValue(formula$1, options.defaults);
+      setValueByPath2(values, formula$1.fieldName, defaultValue);
+      setValueByPath2(data, formula$1.fieldName, defaultValue);
+    }
+    return [
+      createError(
+        formula$1,
+        error instanceof Error ? error.message : String(error),
+        options.useDefaults ?? false
+      )
+    ];
+  }
+}
+function evaluateArrayFormula(formula$1, data, values, options) {
+  const errors = [];
+  const arrayPath = formula$1.arrayPath;
+  const array = getValueByPath2(data, arrayPath);
+  if (!Array.isArray(array)) {
+    return errors;
+  }
+  for (let i = 0; i < array.length; i++) {
+    const item = array[i];
+    if (typeof item !== "object" || item === null) {
+      continue;
+    }
+    const itemData = item;
+    const fieldPath = `${arrayPath}[${i}].${formula$1.localFieldPath}`;
+    const context = {
+      rootData: data,
+      itemData,
+      currentPath: `${arrayPath}[${i}]`
+    };
+    try {
+      const result = formula.evaluateWithContext(formula$1.expression, context);
+      if (result === void 0) {
+        if (options.useDefaults) {
+          const defaultValue = getDefaultValue(formula$1, options.defaults);
+          setValueByPath2(values, fieldPath, defaultValue);
+          setValueByPath2(itemData, formula$1.localFieldPath, defaultValue);
+        }
+        errors.push({
+          field: fieldPath,
+          expression: formula$1.expression,
+          error: "Formula returned undefined",
+          defaultUsed: options.useDefaults ?? false
+        });
+        continue;
+      }
+      setValueByPath2(values, fieldPath, result);
+      setValueByPath2(itemData, formula$1.localFieldPath, result);
+    } catch (error) {
+      if (options.useDefaults) {
+        const defaultValue = getDefaultValue(formula$1, options.defaults);
+        setValueByPath2(values, fieldPath, defaultValue);
+        setValueByPath2(itemData, formula$1.localFieldPath, defaultValue);
+      }
+      errors.push({
+        field: fieldPath,
+        expression: formula$1.expression,
+        error: error instanceof Error ? error.message : String(error),
+        defaultUsed: options.useDefaults ?? false
+      });
+    }
+  }
+  return errors;
+}
+function getParentPath2(fieldPath) {
+  const lastDotIndex = fieldPath.lastIndexOf(".");
+  if (lastDotIndex === -1) {
+    return "";
+  }
+  return fieldPath.substring(0, lastDotIndex);
+}
+function getValueByPath2(obj, path) {
+  const segments = path.split(".");
+  let current = obj;
+  for (const segment of segments) {
+    if (current === null || current === void 0) {
+      return void 0;
+    }
+    current = current[segment];
+  }
+  return current;
+}
+function isSafeKey(key) {
+  return key !== "__proto__";
+}
+function setValueByPath2(obj, path, value) {
+  const segments = path.split(".");
+  let current = obj;
+  for (let i = 0; i < segments.length - 1; i++) {
+    const segment = segments[i];
+    if (!isSafeKey(segment)) {
+      return;
+    }
+    if (!(segment in current)) {
+      current[segment] = {};
+    }
+    current = current[segment];
+  }
+  const lastSegment = segments.at(-1);
+  if (!isSafeKey(lastSegment)) {
+    return;
+  }
+  current[lastSegment] = value;
+}
+function getDefaultValue(formula, defaults) {
+  if (defaults && formula.fieldName in defaults) {
+    return defaults[formula.fieldName];
+  }
+  switch (formula.fieldType) {
+    case "number":
+      return 0;
+    case "string":
+      return "";
+    case "boolean":
+      return false;
+    default:
+      return null;
+  }
+}
+function createError(formula, error, defaultUsed) {
+  return {
+    field: formula.fieldName,
+    expression: formula.expression,
+    error,
+    defaultUsed
+  };
+}
+
 // src/lib/getDBJsonPathByJsonSchemaStore.ts
 var getDBJsonPathByJsonSchemaStore = (store) => {
   let node = store;
@@ -824,6 +1317,10 @@ var SchemaTable = class {
   }
 };
 
+Object.defineProperty(exports, "formulaSpec", {
+  enumerable: true,
+  get: function () { return spec.formulaSpec; }
+});
 exports.SchemaTable = SchemaTable;
 exports.VALIDATE_JSON_FIELD_NAME_ERROR_MESSAGE = VALIDATE_JSON_FIELD_NAME_ERROR_MESSAGE;
 exports.applyAddPatch = applyAddPatch;
@@ -837,6 +1334,8 @@ exports.createJsonObjectSchemaStore = createJsonObjectSchemaStore;
 exports.createJsonSchemaStore = createJsonSchemaStore;
 exports.createPrimitiveStoreBySchema = createPrimitiveStoreBySchema;
 exports.deepEqual = deepEqual;
+exports.evaluateFormulas = evaluateFormulas;
+exports.extractSchemaFormulas = extractSchemaFormulas;
 exports.getDBJsonPathByJsonSchemaStore = getDBJsonPathByJsonSchemaStore;
 exports.getForeignKeyPatchesFromSchema = getForeignKeyPatchesFromSchema;
 exports.getForeignKeysFromSchema = getForeignKeysFromSchema;
@@ -850,12 +1349,15 @@ exports.getValueByPath = getValueByPath;
 exports.hasPath = hasPath;
 exports.parsePath = parsePath;
 exports.pluginRefs = pluginRefs;
+exports.prepareFormulas = prepareFormulas;
 exports.replaceForeignKeyValue = replaceForeignKeyValue;
 exports.resolveRefs = resolveRefs;
 exports.saveSharedFields = saveSharedFields;
 exports.setValueByPath = setValueByPath;
 exports.traverseStore = traverseStore;
 exports.traverseValue = traverseValue;
+exports.validateFormulaAgainstSchema = validateFormulaAgainstSchema;
 exports.validateJsonFieldName = validateJsonFieldName;
-//# sourceMappingURL=chunk-UJBE43WI.cjs.map
-//# sourceMappingURL=chunk-UJBE43WI.cjs.map
+exports.validateSchemaFormulas = validateSchemaFormulas;
+//# sourceMappingURL=chunk-M6IMV3AN.cjs.map
+//# sourceMappingURL=chunk-M6IMV3AN.cjs.map