@stndrds/schema 0.1.0-alpha.18 → 0.1.0-alpha.20

package/dist/runtime.js

@@ -128,31 +128,435 @@ __export(runtime_exports, {
   FlowService: () => FlowService,
   GeocodingService: () => GeocodingService,
   GlobalSearchService: () => GlobalSearchService,
+  InvalidPathError: () => InvalidPathError,
+  MaxDepthExceededError: () => MaxDepthExceededError,
   NoopGeocodingAdapter: () => NoopGeocodingAdapter,
   NoopHookRegistry: () => NoopHookRegistry,
   ObjectSchemaService: () => ObjectSchemaService,
   PermissionService: () => PermissionService,
   RecordService: () => RecordService,
+  RelationResolverService: () => RelationResolverService,
   RelationService: () => RelationService,
+  RollupScheduler: () => RollupScheduler,
+  RollupService: () => RollupService,
   UserProfileService: () => UserProfileService,
   UserService: () => UserService,
   ViewService: () => ViewService,
   buildAuditChanges: () => buildAuditChanges,
   createMockAdapter: () => createMockAdapter,
   enrichValuesWithSelectLabels: () => enrichValuesWithSelectLabels,
+  evaluateFormula: () => evaluateFormula,
+  evaluateFormulaAttribute: () => evaluateFormulaAttribute,
+  evaluateFormulaAttributeWithRelations: () => evaluateFormulaAttributeWithRelations,
+  evaluateFormulaWithRelations: () => evaluateFormulaWithRelations,
+  evaluateFormulaWithResult: () => evaluateFormulaWithResult,
   extractAttributeNames: () => extractAttributeNames,
+  extractFormulaVariables: () => extractFormulaVariables,
+  extractRelationNames: () => extractRelationNames,
+  extractRelationReferences: () => extractRelationReferences,
+  flattenRelationsForEval: () => flattenRelationsForEval,
+  formatFormulaResult: () => formatFormulaResult,
+  getPathDepth: () => getPathDepth,
+  getRelationPath: () => getRelationPath,
   getSyncPreview: () => getSyncPreview,
+  getTargetAttributeName: () => getTargetAttributeName,
   getViewSyncPreview: () => getViewSyncPreview,
+  hasRelationReferences: () => hasRelationReferences,
   isLabelExpression: () => isLabelExpression,
+  parsePath: () => parsePath,
+  pathHasManyCardinality: () => pathHasManyCardinality,
   renderLabelExpression: () => renderLabelExpression,
+  resolveMultiplePaths: () => resolveMultiplePaths,
+  resolveSingleValue: () => resolveSingleValue,
   syncAll: () => syncAll,
   syncNativeObjects: () => syncNativeObjects,
   syncNativeViews: () => syncNativeViews,
+  traversePath: () => traversePath,
+  validateFormulaExpression: () => validateFormulaExpression,
+  validatePath: () => validatePath,
   verifyNativeObjectsSync: () => verifyNativeObjectsSync,
   verifyNativeViewsSync: () => verifyNativeViewsSync
 });
 module.exports = __toCommonJS(runtime_exports);
 
