@revisium/formula 0.2.1 → 0.4.0

package/README.md

@@ -3,7 +3,7 @@
 # @revisium/formula
 
 [![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=revisium_formula&metric=alert_status)](https://sonarcloud.io/summary/new_code?id=revisium_formula)
-[![codecov](https://codecov.io/gh/revisium/formula/graph/badge.svg)](https://codecov.io/gh/revisium/formula)
+[![Coverage](https://sonarcloud.io/api/project_badges/measure?project=revisium_formula&metric=coverage)](https://sonarcloud.io/summary/new_code?id=revisium_formula)
 [![GitHub License](https://img.shields.io/badge/License-MIT-green.svg)](https://github.com/revisium/formula/blob/master/LICENSE)
 [![GitHub Release](https://img.shields.io/github/v/release/revisium/formula)](https://github.com/revisium/formula/releases)
 
@@ -46,6 +46,13 @@ evaluate('items[0].price + items[1].price', { items: [{ price: 10 }, { price: 20
 evaluate('price > 100', { price: 150 });
 // true
 
+// Fields named like functions
+evaluate('max(max, 0)', { max: 10 });
+// 10 (max() function is called with field "max" as argument)
+
+evaluate('max(max - field.min, 0)', { max: 100, field: { min: 20 } });
+// 80
+
 // Type inference
 import { inferFormulaType } from '@revisium/formula';
 
@@ -72,6 +79,25 @@ validateFormulaAgainstSchema('price * quantity', 'total', schema);
 
 validateFormulaAgainstSchema('price > 100', 'total', schema);
 // { field: 'total', error: "Type mismatch: formula returns 'boolean' but field expects 'number'" }
+
+// Array item formulas with path resolution
+import { evaluateWithContext } from '@revisium/formula';
+
+// Absolute path: /field always resolves from root data
+evaluateWithContext('price * (1 + /taxRate)', {
+  rootData: { taxRate: 0.1, items: [{ price: 100 }] },
+  itemData: { price: 100 },
+  currentPath: 'items[0]'
+});
+// 110
+
+// Relative path: ../field resolves from parent (root)
+evaluateWithContext('price * (1 - ../discount)', {
+  rootData: { discount: 0.2, items: [] },
+  itemData: { price: 100 },
+  currentPath: 'items[0]'
+});
+// 80
 ```
 
 ## API
@@ -83,6 +109,7 @@ validateFormulaAgainstSchema('price > 100', 'total', schema);
 | `parseFormula` | Low-level parser returning AST, dependencies, features |
 | `validateSyntax` | Validate expression syntax |
 | `evaluate` | Evaluate expression with context |
+| `evaluateWithContext` | Evaluate with automatic `/` and `../` path resolution |
 | `inferFormulaType` | Infer return type of expression |
 
 ### Expression API
@@ -116,14 +143,19 @@ validateFormulaAgainstSchema('price > 100', 'total', schema);
 | `obj.field` | Nested object | `stats.damage` |
 | `arr[N]` | Array index | `items[0].price` |
 | `arr[-1]` | Last element | `items[-1]` |
+| `/field` | Absolute path (from root) | `/taxRate`, `/config.tax` |
+| `../field` | Relative path (parent scope) | `../discount`, `../settings.multiplier` |
 
 ## Version Detection
 
 | Feature | Min Version |
 |---------|-------------|
 | Simple refs (`field`) | 1.0 |
+| Function-named fields | 1.0 |
 | Nested paths (`a.b`) | 1.1 |
 | Array index (`[0]`, `[-1]`) | 1.1 |
+| Absolute paths (`/field`) | 1.1 |
+| Relative paths (`../field`) | 1.1 |
 
 ## License
 

package/dist/{chunk-5NMNSRHH.cjs → chunk-AGBOCJGV.cjs}

@@ -296,6 +296,125 @@ token("*", 200, (a) => {
   if (!a) return createWildcardLiteral();
   return void 0;
 });
+token("/", 200, (a) => {
+  if (a) return;
+  const name = next2(isIdChar);
+  if (!name) return;
+  return "/" + name;
+});
+var isRelativePathChar = (c) => isIdChar(c) || c === 47 || c === 46 ? 1 : 0;
+token(".", 200, (a) => {
+  if (a) return;
+  const second = next2((c) => c === 46 ? 1 : 0);
+  if (!second) return;
+  const rest = next2(isRelativePathChar);
+  if (!rest) return;
+  return ".." + rest;
+});
+var BUILTIN_FUNCTIONS = {
+  and: (a, b) => Boolean(a) && Boolean(b),
+  or: (a, b) => Boolean(a) || Boolean(b),
+  not: (a) => !a,
+  concat: (...args) => args.map(String).join(""),
+  upper: (s) => String(s).toUpperCase(),
+  lower: (s) => String(s).toLowerCase(),
+  trim: (s) => String(s).trim(),
+  left: (s, n) => {
+    const count = Math.max(0, Math.floor(Number(n)));
+    return String(s).slice(0, count);
+  },
+  right: (s, n) => {
+    const str = String(s);
+    const count = Math.max(0, Math.floor(Number(n)));
+    return count === 0 ? "" : str.slice(-count);
+  },
+  replace: (s, search, replacement) => String(s).replace(String(search), String(replacement)),
+  tostring: String,
+  length: (s) => {
+    if (Array.isArray(s)) return s.length;
+    if (typeof s === "string") return s.length;
+    if (s !== null && typeof s === "object") return Object.keys(s).length;
+    return String(s).length;
+  },
+  contains: (s, search) => String(s).includes(String(search)),
+  startswith: (s, search) => String(s).startsWith(String(search)),
+  endswith: (s, search) => String(s).endsWith(String(search)),
+  tonumber: Number,
+  toboolean: Boolean,
+  isnull: (v) => v === null || v === void 0,
+  coalesce: (...args) => args.find((v) => v !== null && v !== void 0) ?? null,
+  round: (n, decimals) => {
+    const num2 = Number(n);
+    const dec = decimals === void 0 ? 0 : Number(decimals);
+    const factor = 10 ** dec;
+    return Math.round(num2 * factor) / factor;
+  },
+  floor: (n) => Math.floor(Number(n)),
+  ceil: (n) => Math.ceil(Number(n)),
+  abs: (n) => Math.abs(Number(n)),
+  sqrt: (n) => Math.sqrt(Number(n)),
+  pow: (base, exp) => Math.pow(Number(base), Number(exp)),
+  min: (...args) => args.length === 0 ? Number.NaN : Math.min(...args.map(Number)),
+  max: (...args) => args.length === 0 ? Number.NaN : Math.max(...args.map(Number)),
+  log: (n) => Math.log(Number(n)),
+  log10: (n) => Math.log10(Number(n)),
+  exp: (n) => Math.exp(Number(n)),
+  sign: (n) => Math.sign(Number(n)),
+  sum: (arr) => Array.isArray(arr) ? arr.reduce((a, b) => a + Number(b), 0) : 0,
+  avg: (arr) => Array.isArray(arr) && arr.length > 0 ? arr.reduce((a, b) => a + Number(b), 0) / arr.length : 0,
+  count: (arr) => Array.isArray(arr) ? arr.length : 0,
+  first: (arr) => Array.isArray(arr) ? arr[0] : void 0,
+  last: (arr) => Array.isArray(arr) ? arr.at(-1) : void 0,
+  join: (arr, separator) => {
+    if (!Array.isArray(arr)) return "";
+    if (separator === void 0) return arr.join(",");
+    if (typeof separator === "string") return arr.join(separator);
+    if (typeof separator === "number") return arr.join(String(separator));
+    return arr.join(",");
+  },
+  includes: (arr, value) => Array.isArray(arr) ? arr.includes(value) : false,
+  if: (condition, ifTrue, ifFalse) => condition ? ifTrue : ifFalse
+};
+function extractCallArgs(argsNode) {
+  if (!argsNode) return [];
+  if (!Array.isArray(argsNode)) return [argsNode];
+  if (argsNode[0] === ",") {
+    return argsNode.slice(1);
+  }
+  return [argsNode];
+}
+function compileNode(node) {
+  return compile(node);
+}
+function createGroupingEvaluator(fn) {
+  const compiledExpr = compileNode(fn);
+  return (ctx) => compiledExpr(ctx);
+}
+function createFunctionCallEvaluator(fn, argsNode) {
+  const args = extractCallArgs(argsNode);
+  const compiledArgs = args.map((arg) => compileNode(arg));
+  return (ctx) => {
+    const argValues = compiledArgs.map((a) => a(ctx));
+    if (typeof fn === "string") {
+      const builtinFn = BUILTIN_FUNCTIONS[fn.toLowerCase()];
+      if (builtinFn) {
+        return builtinFn(...argValues);
+      }
+    }
+    const fnValue = compileNode(fn)(ctx);
+    if (typeof fnValue === "function") {
+      return fnValue(...argValues);
+    }
+    const fnName = typeof fn === "string" ? fn : String(fn);
+    throw new Error(`'${fnName}' is not a function`);
+  };
+}
+operator("()", (fn, argsNode) => {
+  if (argsNode === void 0) {
+    return createGroupingEvaluator(fn);
+  }
+  return createFunctionCallEvaluator(fn, argsNode);
+});
 var KEYWORDS = /* @__PURE__ */ new Set([
   "true",
   "false",
@@ -304,9 +423,6 @@ var KEYWORDS = /* @__PURE__ */ new Set([
   "or",
   "not",
   "if",
-  "constructor",
-  "__proto__",
-  "prototype",
   "round",
   "floor",
   "ceil",
@@ -341,8 +457,6 @@ var KEYWORDS = /* @__PURE__ */ new Set([
   "first",
   "last",
   "join",
-  "filter",
-  "map",
   "includes"
 ]);
 var ARRAY_FUNCTIONS = /* @__PURE__ */ new Set([
@@ -352,8 +466,6 @@ var ARRAY_FUNCTIONS = /* @__PURE__ */ new Set([
   "first",
   "last",
   "join",
-  "filter",
-  "map",
   "includes"
 ]);
 function isKeyword(name) {
@@ -365,6 +477,12 @@ function isArrayFunction(name) {
 function isContextToken(name) {
   return name.startsWith("@") || name.startsWith("#");
 }
+function isRootPath(name) {
+  return name.startsWith("/");
+}
+function isRelativePath(name) {
+  return name.startsWith("..");
+}
 function isValidIdentifierRoot(rootName) {
   return !isKeyword(rootName) && !isContextToken(rootName);
 }
@@ -377,6 +495,10 @@ function addPathIfValid(path, identifiers) {
   }
 }
 function collectStringIdentifier(node, identifiers) {
+  if (isRootPath(node) || isRelativePath(node)) {
+    identifiers.add(node);
+    return;
+  }
   if (!isContextToken(node) && !isKeyword(node)) {
     identifiers.add(node);
   }
@@ -409,6 +531,9 @@ function collectIdentifiers(node, identifiers) {
   if (!Array.isArray(node)) {
     return;
   }
+  if (isLiteralArray(node)) {
+    return;
+  }
   const [op, ...args] = node;
   if (op === "." || op === "[]") {
     collectPathOrFallback(node, identifiers);
@@ -506,16 +631,25 @@ function detectFunctionCallFeatures(funcName, features) {
     features.add("array_function");
   }
 }
-function detectFeatures(node, features) {
-  if (typeof node === "string") {
-    if (isContextToken(node)) {
-      features.add("context_token");
+function detectStringFeatures(node, features) {
+  if (isContextToken(node)) {
+    features.add("context_token");
+  }
+  if (isRootPath(node)) {
+    features.add("root_path");
+    if (node.includes(".")) {
+      features.add("nested_path");
     }
-    return;
   }
-  if (!Array.isArray(node) || isLiteralArray(node)) {
-    return;
+  if (isRelativePath(node)) {
+    features.add("relative_path");
+    const withoutPrefix = node.replace(/^(\.\.\/)+/, "");
+    if (withoutPrefix.includes(".")) {
+      features.add("nested_path");
+    }
   }
+}
+function detectOperatorFeatures(node, features) {
   const op = node[0];
   if (op === ".") {
     features.add("nested_path");
@@ -526,6 +660,16 @@ function detectFeatures(node, features) {
   if (op === "()") {
     detectFunctionCallFeatures(node[1], features);
   }
+}
+function detectFeatures(node, features) {
+  if (typeof node === "string") {
+    detectStringFeatures(node, features);
+    return;
+  }
+  if (!Array.isArray(node) || isLiteralArray(node)) {
+    return;
+  }
+  detectOperatorFeatures(node, features);
   for (let i = 1; i < node.length; i++) {
     detectFeatures(node[i], features);
   }
@@ -574,20 +718,63 @@ function evaluate(expression, context) {
     throw new Error("Empty expression");
   }
   const fn = subscript_default(trimmed);
-  return fn(context);
+  const safeContext = {};
+  for (const [key, value] of Object.entries(context)) {
+    if (typeof value !== "function") {
+      safeContext[key] = value;
+    }
+  }
+  return fn(safeContext);
+}
+function getValueByPath(data, path) {
+  const segments = path.split(".");
+  let current = data;
+  for (const segment of segments) {
+    if (current === null || current === void 0) {
+      return void 0;
+    }
+    if (typeof current !== "object") {
+      return void 0;
+    }
+    current = current[segment];
+  }
+  return current;
+}
+function buildPathReferences(rootData, dependencies) {
+  const refs = {};
+  for (const dep of dependencies) {
+    if (dep.startsWith("/")) {
+      const fieldPath = dep.slice(1);
+      const rootField = fieldPath.split(".")[0] ?? fieldPath;
+      const contextKey = "/" + rootField;
+      if (!(contextKey in refs)) {
+        refs[contextKey] = getValueByPath(rootData, rootField);
+      }
+    } else if (dep.startsWith("../")) {
+      const fieldPath = dep.slice(3);
+      refs[dep] = getValueByPath(rootData, fieldPath);
+    }
+  }
+  return refs;
+}
+function evaluateWithContext(expression, options) {
+  const { rootData, itemData } = options;
+  const trimmed = expression.trim();
+  if (!trimmed) {
+    throw new Error("Empty expression");
+  }
+  const parsed = parseFormula(trimmed);
+  const pathRefs = buildPathReferences(rootData, parsed.dependencies);
+  const context = {
+    ...rootData,
+    ...itemData ?? {},
+    ...pathRefs
+  };
+  return evaluate(trimmed, context);
 }
 var ARITHMETIC_OPS = /* @__PURE__ */ new Set(["+", "-", "*", "/", "%"]);
-var COMPARISON_OPS = /* @__PURE__ */ new Set([
-  "<",
-  ">",
-  "<=",
-  ">=",
-  "==",
-  "!=",
-  "===",
-  "!=="
-]);
-var LOGICAL_OPS = /* @__PURE__ */ new Set(["&&", "||", "!", "and", "or", "not"]);
+var COMPARISON_OPS = /* @__PURE__ */ new Set(["<", ">", "<=", ">=", "==", "!="]);
+var LOGICAL_OPS = /* @__PURE__ */ new Set(["&&", "||", "!"]);
 var NUMERIC_FUNCTIONS = /* @__PURE__ */ new Set([
   "round",
   "floor",
@@ -604,7 +791,8 @@ var NUMERIC_FUNCTIONS = /* @__PURE__ */ new Set([
   "sum",
   "avg",
   "count",
-  "tonumber"
+  "tonumber",
+  "length"
 ]);
 var STRING_FUNCTIONS = /* @__PURE__ */ new Set([
   "concat",
@@ -618,6 +806,9 @@ var STRING_FUNCTIONS = /* @__PURE__ */ new Set([
   "join"
 ]);
 var BOOLEAN_FUNCTIONS = /* @__PURE__ */ new Set([
+  "and",
+  "or",
+  "not",
   "contains",
   "startswith",
   "endswith",
@@ -647,7 +838,12 @@ function inferLiteralArrayType(node) {
   if (typeof val === "boolean") return "boolean";
   return "unknown";
 }
-function inferOperatorType(op, argsLength) {
+function inferOperatorType(op, argsLength, argTypes) {
+  if (op === "+" && argTypes) {
+    if (argTypes.includes("string")) return "string";
+    if (argTypes.includes("unknown")) return "unknown";
+    return "number";
+  }
   if (ARITHMETIC_OPS.has(op)) return "number";
   if (COMPARISON_OPS.has(op)) return "boolean";
   if (LOGICAL_OPS.has(op)) return "boolean";
@@ -672,7 +868,8 @@ function inferTypeFromNode(node, fieldTypes) {
   if (!Array.isArray(node)) return "unknown";
   if (isLiteralArray(node)) return inferLiteralArrayType(node);
   const [op, ...args] = node;
-  const operatorType = inferOperatorType(op, args.length);
+  const argTypes = op === "+" ? args.map((arg) => inferTypeFromNode(arg, fieldTypes)) : void 0;
+  const operatorType = inferOperatorType(op, args.length, argTypes);
   if (operatorType !== null) return operatorType;
   if (op === "." || op === "[]") {
     return inferPropertyAccessType(node, fieldTypes);
@@ -828,21 +1025,104 @@ function processQueue(queue, graph, inDegree) {
 // src/extract-schema.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,
+        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);
+    }
   }
-  return formulas;
 }
 
 // src/validate-schema.ts
+function resolveSubSchema(schema, fieldPath) {
+  if (!fieldPath) {
+    return schema;
+  }
+  const segments = parsePathSegments(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 parsePathSegments(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 ?? {};
@@ -877,44 +1157,56 @@ function extractFieldRoot(dependency) {
   const root = dependency.split(".")[0]?.split("[")[0];
   return root || dependency;
 }
-function validateFormulaAgainstSchema(expression, fieldName, schema) {
+function validateFormulaInContext(expression, fieldPath, rootSchema) {
   const syntaxResult = validateFormulaSyntax(expression);
   if (!syntaxResult.isValid) {
     return {
-      field: fieldName,
+      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 = parseExpression(expression);
-  const schemaFields = getSchemaFields(schema);
+  const schemaFields = getSchemaFields(contextSchema);
   for (const dep of parseResult.dependencies) {
     const rootField = extractFieldRoot(dep);
     if (!schemaFields.has(rootField)) {
       return {
-        field: fieldName,
+        field: fieldPath,
         error: `Unknown field '${rootField}' in formula`
       };
     }
   }
-  if (parseResult.dependencies.some((d) => extractFieldRoot(d) === fieldName)) {
+  if (parseResult.dependencies.some((d) => extractFieldRoot(d) === localFieldName)) {
     return {
-      field: fieldName,
+      field: fieldPath,
       error: `Formula cannot reference itself`
     };
   }
-  const fieldSchema = schema.properties?.[fieldName];
+  const fieldSchema = contextSchema.properties?.[localFieldName];
   const expectedType = schemaTypeToInferred(fieldSchema?.type);
-  const fieldTypes = getSchemaFieldTypes(schema);
+  const fieldTypes = getSchemaFieldTypes(contextSchema);
   const inferredType = inferFormulaType(expression, fieldTypes);
   if (!isTypeCompatible(inferredType, expectedType)) {
     return {
-      field: fieldName,
+      field: fieldPath,
       error: `Type mismatch: formula returns '${inferredType}' but field expects '${expectedType}'`
     };
   }
   return null;
 }
+function validateFormulaAgainstSchema(expression, fieldName, schema) {
+  return validateFormulaInContext(expression, fieldName, schema);
+}
 function validateSchemaFormulas(schema) {
   const errors = [];
   const formulas = extractSchemaFormulas(schema);
@@ -934,7 +1226,12 @@ function validateSchemaFormulas(schema) {
   const dependencies = {};
   for (const formula of formulas) {
     const parseResult = parseExpression(formula.expression);
-    dependencies[formula.fieldName] = parseResult.dependencies.map(extractFieldRoot);
+    const parentPath = getParentPath(formula.fieldName);
+    const prefix = parentPath ? `${parentPath}.` : "";
+    dependencies[formula.fieldName] = parseResult.dependencies.map((dep) => {
+      const rootField = extractFieldRoot(dep);
+      return `${prefix}${rootField}`;
+    });
   }
   const graph = buildDependencyGraph(dependencies);
   const circularCheck = detectCircularDependencies(graph);
@@ -955,6 +1252,7 @@ function validateSchemaFormulas(schema) {
 exports.buildDependencyGraph = buildDependencyGraph;
 exports.detectCircularDependencies = detectCircularDependencies;
 exports.evaluate = evaluate;
+exports.evaluateWithContext = evaluateWithContext;
 exports.extractSchemaFormulas = extractSchemaFormulas;
 exports.getTopologicalOrder = getTopologicalOrder;
 exports.inferFormulaType = inferFormulaType;
@@ -964,5 +1262,5 @@ exports.validateFormulaAgainstSchema = validateFormulaAgainstSchema;
 exports.validateFormulaSyntax = validateFormulaSyntax;
 exports.validateSchemaFormulas = validateSchemaFormulas;
 exports.validateSyntax = validateSyntax;
-//# sourceMappingURL=chunk-5NMNSRHH.cjs.map
-//# sourceMappingURL=chunk-5NMNSRHH.cjs.map
+//# sourceMappingURL=chunk-AGBOCJGV.cjs.map
+//# sourceMappingURL=chunk-AGBOCJGV.cjs.map