@stndrds/schema 1.0.0-alpha.112 → 1.0.0-alpha.113

package/dist/index.js

@@ -22,6 +22,7 @@ require('./chunk-P2BE2A2G.js');
 var chunkT225DB55_js = require('./chunk-T225DB55.js');
 var constants = require('@stndrds/constants');
 var z3 = require('zod');
+var exprEval = require('expr-eval');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
@@ -4842,6 +4843,335 @@ var FormRegistry = class {
   }
 };
 var formRegistry = new FormRegistry();
+var DOS_PROTECTION_LIMITS = {
+  MAX_EXPRESSION_LENGTH: 1e4,
+  MAX_TOKEN_COUNT: 1e3,
+  MAX_NESTING_DEPTH: 50
+};
+function createFormulaParser() {
+  const parser = new exprEval.Parser();
+  parser.functions.IF = (condition, thenValue, elseValue) => condition ? thenValue : elseValue;
+  parser.functions.AND = (...args) => args.every(Boolean);
+  parser.functions.OR = (...args) => args.some(Boolean);
+  parser.functions.NOT = (value) => !value;
+  parser.functions.EMPTY = (value) => value === null || value === void 0 || value === "";
+  parser.functions.COALESCE = (...args) => args.find((a) => a != null) ?? null;
+  parser.functions.DEFAULT = (value, defaultValue) => value == null || value === "" ? defaultValue : value;
+  parser.functions.CONCAT = (...args) => args.filter((a) => a != null).map(String).join("");
+  parser.functions.UPPER = (value) => String(value ?? "").toUpperCase();
+  parser.functions.LOWER = (value) => String(value ?? "").toLowerCase();
+  parser.functions.TRIM = (value) => String(value ?? "").trim();
+  parser.functions.LENGTH = (value) => String(value ?? "").length;
+  parser.functions.LEFT = (value, count) => String(value ?? "").slice(0, count);
+  parser.functions.RIGHT = (value, count) => String(value ?? "").slice(-count);
+  parser.functions.REPLACE = (value, search, replacement) => String(value ?? "").split(String(search)).join(replacement);
+  parser.functions.CONTAINS = (value, search) => String(value ?? "").toLowerCase().includes(String(search).toLowerCase());
+  parser.functions.ROUND = (value, decimals = 0) => {
+    if (typeof value !== "number" || Number.isNaN(value)) return null;
+    const factor = 10 ** decimals;
+    return Math.round(value * factor) / factor;
+  };
+  parser.functions.FLOOR = (value) => {
+    if (typeof value !== "number" || Number.isNaN(value)) return null;
+    return Math.floor(value);
+  };
+  parser.functions.CEIL = (value) => {
+    if (typeof value !== "number" || Number.isNaN(value)) return null;
+    return Math.ceil(value);
+  };
+  parser.functions.ABS = (value) => {
+    if (typeof value !== "number" || Number.isNaN(value)) return null;
+    return Math.abs(value);
+  };
+  parser.functions.MIN = (...args) => {
+    const nums = args.filter((n) => typeof n === "number" && !Number.isNaN(n));
+    return nums.length > 0 ? Math.min(...nums) : null;
+  };
+  parser.functions.MAX = (...args) => {
+    const nums = args.filter((n) => typeof n === "number" && !Number.isNaN(n));
+    return nums.length > 0 ? Math.max(...nums) : null;
+  };
+  parser.functions.POW = (base, exponent) => {
+    if (typeof base !== "number" || typeof exponent !== "number") return null;
+    if (exponent > 1e3 || exponent < -1e3) return null;
+    return base ** exponent;
+  };
+  parser.functions.MOD = (a, b) => {
+    if (typeof a !== "number" || typeof b !== "number" || b === 0) return null;
+    return a % b;
+  };
+  parser.functions.NOW = () => (/* @__PURE__ */ new Date()).toISOString();
+  parser.functions.TODAY = () => (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  parser.functions.YEAR = (value) => {
+    const date2 = parseDate(value);
+    return date2 ? date2.getFullYear() : null;
+  };
+  parser.functions.MONTH = (value) => {
+    const date2 = parseDate(value);
+    return date2 ? date2.getMonth() + 1 : null;
+  };
+  parser.functions.DAY = (value) => {
+    const date2 = parseDate(value);
+    return date2 ? date2.getDate() : null;
+  };
+  parser.functions.DATE_DIFF = (date1, date2, unit = "days") => {
+    const d1 = parseDate(date1);
+    const d2 = parseDate(date2);
+    if (d1 === null || d2 === null) return null;
+    const diffMs = d1.getTime() - d2.getTime();
+    const MS_PER_DAY = 1e3 * 60 * 60 * 24;
+    const conversions = {
+      years: MS_PER_DAY * 365,
+      months: MS_PER_DAY * 30,
+      weeks: MS_PER_DAY * 7,
+      days: MS_PER_DAY,
+      hours: 1e3 * 60 * 60,
+      minutes: 1e3 * 60
+    };
+    const divisor = conversions[unit] ?? MS_PER_DAY;
+    return diffMs / divisor;
+  };
+  return parser;
+}
+function parseDate(value) {
+  if (!value) return null;
+  if (value instanceof Date) return value;
+  if (typeof value === "string" || typeof value === "number") {
+    const date2 = new Date(value);
+    return Number.isNaN(date2.getTime()) ? null : date2;
+  }
+  return null;
+}
+var formulaParser = createFormulaParser();
+function validateFormulaComplexity(expression) {
+  if (expression.length > DOS_PROTECTION_LIMITS.MAX_EXPRESSION_LENGTH) {
+    return {
+      valid: false,
+      error: `Expression too long (${expression.length} chars, max ${DOS_PROTECTION_LIMITS.MAX_EXPRESSION_LENGTH})`
+    };
+  }
+  const nestingDepth = calculateNestingDepth(expression);
+  if (nestingDepth > DOS_PROTECTION_LIMITS.MAX_NESTING_DEPTH) {
+    return {
+      valid: false,
+      error: `Expression too deeply nested (${nestingDepth} levels, max ${DOS_PROTECTION_LIMITS.MAX_NESTING_DEPTH})`
+    };
+  }
+  try {
+    formulaParser.parse(expression);
+    const tokenCountApprox = estimateTokenCount(expression);
+    if (tokenCountApprox > DOS_PROTECTION_LIMITS.MAX_TOKEN_COUNT) {
+      return {
+        valid: false,
+        error: `Expression too complex (approx ${tokenCountApprox} tokens, max ${DOS_PROTECTION_LIMITS.MAX_TOKEN_COUNT})`
+      };
+    }
+    return { valid: true };
+  } catch {
+    return { valid: true };
+  }
+}
+function estimateTokenCount(expression) {
+  const tokens = expression.match(/-?\d+\.?\d*|[a-zA-Z_][a-zA-Z0-9_]*|[+\-*/(),.><=!&|]+|'(?:[^'\\]|\\.)*'/g) ?? [];
+  return tokens.length;
+}
+function calculateNestingDepth(expression) {
+  let maxDepth = 0;
+  let currentDepth = 0;
+  for (const char of expression) {
+    if (char === "(") {
+      currentDepth++;
+      if (currentDepth > maxDepth) maxDepth = currentDepth;
+    } else if (char === ")") {
+      currentDepth--;
+    }
+  }
+  return maxDepth;
+}
+function evaluateFormula(expression, values) {
+  try {
+    const complexityCheck = validateFormulaComplexity(expression);
+    if (!complexityCheck.valid) return null;
+    const parsed = formulaParser.parse(expression);
+    return parsed.evaluate(values);
+  } catch {
+    return null;
+  }
+}
+function evaluateFormulaWithResult(expression, values) {
+  try {
+    const complexityCheck = validateFormulaComplexity(expression);
+    if (!complexityCheck.valid) {
+      return { value: null, error: complexityCheck.error };
+    }
+    const parsed = formulaParser.parse(expression);
+    const value = parsed.evaluate(values);
+    return { value };
+  } catch (error) {
+    return { value: null, error: getErrorMessage(error) };
+  }
+}
+function formatFormulaResult(value, returnType, decimals) {
+  if (value === null || value === void 0) return null;
+  switch (returnType) {
+    case "number": {
+      const num = typeof value === "number" ? value : Number(value);
+      if (Number.isNaN(num)) return null;
+      return decimals !== void 0 ? Number(num.toFixed(decimals)) : num;
+    }
+    case "boolean":
+      return Boolean(value);
+    case "date":
+      if (value instanceof Date) return value.toISOString();
+      if (typeof value === "string") return value;
+      return null;
+    case "text":
+      return String(value);
+  }
+}
+function evaluateFormulaAttribute(attr, values) {
+  const raw = evaluateFormula(attr.expression, values);
+  return formatFormulaResult(raw, attr.returnType, attr.decimals);
+}
+function validateFormulaExpression(expression) {
+  try {
+    const complexityCheck = validateFormulaComplexity(expression);
+    if (!complexityCheck.valid) return complexityCheck;
+    formulaParser.parse(expression);
+    return { valid: true };
+  } catch (error) {
+    return { valid: false, error: getErrorMessage(error) };
+  }
+}
+function extractFormulaVariables(expression) {
+  try {
+    const parsed = formulaParser.parse(expression);
+    return parsed.variables();
+  } catch {
+    return [];
+  }
+}
+var RELATION_REF_PATTERN = /\b([a-zA-Z_][a-zA-Z0-9_]*)\.([a-zA-Z_][a-zA-Z0-9_]*)\b/g;
+function extractRelationReferences(expression) {
+  const regex = new RegExp(RELATION_REF_PATTERN.source, "g");
+  const matches = expression.matchAll(regex);
+  return [...matches].map((m) => m[0]);
+}
+function extractRelationNames(expression) {
+  const refs = extractRelationReferences(expression);
+  const names = refs.map((ref) => ref.split(".")[0]);
+  return [...new Set(names)];
+}
+function hasRelationReferences(expression) {
+  const regex = new RegExp(RELATION_REF_PATTERN.source);
+  return regex.test(expression);
+}
+function flattenRelationsForEval(resolvedRelations) {
+  const result = {};
+  for (const [relationName, values] of Object.entries(resolvedRelations)) {
+    result[relationName] = { ...values };
+  }
+  return result;
+}
+
+// src/formula/path-parser.ts
+var InvalidPathError = class extends Error {
+  constructor(path, segment, reason) {
+    super(`Invalid path "${path}" at "${segment}": ${reason}`);
+    this.path = path;
+    this.segment = segment;
+    this.reason = reason;
+    this.name = "InvalidPathError";
+  }
+};
+var MaxDepthExceededError = class extends Error {
+  constructor(path, maxDepth) {
+    super(`Path "${path}" exceeds maximum depth of ${maxDepth}`);
+    this.path = path;
+    this.maxDepth = maxDepth;
+    this.name = "MaxDepthExceededError";
+  }
+};
+async function parsePath(path, startSchema, getSchema, maxDepth = 5) {
+  const segments = path.split(".");
+  if (segments.length === 0 || segments.length === 1 && segments[0] === "") {
+    throw new InvalidPathError(path, path, "Path cannot be empty");
+  }
+  if (segments.length > maxDepth) {
+    throw new MaxDepthExceededError(path, maxDepth);
+  }
+  const result = [];
+  let currentSchema = startSchema;
+  for (let i = 0; i < segments.length; i++) {
+    const segmentName = segments[i];
+    const isLastSegment = i === segments.length - 1;
+    const attr = currentSchema.attributes.find((a) => a.name === segmentName);
+    if (!attr) {
+      throw new InvalidPathError(
+        path,
+        segmentName,
+        `Attribute "${segmentName}" not found in object "${currentSchema.name}"`
+      );
+    }
+    if (attr.type === "relation") {
+      const relationAttr = attr;
+      const targetObject = relationAttr.targets[0]?.object;
+      if (!targetObject) {
+        throw new InvalidPathError(path, segmentName, "Relation has no target object");
+      }
+      result.push({
+        name: segmentName,
+        type: "relation",
+        cardinality: relationAttr.cardinality,
+        targetObject
+      });
+      if (!isLastSegment) {
+        const nextSchema = await getSchema(targetObject);
+        if (!nextSchema) {
+          throw new InvalidPathError(
+            path,
+            segmentName,
+            `Target object "${targetObject}" schema not found`
+          );
+        }
+        currentSchema = nextSchema;
+      }
+    } else {
+      if (!isLastSegment) {
+        throw new InvalidPathError(
+          path,
+          segmentName,
+          `"${segmentName}" is not a relation but has segments after it`
+        );
+      }
+      result.push({ name: segmentName, type: "attribute" });
+    }
+  }
+  return result;
+}
+async function validatePath(path, startSchema, getSchema, maxDepth = 5) {
+  try {
+    await parsePath(path, startSchema, getSchema, maxDepth);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function pathHasManyCardinality(segments) {
+  return segments.some((s) => s.type === "relation" && s.cardinality === "many");
+}
+function getPathDepth(segments) {
+  return segments.filter((s) => s.type === "relation").length;
+}
+function getTargetAttributeName(path) {
+  const parts = path.split(".");
+  return parts[parts.length - 1];
+}
+function getRelationPath(path) {
+  const parts = path.split(".");
+  if (parts.length <= 1) return null;
+  return parts.slice(0, -1).join(".");
+}
 
 Object.defineProperty(exports, "asTenantId", {
   enumerable: true,
@@ -4923,8 +5253,10 @@ exports.FormRowBuilder = FormRowBuilder;
 exports.FormStepBuilder = FormStepBuilder;
 exports.GroupBuilder = GroupBuilder;
 exports.IDENTITY_PROPERTIES = IDENTITY_PROPERTIES;
+exports.InvalidPathError = InvalidPathError;
 exports.ListViewBuilder = ListViewBuilder;
 exports.ListViewTabConfigBuilder = ListViewTabConfigBuilder;
+exports.MaxDepthExceededError = MaxDepthExceededError;
 exports.MemoryNotFoundError = MemoryNotFoundError;
 exports.NO_VALUE_OPERATORS = NO_VALUE_OPERATORS;
 exports.NoopGeocodingAdapter = NoopGeocodingAdapter;
@@ -4971,21 +5303,33 @@ exports.currency = currency;
 exports.date = date;
 exports.detailView = detailView;
 exports.document = document;
+exports.evaluateFormula = evaluateFormula;
+exports.evaluateFormulaAttribute = evaluateFormulaAttribute;
+exports.evaluateFormulaWithResult = evaluateFormulaWithResult;
 exports.extractAttributeNames = extractAttributeNames;
+exports.extractFormulaVariables = extractFormulaVariables;
+exports.extractRelationNames = extractRelationNames;
+exports.extractRelationReferences = extractRelationReferences;
 exports.file = file;
 exports.flagRegistry = flagRegistry;
+exports.flattenRelationsForEval = flattenRelationsForEval;
 exports.form = form;
 exports.formRegistry = formRegistry;
 exports.formatAttributeValue = formatAttributeValue;
+exports.formatFormulaResult = formatFormulaResult;
 exports.formula = formula;
 exports.generateDefaultDetailView = generateDefaultDetailView;
 exports.generateDefaultListView = generateDefaultListView;
 exports.getActiveTab = getActiveTab;
 exports.getErrorMessage = getErrorMessage;
+exports.getPathDepth = getPathDepth;
+exports.getRelationPath = getRelationPath;
 exports.getRollupFilterOperators = getRollupFilterOperators;
 exports.getSystemAttributeList = getSystemAttributeList;
+exports.getTargetAttributeName = getTargetAttributeName;
 exports.group = group;
 exports.hasOptions = hasOptions;
+exports.hasRelationReferences = hasRelationReferences;
 exports.inferInverseCardinality = inferInverseCardinality;
 exports.isAttributeInUseError = isAttributeInUseError;
 exports.isAttributeSortable = isAttributeSortable;
@@ -5021,6 +5365,8 @@ exports.multiselect = multiselect;
 exports.number = number;
 exports.numberFlag = numberFlag;
 exports.object = object;
+exports.parsePath = parsePath;
+exports.pathHasManyCardinality = pathHasManyCardinality;
 exports.phone = phone;
 exports.rating = rating;
 exports.registry = registry;
@@ -5038,4 +5384,6 @@ exports.textarea = textarea;
 exports.toUndefinedIfEmpty = toUndefinedIfEmpty;
 exports.user = user;
 exports.validateAttributeName = validateAttributeName;
+exports.validateFormulaExpression = validateFormulaExpression;
+exports.validatePath = validatePath;
 exports.viewRegistry = viewRegistry;