+// src/runtime/formula/evaluator.ts
+var import_expr_eval = require("expr-eval");
+function createFormulaParser() {
+  const parser = new import_expr_eval.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 ?? "").replace(new RegExp(search, "g"), 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;
+    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 date = parseDate(value);
+    return date ? date.getFullYear() : null;
+  };
+  parser.functions.MONTH = (value) => {
+    const date = parseDate(value);
+    return date ? date.getMonth() + 1 : null;
+  };
+  parser.functions.DAY = (value) => {
+    const date = parseDate(value);
+    return date ? date.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 date = new Date(value);
+    return Number.isNaN(date.getTime()) ? null : date;
+  }
+  return null;
+}
+var formulaParser = createFormulaParser();
+function evaluateFormula(expression, values) {
+  try {
+    const parsed = formulaParser.parse(expression);
+    return parsed.evaluate(values);
+  } catch {
+    return null;
+  }
+}
+function evaluateFormulaWithResult(expression, values) {
+  try {
+    const parsed = formulaParser.parse(expression);
+    const value = parsed.evaluate(values);
+    return { value };
+  } catch (error) {
+    return {
+      value: null,
+      error: error instanceof Error ? error.message : "Unknown error"
+    };
+  }
+}
+function formatFormulaResult(value, returnType, decimals) {
+  if (value === null || value === void 0) {
+    return null;
+  }
+  switch (returnType) {
+    case "number":
+      return formatNumberResult(value, decimals);
+    case "boolean":
+      return Boolean(value);
+    case "date":
+      return formatDateResult(value);
+    case "text":
+      return String(value);
+  }
+}
+function formatNumberResult(value, decimals) {
+  const num = typeof value === "number" ? value : Number(value);
+  if (Number.isNaN(num)) return null;
+  return decimals !== void 0 ? Number(num.toFixed(decimals)) : num;
+}
+function formatDateResult(value) {
+  if (value instanceof Date) return value.toISOString();
+  if (typeof value === "string") return value;
+  return null;
+}
+function evaluateFormulaAttribute(attr, values) {
+  const raw = evaluateFormula(attr.expression, values);
+  return formatFormulaResult(raw, attr.returnType, attr.decimals);
+}
+function validateFormulaExpression(expression) {
+  try {
+    formulaParser.parse(expression);
+    return { valid: true };
+  } catch (error) {
+    return {
+      valid: false,
+      error: error instanceof Error ? error.message : "Invalid expression"
+    };
+  }
+}
+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 flat = {};
+  for (const [relationName, values] of Object.entries(resolvedRelations)) {
+    for (const [key, value] of Object.entries(values)) {
+      flat[`${relationName}.${key}`] = value;
+    }
+  }
+  return flat;
+}
+async function evaluateFormulaWithRelations(expression, record, schema, resolver) {
+  const relationNames = extractRelationNames(expression);
+  if (relationNames.length === 0) {
+    return evaluateFormula(expression, record.values);
+  }
+  const resolvedRelations = await resolver.resolveRelationValues(record, schema, relationNames);
+  const flattenedRelations = flattenRelationsForEval(resolvedRelations);
+  const allValues = {
+    ...record.values,
+    ...flattenedRelations
+  };
+  return evaluateFormula(expression, allValues);
+}
+async function evaluateFormulaAttributeWithRelations(attr, record, schema, resolver) {
+  const raw = await evaluateFormulaWithRelations(attr.expression, record, schema, resolver);
+  return formatFormulaResult(raw, attr.returnType, attr.decimals);
+}
+
+// src/runtime/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(".");
+}
+
+// src/runtime/formula/path-traversal.ts
+async function traversePath(record, path, startSchemaName, adapter, getSchema, options) {
+  const maxDepth = options?.maxDepth ?? 5;
+  const startSchema = await getSchema(startSchemaName);
+  if (!startSchema) {
+    return { values: [], recordCounts: [0] };
+  }
+  const segments = await parsePath(path, startSchema, getSchema, maxDepth);
+  if (segments.length > maxDepth) {
+    throw new MaxDepthExceededError(path, maxDepth);
+  }
+  return await executeTraversal([record], segments, adapter, 0);
+}
+async function executeTraversal(records, segments, adapter, depth) {
+  const recordCounts = [records.length];
+  if (depth >= segments.length || records.length === 0) {
+    return { values: [], recordCounts };
+  }
+  const segment = segments[depth];
+  const isLastSegment = depth === segments.length - 1;
+  if (segment.type === "attribute") {
+    const values = records.map((r) => r.values[segment.name]).filter((v) => v !== void 0);
+    return { values, recordCounts };
+  }
+  const relatedIds = collectRelatedIds(records, segment.name);
+  if (relatedIds.length === 0) {
+    return { values: [], recordCounts };
+  }
+  const relatedRecords = await adapter.objectRecords.findByIds(relatedIds);
+  recordCounts.push(relatedRecords.length);
+  if (isLastSegment) {
+    return { values: relatedIds, recordCounts };
+  }
+  const nestedResult = await executeTraversal(relatedRecords, segments, adapter, depth + 1);
+  return {
+    values: nestedResult.values,
+    recordCounts: [...recordCounts, ...nestedResult.recordCounts.slice(1)]
+  };
+}
+function collectRelatedIds(records, relationName) {
+  const ids = [];
+  for (const record of records) {
+    const value = record.values[relationName];
+    if (typeof value === "string" && value.length > 0) {
+      ids.push(value);
+    } else if (Array.isArray(value)) {
+      for (const id of value) {
+        if (typeof id === "string" && id.length > 0) {
+          ids.push(id);
+        }
+      }
+    }
+  }
+  return [...new Set(ids)];
+}
+async function resolveSingleValue(record, path, startSchemaName, adapter, getSchema) {
+  const result = await traversePath(record, path, startSchemaName, adapter, getSchema);
+  return result.values[0] ?? null;
+}
+async function resolveMultiplePaths(record, paths, startSchemaName, adapter, getSchema) {
+  const results = /* @__PURE__ */ new Map();
+  await Promise.all(
+    paths.map(async (path) => {
+      const result = await traversePath(record, path, startSchemaName, adapter, getSchema);
+      results.set(path, result.values);
+    })
+  );
+  return results;
+}
+
 // src/runtime/hooks/hook.registry.ts
 var NoopHookRegistry = class {
   async execute() {
@@ -997,6 +1401,26 @@ function createMockObjectRecordsRepository(stores) {
         }
       }
       return Promise.resolve(updated);
+    },
+    findByRelation(objectName, relationAttributeName, targetRecordId) {
+      const obj = Array.from(stores.objects.values()).find((o) => o.name === objectName);
+      if (!obj) return Promise.resolve([]);
+      const results = [];
+      for (const record of stores.objectRecords.values()) {
+        if (record.objectId !== obj.id) continue;
+        const value = record.values[relationAttributeName];
+        let matches = false;
+        if (typeof value === "string" && value === targetRecordId) {
+          matches = true;
+        } else if (Array.isArray(value) && value.includes(targetRecordId)) {
+          matches = true;
+        }
+        if (matches) {
+          const { tenantId: _, ...publicRecord } = record;
+          results.push(publicRecord);
+        }
+      }
+      return Promise.resolve(results);
     }
   };
 }
@@ -2902,6 +3326,32 @@ var ratingConfigSchema = baseConfigSchema.extend({
   max: import_zod4.z.number().int().min(1).optional(),
   iconType: import_zod4.z.enum(["star", "heart", "thumbs", "number"]).optional()
 });
+var formulaConfigSchema = baseConfigSchema.extend({
+  expression: import_zod4.z.string().min(1),
+  returnType: import_zod4.z.enum(["text", "number", "boolean", "date"]),
+  decimals: import_zod4.z.number().int().min(0).max(10).optional(),
+  allowRelations: import_zod4.z.boolean().optional()
+});
+var rollupConfigSchema = baseConfigSchema.extend({
+  relationAttribute: import_zod4.z.string().min(1).optional(),
+  relationPath: import_zod4.z.string().optional(),
+  targetAttribute: import_zod4.z.string().min(1),
+  function: import_zod4.z.enum([
+    "sum",
+    "count",
+    "avg",
+    "min",
+    "max",
+    "countValues",
+    "countEmpty",
+    "percentEmpty",
+    "percentFilled",
+    "collect"
+  ]),
+  decimals: import_zod4.z.number().int().min(0).max(10).optional(),
+  showAsOriginal: import_zod4.z.boolean().optional(),
+  targetAttributeType: import_zod4.z.string().optional()
+});
 var attributeConfigSchemas = {
   text: textConfigSchema,
   textarea: textareaConfigSchema,
@@ -2918,7 +3368,9 @@ var attributeConfigSchemas = {
   file: fileConfigSchema,
   user: userConfigSchema,
   relation: relationConfigSchema,
-  rating: ratingConfigSchema
+  rating: ratingConfigSchema,
+  formula: formulaConfigSchema,
+  rollup: rollupConfigSchema
 };
 function getAttributeConfigSchema(type) {
   return attributeConfigSchemas[type];
@@ -3075,6 +3527,12 @@ function createRatingValidator(attr) {
   }
   return schema;
 }
+function createFormulaValidator(_attr) {
+  return import_zod4.z.unknown();
+}
+function createRollupValidator(_attr) {
+  return import_zod4.z.unknown();
+}
 function createAttributeValidator(attr) {
   switch (attr.type) {
     case "text":
@@ -3107,6 +3565,10 @@ function createAttributeValidator(attr) {
       return createRelationValidator(attr);
     case "rating":
       return createRatingValidator(attr);
+    case "formula":
+      return createFormulaValidator(attr);
+    case "rollup":
+      return createRollupValidator(attr);
     default:
       return import_zod4.z.unknown();
   }
@@ -4734,6 +5196,263 @@ var RelationService = class {
   }
 };
 
+// src/runtime/services/rollup.service.ts
+var RollupService = class {
+  constructor(adapter) {
+    this.adapter = adapter;
+  }
+  /**
+   * Calculate a rollup value for a record
+   *
+   * @param recordId - ID of the parent record
+   * @param rollupAttr - Rollup attribute definition
+   * @param schema - Schema of the parent object
+   * @returns Computed rollup value
+   *
+   * @example
+   * ```typescript
+   * // Sum all order amounts for a company
+   * const totalOrders = await rollupService.calculate(
+   *   "company-123",
+   *   {
+   *     type: "rollup",
+   *     name: "totalOrders",
+   *     relationAttribute: "orders",
+   *     targetAttribute: "amount",
+   *     function: "sum",
+   *     ...
+   *   },
+   *   companySchema
+   * );
+   * ```
+   */
+  async calculate(recordId, rollupAttr, schema) {
+    const relationAttr = schema.attributes.find(
+      (a) => a.type === "relation" && a.name === rollupAttr.relationAttribute
+    );
+    if (relationAttr) {
+      return this.calculateForward(recordId, rollupAttr);
+    }
+    return this.calculateReverse(recordId, rollupAttr, schema);
+  }
+  /**
+   * Forward pattern: this record has a relation attribute pointing to other records
+   * Example: entreprise222 has relation "entreprises" → companies, rollup collects from companies
+   */
+  async calculateForward(recordId, rollupAttr) {
+    const record = await this.adapter.objectRecords.findById(recordId);
+    if (!record) {
+      return { value: null, recordCount: 0 };
+    }
+    const relationValue = record.values[rollupAttr.relationAttribute];
+    let relatedIds = [];
+    if (typeof relationValue === "string" && relationValue.length > 0) {
+      relatedIds = [relationValue];
+    } else if (Array.isArray(relationValue)) {
+      relatedIds = relationValue.filter((id) => typeof id === "string" && id.length > 0);
+    }
+    if (relatedIds.length === 0) {
+      return { value: this.getEmptyValue(rollupAttr.function), recordCount: 0 };
+    }
+    const relatedRecords = await this.adapter.objectRecords.findByIds(relatedIds);
+    if (relatedRecords.length === 0) {
+      return { value: this.getEmptyValue(rollupAttr.function), recordCount: 0 };
+    }
+    return this.aggregateValues(relatedRecords, rollupAttr);
+  }
+  /**
+   * Reverse pattern: other records have a relation pointing to this record
+   * Example: Company has rollup on "orders", Order has relation "company" → companies
+   */
+  async calculateReverse(recordId, rollupAttr, schema) {
+    const record = await this.adapter.objectRecords.findById(recordId);
+    if (!record) {
+      return { value: null, recordCount: 0 };
+    }
+    const parentObject = await this.adapter.objects.findById(record.objectId);
+    if (!parentObject) {
+      return { value: null, recordCount: 0 };
+    }
+    const tenantId = parentObject.tenantId;
+    const sourceObjectName = rollupAttr.relationAttribute;
+    const sourceObject = await this.adapter.objects.findByName(tenantId, sourceObjectName);
+    if (!sourceObject) {
+      return { value: null, recordCount: 0 };
+    }
+    const sourceAttributes = await this.adapter.attributes.findByObjectId(sourceObject.id);
+    const reverseRelationAttr = sourceAttributes.find((attr) => {
+      if (attr.type !== "relation") return false;
+      const relationConfig = attr.config;
+      return relationConfig?.targets?.some((t) => t.object === schema.name);
+    });
+    if (!reverseRelationAttr) {
+      return { value: null, recordCount: 0 };
+    }
+    const relatedRecords = await this.adapter.objectRecords.findByRelation(
+      tenantId,
+      sourceObject.id,
+      reverseRelationAttr.name,
+      recordId
+    );
+    if (relatedRecords.length === 0) {
+      return { value: this.getEmptyValue(rollupAttr.function), recordCount: 0 };
+    }
+    return this.aggregateValues(relatedRecords, rollupAttr);
+  }
+  /**
+   * Extract and aggregate values from related records
+   */
+  aggregateValues(relatedRecords, rollupAttr) {
+    const values = relatedRecords.map((r) => r.values[rollupAttr.targetAttribute]).filter((v) => v !== void 0 && v !== null);
+    const aggregated = this.aggregate(values, rollupAttr.function);
+    const result = typeof aggregated === "number" && rollupAttr.decimals !== void 0 ? Number(aggregated.toFixed(rollupAttr.decimals)) : aggregated;
+    return { value: result, recordCount: relatedRecords.length };
+  }
+  /**
+   * Calculate rollup values for multiple records (batched)
+   *
+   * More efficient than calling calculate() for each record individually.
+   */
+  async calculateForMany(recordIds, rollupAttr, schema) {
+    const results = /* @__PURE__ */ new Map();
+    for (const id of recordIds) {
+      results.set(id, { value: this.getEmptyValue(rollupAttr.function), recordCount: 0 });
+    }
+    await Promise.all(
+      recordIds.map(async (id) => {
+        const result = await this.calculate(id, rollupAttr, schema);
+        results.set(id, result);
+      })
+    );
+    return results;
+  }
+  /**
+   * Apply aggregation function to a set of values
+   */
+  aggregate(values, fn) {
+    switch (fn) {
+      case "sum":
+        return this.sumNumbers(values);
+      case "avg":
+        return this.averageNumbers(values);
+      case "min":
+        return this.minNumbers(values);
+      case "max":
+        return this.maxNumbers(values);
+      case "count":
+        return values.length;
+      case "countValues":
+        return values.filter((v) => v != null && v !== "").length;
+      case "countEmpty":
+        return values.filter((v) => v == null || v === "").length;
+      case "percentFilled": {
+        if (values.length === 0) return 0;
+        const filled = values.filter((v) => v != null && v !== "").length;
+        return filled / values.length * 100;
+      }
+      case "percentEmpty": {
+        if (values.length === 0) return 0;
+        const empty = values.filter((v) => v == null || v === "").length;
+        return empty / values.length * 100;
+      }
+      case "collect":
+        return values;
+    }
+  }
+  /**
+   * Get the default empty value for a rollup function
+   */
+  getEmptyValue(fn) {
+    switch (fn) {
+      case "sum":
+      case "count":
+      case "countValues":
+      case "countEmpty":
+      case "percentEmpty":
+      case "percentFilled":
+        return 0;
+      case "avg":
+      case "min":
+      case "max":
+        return null;
+      case "collect":
+        return [];
+    }
+  }
+  /**
+   * Sum numeric values
+   */
+  sumNumbers(values) {
+    return values.filter((v) => typeof v === "number" && !Number.isNaN(v)).reduce((sum, n) => sum + n, 0);
+  }
+  /**
+   * Average numeric values
+   */
+  averageNumbers(values) {
+    const nums = values.filter((v) => typeof v === "number" && !Number.isNaN(v));
+    if (nums.length === 0) return null;
+    return nums.reduce((sum, n) => sum + n, 0) / nums.length;
+  }
+  /**
+   * Minimum numeric value
+   */
+  minNumbers(values) {
+    const nums = values.filter((v) => typeof v === "number" && !Number.isNaN(v));
+    if (nums.length === 0) return null;
+    return Math.min(...nums);
+  }
+  /**
+   * Maximum numeric value
+   */
+  maxNumbers(values) {
+    const nums = values.filter((v) => typeof v === "number" && !Number.isNaN(v));
+    if (nums.length === 0) return null;
+    return Math.max(...nums);
+  }
+  /**
+   * Recalculate all rollup attributes for a record and update it
+   *
+   * Called after related records change to keep rollups up-to-date.
+   */
+  async recalculateAndUpdate(record, schema) {
+    const rollupAttrs = schema.attributes.filter((a) => a.type === "rollup");
+    if (rollupAttrs.length === 0) {
+      return record;
+    }
+    const updates = {};
+    for (const attr of rollupAttrs) {
+      const result = await this.calculate(record.id, attr, schema);
+      updates[attr.name] = result.value;
+    }
+    return await this.adapter.objectRecords.update(record.id, updates);
+  }
+  /**
+   * Find parent records that need rollup recalculation when a child record changes
+   *
+   * Used by hooks to determine which parent records to recalculate after
+   * a child record is created, updated, or deleted.
+   *
+   * @param changedRecord - The record that was modified
+   * @param changedSchema - Schema of the changed record's object
+   * @returns Array of parent record IDs that need recalculation
+   */
+  async findAffectedParentRecords(changedRecord, changedSchema) {
+    const affectedIds = [];
+    const relationAttrs = changedSchema.attributes.filter(
+      (a) => a.type === "relation"
+    );
+    for (const attr of relationAttrs) {
+      const relatedId = changedRecord.values[attr.name];
+      if (typeof relatedId === "string" && relatedId.length > 0) {
+        affectedIds.push(relatedId);
+      } else if (Array.isArray(relatedId)) {
+        affectedIds.push(...relatedId.filter((id) => typeof id === "string"));
+      }
+    }
+    return [...new Set(affectedIds)];
+  }
+};
+
 // src/runtime/services/user.service.ts
 var UserService = class {
   constructor(adapter, tenantId) {
@@ -4859,6 +5578,7 @@ var RecordService = class {
     this.schemaService = new ObjectSchemaService(adapter, registry);
     this.relationService = new RelationService(adapter, registry);
     this.userService = new UserService(adapter, tenantId);
+    this.rollupService = new RollupService(adapter);
     this.hookRegistry = options?.hookRegistry ?? new NoopHookRegistry();
     this.permissionService = options?.permissionService;
     this.auditService = options?.auditService ?? (adapter.audit ? new AuditService(adapter, tenantId) : void 0);
@@ -5020,6 +5740,7 @@ var RecordService = class {
       };
       await this.hookRegistry.execute("afterCreate", schema.name, afterCtx);
     }
+    await this.recalculateParentRollups(record, schema);
     if (this.auditService && this.userId) {
       await this.auditService.logRecordAction({
         action: "record.created",
@@ -5046,13 +5767,17 @@ var RecordService = class {
     if (!record) {
       return null;
     }
+    const schema = await this.schemaService.getObjectSchema(record.objectId);
+    let enrichedRecord = record;
+    if (!options?.skipFormulas) {
+      enrichedRecord = this.enrichWithFormulas(record, schema);
+    }
     if (options?.includeSchema) {
-      const schema = await this.schemaService.getObjectSchema(record.objectId);
-      const recordWithSchema = record;
+      const recordWithSchema = enrichedRecord;
       recordWithSchema.schema = schema;
       return recordWithSchema;
     }
-    return record;
+    return enrichedRecord;
   }
   /**
    * Get a record by ID or throw if not found
@@ -5131,6 +5856,7 @@ var RecordService = class {
       };
       await this.hookRegistry.execute("afterUpdate", schema.name, afterCtx);
     }
+    await this.recalculateParentRollups(updated, schema);
     if (this.auditService && this.userId && changedAttributes.length > 0) {
       const changes = changedAttributes.map((attr) => ({
         field: attr,
@@ -5258,6 +5984,7 @@ var RecordService = class {
     if (!options?.skipHooks) {
       await this.hookRegistry.execute("afterDelete", schema.name, hookCtx);
     }
+    await this.recalculateParentRollups(record, schema);
     if (this.auditService && this.userId) {
       await this.auditService.logRecordAction({
         action: "record.deleted",
@@ -5347,6 +6074,79 @@ var RecordService = class {
       timestamp: /* @__PURE__ */ new Date()
     };
   }
+  /**
+   * Enrich a record with computed formula values
+   *
+   * Formula attributes are calculated at read-time from the record's values.
+   * This method adds the computed values to the record's values object.
+   *
+   * @param record - The record to enrich
+   * @param schema - The object schema containing attribute definitions
+   * @returns Record with formula values computed
+   * @internal
+   */
+  enrichWithFormulas(record, schema) {
+    const formulaAttrs = schema.attributes.filter(
+      (a) => a.type === "formula"
+    );
+    if (formulaAttrs.length === 0) {
+      return record;
+    }
+    const enrichedValues = { ...record.values };
+    for (const attr of formulaAttrs) {
+      enrichedValues[attr.name] = evaluateFormulaAttribute(attr, record.values);
+    }
+    return {
+      ...record,
+      values: enrichedValues
+    };
+  }
+  /**
+   * Enrich multiple records with computed formula values
+   * @internal
+   */
+  enrichRecordsWithFormulas(records, schema) {
+    const formulaAttrs = schema.attributes.filter(
+      (a) => a.type === "formula"
+    );
+    if (formulaAttrs.length === 0) {
+      return records;
+    }
+    return records.map((record) => this.enrichWithFormulas(record, schema));
+  }
+  /**
+   * Recalculate rollups after a record changes
+   *
+   * This handles two cases:
+   * 1. The record itself has rollups (e.g., aggregating from related records it points to)
+   * 2. Parent records have rollups that aggregate from this record
+   *
+   * @param record - The record that was modified
+   * @param schema - Schema of the record's object
+   * @internal
+   */
+  async recalculateParentRollups(record, schema) {
+    const ownRollupAttrs = schema.attributes.filter(
+      (a) => a.type === "rollup"
+    );
+    if (ownRollupAttrs.length > 0) {
+      await this.rollupService.recalculateAndUpdate(record, schema);
+    }
+    const affectedParentIds = await this.rollupService.findAffectedParentRecords(record, schema);
+    if (affectedParentIds.length === 0) {
+      return;
+    }
+    const parentRecords = await this.adapter.objectRecords.findByIds(affectedParentIds);
+    for (const parentRecord of parentRecords) {
+      const parentSchema = await this.schemaService.getObjectSchema(parentRecord.objectId);
+      const rollupAttrs = parentSchema.attributes.filter(
+        (a) => a.type === "rollup"
+      );
+      if (rollupAttrs.length > 0) {
+        await this.rollupService.recalculateAndUpdate(parentRecord, parentSchema);
+      }
+    }
+  }
   /**
    * Permanently delete a record (hard delete)
    *
@@ -5375,11 +6175,18 @@ var RecordService = class {
    * @returns Records and total count
    */
   async listRecords(objectId, options) {
+    const schema = await this.schemaService.getObjectSchema(objectId);
     if (this.permissionService && this.userId) {
-      const schema = await this.schemaService.getObjectSchema(objectId);
       await this.checkPermission(schema.name, "read");
     }
-    return await this.adapter.objectRecords.list(this.tenantId, objectId, options);
+    const result = await this.adapter.objectRecords.list(this.tenantId, objectId, options);
+    if (!options?.skipFormulas) {
+      return {
+        records: this.enrichRecordsWithFormulas(result.records, schema),
+        total: result.total
+      };
+    }
+    return result;
   }
   /**
    * Search records using full-text search
@@ -5390,11 +6197,18 @@ var RecordService = class {
    * @returns Matching records and total count
    */
   async searchRecords(objectId, query, options) {
+    const schema = await this.schemaService.getObjectSchema(objectId);
     if (this.permissionService && this.userId) {
-      const schema = await this.schemaService.getObjectSchema(objectId);
       await this.checkPermission(schema.name, "read");
     }
-    return await this.adapter.objectRecords.search(this.tenantId, objectId, query, options);
+    const result = await this.adapter.objectRecords.search(this.tenantId, objectId, query, options);
+    if (!options?.skipFormulas) {
+      return {
+        records: this.enrichRecordsWithFormulas(result.records, schema),
+        total: result.total
+      };
+    }
+    return result;
   }
   /**
    * Validate data against object schema without saving
@@ -5439,6 +6253,231 @@ var RecordService = class {
   }
 };
 
+// src/runtime/services/relation-resolver.service.ts
+var RelationResolverService = class {
+  constructor(adapter) {
+    this.adapter = adapter;
+  }
+  /**
+   * Resolve values from related records for formula evaluation
+   *
+   * Phase 2: Supports 1 level of relation traversal only
+   *
+   * @param record - The source record
+   * @param schema - Schema of the source object
+   * @param relationNames - Names of relation attributes to resolve
+   * @returns Map of relation name to related record's values
+   *
+   * @example
+   * ```typescript
+   * // For an order with company relation
+   * const resolved = await resolver.resolveRelationValues(
+   *   orderRecord,
+   *   orderSchema,
+   *   ["company"]
+   * );
+   * // → { company: { id: "...", name: "Acme Corp", ... } }
+   * ```
+   */
+  async resolveRelationValues(record, schema, relationNames) {
+    const result = {};
+    const relationAttrs = schema.attributes.filter(
+      (a) => a.type === "relation" && relationNames.includes(a.name)
+    );
+    if (relationAttrs.length === 0) {
+      return result;
+    }
+    const idsToFetch = [];
+    const attrIdMap = /* @__PURE__ */ new Map();
+    for (const attr of relationAttrs) {
+      const relatedId = this.extractSingleId(record.values[attr.name]);
+      if (relatedId) {
+        idsToFetch.push(relatedId);
+        attrIdMap.set(relatedId, attr.name);
+      }
+    }
+    if (idsToFetch.length === 0) {
+      return result;
+    }
+    const relatedRecords = await this.adapter.objectRecords.findByIds(idsToFetch);
+    for (const relatedRecord of relatedRecords) {
+      const attrName = attrIdMap.get(relatedRecord.id);
+      if (attrName) {
+        result[attrName] = relatedRecord.values;
+      }
+    }
+    return result;
+  }
+  /**
+   * Resolve relation values for multiple records (batched)
+   *
+   * Optimized for list operations - fetches all related records in one batch
+   *
+   * @param records - Source records
+   * @param schema - Schema of the source object
+   * @param relationNames - Names of relation attributes to resolve
+   * @returns Map of record ID to resolved relations
+   */
+  async resolveRelationValuesForMany(records, schema, relationNames) {
+    const resultMap = /* @__PURE__ */ new Map();
+    for (const record of records) {
+      resultMap.set(record.id, {});
+    }
+    const relationAttrs = schema.attributes.filter(
+      (a) => a.type === "relation" && relationNames.includes(a.name)
+    );
+    if (relationAttrs.length === 0) {
+      return resultMap;
+    }
+    const allIdsToFetch = /* @__PURE__ */ new Set();
+    const recordRelationMap = /* @__PURE__ */ new Map();
+    for (const record of records) {
+      const idToAttr = /* @__PURE__ */ new Map();
+      for (const attr of relationAttrs) {
+        const relatedId = this.extractSingleId(record.values[attr.name]);
+        if (relatedId) {
+          allIdsToFetch.add(relatedId);
+          idToAttr.set(relatedId, attr.name);
+        }
+      }
+      recordRelationMap.set(record.id, idToAttr);
+    }
+    if (allIdsToFetch.size === 0) {
+      return resultMap;
+    }
+    const relatedRecords = await this.adapter.objectRecords.findByIds([...allIdsToFetch]);
+    const relatedRecordMap = new Map(relatedRecords.map((r) => [r.id, r]));
+    for (const record of records) {
+      const result = resultMap.get(record.id);
+      const idToAttr = recordRelationMap.get(record.id);
+      for (const [relatedId, attrName] of idToAttr) {
+        const relatedRecord = relatedRecordMap.get(relatedId);
+        if (relatedRecord) {
+          result[attrName] = relatedRecord.values;
+        }
+      }
+    }
+    return resultMap;
+  }
+  /**
+   * Flatten resolved relations for formula evaluation
+   *
+   * Converts nested structure to dot-notation keys:
+   * { company: { name: "Acme" } } → { "company.name": "Acme" }
+   *
+   * @param resolved - Resolved relations from resolveRelationValues
+   * @returns Flattened values suitable for formula evaluation
+   */
+  flattenResolvedRelations(resolved) {
+    const flat = {};
+    for (const [relationName, values] of Object.entries(resolved)) {
+      for (const [key, value] of Object.entries(values)) {
+        flat[`${relationName}.${key}`] = value;
+      }
+    }
+    return flat;
+  }
+  /**
+   * Extract a single relation ID from a value
+   * Handles both single (string) and multi (array) relations
+   * @internal
+   */
+  extractSingleId(value) {
+    if (typeof value === "string" && value.length > 0) {
+      return value;
+    }
+    if (Array.isArray(value) && value.length > 0 && typeof value[0] === "string") {
+      return value[0];
+    }
+    return null;
+  }
+};
+
+// src/runtime/services/rollup-scheduler.ts
+var RollupScheduler = class {
+  constructor(adapter, getSchemaById, options) {
+    this.adapter = adapter;
+    this.getSchemaById = getSchemaById;
+    this.pending = /* @__PURE__ */ new Map();
+    this.rollupService = new RollupService(adapter);
+    this.debounceMs = options?.debounceMs ?? 100;
+    this.maxPending = options?.maxPending ?? 100;
+  }
+  /**
+   * Schedule a rollup recalculation for a parent record
+   *
+   * If the same record is already pending, the timer is reset.
+   * If too many recalculations are pending, triggers an immediate flush.
+   *
+   * @param parentId - ID of the parent record to recalculate
+   * @param parentObjectId - Object ID of the parent
+   * @param tenantId - Tenant ID
+   */
+  scheduleRecalculation(parentId, parentObjectId, tenantId) {
+    const key = `${parentId}:${parentObjectId}`;
+    const existing = this.pending.get(key);
+    if (existing) {
+      clearTimeout(existing.timeout);
+    }
+    const timeout = setTimeout(async () => {
+      await this.executeRecalculation(parentId, parentObjectId);
+      this.pending.delete(key);
+    }, this.debounceMs);
+    this.pending.set(key, { parentId, parentObjectId, tenantId, timeout });
+    if (this.pending.size >= this.maxPending) {
+      this.flush();
+    }
+  }
+  /**
+   * Execute all pending recalculations immediately
+   */
+  async flush() {
+    const entries = Array.from(this.pending.entries());
+    for (const [, entry] of entries) {
+      clearTimeout(entry.timeout);
+    }
+    this.pending.clear();
+    const tenantMap = /* @__PURE__ */ new Map();
+    for (const [, entry] of entries) {
+      tenantMap.set(entry.parentId, entry.tenantId);
+    }
+    const allIds = entries.map(([, entry]) => entry.parentId);
+    const records = await this.adapter.objectRecords.findByIds(allIds);
+    for (const record of records) {
+      const schema = await this.getSchemaById(record.objectId);
+      const tenantId = tenantMap.get(record.id);
+      if (schema && tenantId) {
+        await this.rollupService.recalculateAndUpdate(record, schema);
+      }
+    }
+  }
+  /**
+   * Execute a single recalculation
+   */
+  async executeRecalculation(parentId, parentObjectId) {
+    const record = await this.adapter.objectRecords.findById(parentId);
+    if (!record) return;
+    const schema = await this.getSchemaById(parentObjectId);
+    if (!schema) return;
+    await this.rollupService.recalculateAndUpdate(record, schema);
+  }
+  /**
+   * Get number of pending recalculations
+   */
+  get pendingCount() {
+    return this.pending.size;
+  }
+  /**
+   * Clear all pending recalculations without executing them
+   */
+  clear() {
+    for (const [, entry] of this.pending) {
+      clearTimeout(entry.timeout);
+    }
+    this.pending.clear();
+  }
+};
+
 // src/runtime/services/user-profile.service.ts
 var UserProfileService = class {
   constructor(adapter, tenantId, options) {
@@ -6136,7 +7175,8 @@ async function syncAttributes(adapter, nativeObject, dbObject, existingObject, r
       hidden: attr.hidden,
       archived: attr.archived,
       deprecated: attr.deprecated,
-      defaultValue: attr.defaultValue,
+      // Formula and rollup attributes don't have defaultValue
+      defaultValue: "defaultValue" in attr ? attr.defaultValue : void 0,
       config: extractAttributeConfig(attr)
     });
     if (existingAttr) {
@@ -6215,26 +7255,52 @@ var NoopGeocodingAdapter = class {
   FlowService,
   GeocodingService,
   GlobalSearchService,
+  InvalidPathError,
+  MaxDepthExceededError,
   NoopGeocodingAdapter,
   NoopHookRegistry,
   ObjectSchemaService,
   PermissionService,
   RecordService,
+  RelationResolverService,
   RelationService,
+  RollupScheduler,
+  RollupService,
   UserProfileService,
   UserService,
   ViewService,
   buildAuditChanges,
   createMockAdapter,
   enrichValuesWithSelectLabels,
+  evaluateFormula,
+  evaluateFormulaAttribute,
+  evaluateFormulaAttributeWithRelations,
+  evaluateFormulaWithRelations,
+  evaluateFormulaWithResult,
   extractAttributeNames,
+  extractFormulaVariables,
+  extractRelationNames,
+  extractRelationReferences,
+  flattenRelationsForEval,
+  formatFormulaResult,
+  getPathDepth,
+  getRelationPath,
   getSyncPreview,
+  getTargetAttributeName,
   getViewSyncPreview,
+  hasRelationReferences,
   isLabelExpression,
+  parsePath,
+  pathHasManyCardinality,
   renderLabelExpression,
+  resolveMultiplePaths,
+  resolveSingleValue,
   syncAll,
   syncNativeObjects,
   syncNativeViews,
+  traversePath,
+  validateFormulaExpression,
+  validatePath,
   verifyNativeObjectsSync,
   verifyNativeViewsSync
 });