@stndrds/schema 0.1.0-alpha.17 → 0.1.0-alpha.19

package/dist/runtime.js

@@ -59,21 +59,25 @@ var init_default_roles = __esm({
       /** Tenant settings and configuration */
       SETTINGS: "settings",
       /** Audit logs and activity trail */
-      AUDIT: "audit"
+      AUDIT: "audit",
+      /** File uploads and storage management */
+      FILES: "files"
     };
     ALL_SYSTEM_RESOURCES = [
       SYSTEM_RESOURCES.USERS,
       SYSTEM_RESOURCES.SCHEMA,
       SYSTEM_RESOURCES.ROLES,
       SYSTEM_RESOURCES.SETTINGS,
-      SYSTEM_RESOURCES.AUDIT
+      SYSTEM_RESOURCES.AUDIT,
+      SYSTEM_RESOURCES.FILES
     ];
     SYSTEM_RESOURCE_LABELS = {
       users: "Users",
       schema: "Schema",
       roles: "Roles & Permissions",
       settings: "Settings",
-      audit: "Audit Logs"
+      audit: "Audit Logs",
+      files: "Files"
     };
     DEFAULT_ROLES = {
       /** Full platform access - can manage everything */
@@ -124,36 +128,697 @@ __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,
+  createRollupHooks: () => createRollupHooks,
   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,
+  registerAllRollupHooks: () => registerAllRollupHooks,
   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() {
   }
 };
 
+// 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, tenantId) {
+    const relationAttr = schema.attributes.find(
+      (a) => a.type === "relation" && a.name === rollupAttr.relationAttribute
+    );
+    if (!relationAttr) {
+      return { value: null, recordCount: 0 };
+    }
+    const targetObjectName = relationAttr.targets[0]?.object;
+    if (!targetObjectName) {
+      return { value: null, recordCount: 0 };
+    }
+    const targetObject = await this.adapter.objects.findByName(tenantId, targetObjectName);
+    if (!targetObject) {
+      return { value: null, recordCount: 0 };
+    }
+    const relatedRecords = await this.adapter.objectRecords.findByRelation(
+      tenantId,
+      targetObject.id,
+      rollupAttr.relationAttribute,
+      recordId
+    );
+    if (relatedRecords.length === 0) {
+      return { value: this.getEmptyValue(rollupAttr.function), recordCount: 0 };
+    }
+    const values = relatedRecords.map((r) => r.values[rollupAttr.targetAttribute]).filter((v) => v !== void 0);
+    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, tenantId) {
+    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, tenantId);
+        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;
+      }
+    }
+  }
+  /**
+   * 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;
+    }
+  }
+  /**
+   * 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, tenantId) {
+    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, tenantId);
+      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/hooks/rollup.hooks.ts
+function createRollupHooks(objectName, config) {
+  const rollupService = new RollupService(config.adapter);
+  async function recalculateParentRollups(ctx) {
+    const schema = await config.getSchemaById(ctx.objectId);
+    if (!schema) return;
+    const affectedParentIds = await rollupService.findAffectedParentRecords(ctx.record, schema);
+    if (affectedParentIds.length === 0) return;
+    const parentRecords = await config.adapter.objectRecords.findByIds(affectedParentIds);
+    for (const parentRecord of parentRecords) {
+      const parentSchema = await config.getSchemaById(parentRecord.objectId);
+      if (!parentSchema) continue;
+      const hasRollups = parentSchema.attributes.some(
+        (a) => a.type === "rollup"
+      );
+      if (hasRollups) {
+        await rollupService.recalculateAndUpdate(parentRecord, parentSchema, config.tenantId);
+      }
+    }
+  }
+  return [
+    {
+      type: "afterCreate",
+      objectName,
+      handler: recalculateParentRollups,
+      priority: 100
+      // Run after other hooks
+    },
+    {
+      type: "afterUpdate",
+      objectName,
+      handler: recalculateParentRollups,
+      priority: 100
+    },
+    {
+      type: "afterDelete",
+      objectName,
+      handler: recalculateParentRollups,
+      priority: 100
+    }
+  ];
+}
+function registerAllRollupHooks(hookRegistry, schemas, config) {
+  for (const schema of schemas) {
+    const hasRelations = schema.attributes.some((a) => a.type === "relation");
+    if (hasRelations && hookRegistry.register) {
+      const hooks = createRollupHooks(schema.name, config);
+      for (const hook of hooks) {
+        hookRegistry.register(hook);
+      }
+    }
+  }
+}
+
 // src/utils.ts
 function generateId() {
   if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
@@ -178,6 +843,13 @@ function formatCheckbox(value) {
 function formatNumber(value, attribute) {
   if (typeof value !== "number") return String(value);
   const decimals = attribute.decimals;
+  if (attribute.unit === "percentage") {
+    return value.toLocaleString(void 0, {
+      style: "percent",
+      minimumFractionDigits: decimals,
+      maximumFractionDigits: decimals
+    });
+  }
   return value.toLocaleString(void 0, {
     minimumFractionDigits: decimals,
     maximumFractionDigits: decimals
@@ -985,6 +1657,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);
     }
   };
 }
@@ -1404,6 +2096,24 @@ var AuditService = class {
     };
     await this.log(entry);
   }
+  /**
+   * Log a file action (upload, update, delete)
+   */
+  async logFileAction(params) {
+    const entry = {
+      tenantId: this.tenantId,
+      actorId: params.actorId,
+      actorEmail: params.actorEmail,
+      actorType: "user",
+      action: params.action,
+      resourceType: "file",
+      resourceId: params.fileId,
+      resourceLabel: params.fileName,
+      changes: params.changes ? this.redactSensitiveFields(params.changes) : void 0,
+      metadata: params.metadata
+    };
+    await this.log(entry);
+  }
   /**
    * Log a system action (no actor)
    */
@@ -1553,21 +2263,105 @@ var AuditService = class {
 
 // src/runtime/services/file.service.ts
 var FileService = class {
-  constructor(adapter, tenantId) {
+  constructor(adapter, tenantId, options) {
     this.adapter = adapter;
     this.tenantId = tenantId;
+    this.auditService = options?.auditService ?? (adapter.audit ? new AuditService(adapter, tenantId) : void 0);
+    this.userId = options?.userId;
+    this.userEmail = options?.userEmail;
   }
+  // ============================================================================
+  // UPLOAD (requires StorageAdapter)
+  // ============================================================================
   /**
-   * Create a new file record (after upload to storage)
+   * Upload a file to storage and create metadata record.
    *
-   * @param data - File metadata
+   * This method orchestrates:
+   * 1. Upload to storage (via StorageAdapter)
+   * 2. Create file metadata in database
+   * 3. Audit log the operation
+   *
+   * Requires `adapter.storage` to be configured.
+   *
+   * @param input - File content and metadata
    * @returns Created file record
+   * @throws Error if StorageAdapter is not configured
    *
    * @example
    * ```typescript
-   * const service = new FileService(adapter, "tenant-123");
+   * const file = await service.uploadFile({
+   *   content: fileBuffer,
+   *   fileName: "document.pdf",
+   *   mimeType: "application/pdf",
+   *   size: 12345,
+   *   uploadedBy: "user-123",
+   *   visibility: "private",
+   *   folderPath: "/documents",
+   *   tags: ["contract", "2025"],
+   * });
+   * ```
+   */
+  async uploadFile(input) {
+    if (!this.adapter.storage) {
+      throw new Error(
+        "StorageAdapter is not configured. Provide adapter.storage to use uploadFile()."
+      );
+    }
+    const uploadResult = await this.adapter.storage.upload({
+      content: input.content,
+      fileName: input.fileName,
+      mimeType: input.mimeType,
+      size: input.size,
+      tenantId: this.tenantId,
+      folderPath: input.folderPath
+    });
+    const file = await this.adapter.files.create({
+      tenantId: this.tenantId,
+      name: input.fileName,
+      originalName: input.fileName,
+      mimeType: input.mimeType,
+      size: input.size,
+      storageProvider: uploadResult.storageProvider,
+      storagePath: uploadResult.storagePath,
+      storageBucket: uploadResult.storageBucket,
+      url: uploadResult.url,
+      uploadedBy: input.uploadedBy,
+      folderPath: input.folderPath,
+      tags: input.tags,
+      visibility: input.visibility ?? "private",
+      allowedUsers: input.allowedUsers
+    });
+    if (this.auditService && this.userId) {
+      await this.auditService.logFileAction({
+        action: "file.uploaded",
+        actorId: this.userId,
+        actorEmail: this.userEmail,
+        fileId: file.id,
+        fileName: file.name,
+        metadata: {
+          mimeType: file.mimeType,
+          size: file.size,
+          visibility: file.visibility
+        }
+      });
+    }
+    return file;
+  }
+  // ============================================================================
+  // CREATE (metadata only, for external storage)
+  // ============================================================================
+  /**
+   * Create a new file record (after upload to storage).
    *
-   * // After uploading to S3
+   * Use this method when handling storage externally (e.g., with Multer + S3).
+   * For integrated upload, use `uploadFile()` instead.
+   *
+   * @param data - File metadata
+   * @returns Created file record
+   *
+   * @example
+   * ```typescript
+   * // After uploading to S3 with Multer
    * const file = await service.createFile({
    *   tenantId: "tenant-123",
    *   name: "contract-2025.pdf",
@@ -1589,8 +2383,26 @@ var FileService = class {
         `Tenant mismatch: service initialized with "${this.tenantId}" but data has "${data.tenantId}"`
       );
     }
-    return await this.adapter.files.create(data);
+    const file = await this.adapter.files.create(data);
+    if (this.auditService && this.userId) {
+      await this.auditService.logFileAction({
+        action: "file.uploaded",
+        actorId: this.userId,
+        actorEmail: this.userEmail,
+        fileId: file.id,
+        fileName: file.name,
+        metadata: {
+          mimeType: file.mimeType,
+          size: file.size,
+          visibility: file.visibility
+        }
+      });
+    }
+    return file;
   }
+  // ============================================================================
+  // READ
+  // ============================================================================
   /**
    * Get file by ID
    */
@@ -1611,6 +2423,9 @@ var FileService = class {
     }
     return file;
   }
+  // ============================================================================
+  // UPDATE
+  // ============================================================================
   /**
    * Update file metadata
    *
@@ -1619,18 +2434,44 @@ var FileService = class {
    * @returns Updated file
    */
   async updateFile(fileId, data) {
-    await this.getFileOrThrow(fileId);
-    return await this.adapter.files.update(fileId, data);
+    const existingFile = await this.getFileOrThrow(fileId);
+    const updatedFile = await this.adapter.files.update(fileId, data);
+    if (this.auditService && this.userId) {
+      const changes = [];
+      for (const key of Object.keys(data)) {
+        if (data[key] !== void 0 && data[key] !== existingFile[key]) {
+          changes.push({
+            field: key,
+            oldValue: existingFile[key],
+            newValue: data[key]
+          });
+        }
+      }
+      if (changes.length > 0) {
+        await this.auditService.logFileAction({
+          action: "file.updated",
+          actorId: this.userId,
+          actorEmail: this.userEmail,
+          fileId,
+          fileName: updatedFile.name,
+          changes
+        });
+      }
+    }
+    return updatedFile;
   }
+  // ============================================================================
+  // DELETE
+  // ============================================================================
   /**
-   * Delete file (soft delete)
+   * Delete file (soft delete by default)
    *
    * @param fileId - File UUID
    * @param options - Delete options
    */
   async deleteFile(fileId, options) {
+    const file = await this.getFileOrThrow(fileId);
     if (options?.checkOwnership && options.userId) {
-      const file = await this.getFileOrThrow(fileId);
       if (file.uploadedBy !== options.userId) {
         throw new Error("You can only delete files you uploaded");
       }
@@ -1640,7 +2481,84 @@ var FileService = class {
     } else {
       await this.adapter.files.delete(fileId);
     }
+    if (this.auditService && this.userId) {
+      await this.auditService.logFileAction({
+        action: "file.deleted",
+        actorId: this.userId,
+        actorEmail: this.userEmail,
+        fileId,
+        fileName: file.name
+      });
+    }
   }
+  /**
+   * Delete file from both storage and database.
+   *
+   * Requires `adapter.storage` to be configured.
+   *
+   * @param fileId - File UUID
+   * @param options - Delete options
+   * @throws Error if StorageAdapter is not configured
+   */
+  async deleteFileWithStorage(fileId, options) {
+    if (!this.adapter.storage) {
+      throw new Error(
+        "StorageAdapter is not configured. Provide adapter.storage to use deleteFileWithStorage()."
+      );
+    }
+    const file = await this.getFileOrThrow(fileId);
+    await this.adapter.storage.delete(file.storagePath);
+    if (options?.hard) {
+      await this.adapter.files.hardDelete(fileId);
+    } else {
+      await this.adapter.files.delete(fileId);
+    }
+    if (this.auditService && this.userId) {
+      await this.auditService.logFileAction({
+        action: "file.deleted",
+        actorId: this.userId,
+        actorEmail: this.userEmail,
+        fileId,
+        fileName: file.name,
+        metadata: { deletedFromStorage: true }
+      });
+    }
+  }
+  /**
+   * Delete multiple files
+   *
+   * @param fileIds - Array of file UUIDs
+   * @param options - Delete options
+   */
+  async bulkDelete(fileIds, options) {
+    for (const fileId of fileIds) {
+      const file = await this.getFile(fileId);
+      if (!file) {
+        continue;
+      }
+      if (options?.deleteFromStorage && this.adapter.storage) {
+        await this.adapter.storage.delete(file.storagePath);
+      }
+      if (options?.hard) {
+        await this.adapter.files.hardDelete(fileId);
+      } else {
+        await this.adapter.files.delete(fileId);
+      }
+      if (this.auditService && this.userId) {
+        await this.auditService.logFileAction({
+          action: "file.deleted",
+          actorId: this.userId,
+          actorEmail: this.userEmail,
+          fileId,
+          fileName: file.name,
+          metadata: { deletedFromStorage: options?.deleteFromStorage ?? false }
+        });
+      }
+    }
+  }
+  // ============================================================================
+  // LIST
+  // ============================================================================
   /**
    * List files for the tenant
    */
@@ -1654,10 +2572,78 @@ var FileService = class {
     return await this.adapter.files.findByFolder(this.tenantId, folderPath);
   }
   /**
-   * List files uploaded by a specific user
+   * List files uploaded by a specific user
+   */
+  async listFilesByUploader(uploadedBy) {
+    return await this.adapter.files.findByUploader(uploadedBy);
+  }
+  // ============================================================================
+  // SIGNED URL
+  // ============================================================================
+  /**
+   * Get a signed URL for private file access.
+   *
+   * Checks access permissions before generating URL.
+   * Requires `adapter.storage` to be configured.
+   *
+   * @param fileId - File UUID
+   * @param userId - User requesting access
+   * @param options - Signed URL options
+   * @returns Signed URL
+   * @throws Error if user doesn't have access or StorageAdapter is not configured
+   *
+   * @example
+   * ```typescript
+   * const url = await service.getSignedUrl("file-123", "user-456", {
+   *   expiresIn: 3600, // 1 hour
+   * });
+   * ```
+   */
+  async getSignedUrl(fileId, userId, options) {
+    const file = await this.getFileOrThrow(fileId);
+    const hasAccess = await this.checkAccess(fileId, userId);
+    if (!hasAccess) {
+      throw new Error("Access denied to this file");
+    }
+    if (file.visibility === "public") {
+      return file.url;
+    }
+    if (!this.adapter.storage) {
+      return file.url;
+    }
+    return await this.adapter.storage.getSignedUrl(file.storagePath, options);
+  }
+  // ============================================================================
+  // ACCESS CONTROL
+  // ============================================================================
+  /**
+   * Check if user has access to a file
+   *
+   * @param fileId - File UUID
+   * @param userId - User ID to check
+   * @returns true if user can access the file
+   */
+  async checkAccess(fileId, userId) {
+    const file = await this.getFile(fileId);
+    if (!file) {
+      return false;
+    }
+    if (file.visibility === "public") {
+      return true;
+    }
+    if (file.uploadedBy === userId) {
+      return true;
+    }
+    if (file.visibility === "restricted") {
+      return file.allowedUsers?.includes(userId) ?? false;
+    }
+    return false;
+  }
+  /**
+   * @deprecated Use checkAccess() instead
    */
-  async listFilesByUploader(uploadedBy) {
-    return await this.adapter.files.findByUploader(uploadedBy);
+  canAccess(fileId, userId) {
+    return this.checkAccess(fileId, userId);
   }
   /**
    * Change file visibility
@@ -1702,29 +2688,9 @@ var FileService = class {
       allowedUsers: newAllowed
     });
   }
-  /**
-   * Check if user has access to a file
-   *
-   * @param fileId - File UUID
-   * @param userId - User ID to check
-   * @returns true if user can access the file
-   */
-  async canAccess(fileId, userId) {
-    const file = await this.getFile(fileId);
-    if (!file) {
-      return false;
-    }
-    if (file.visibility === "public") {
-      return true;
-    }
-    if (file.uploadedBy === userId) {
-      return true;
-    }
-    if (file.visibility === "restricted") {
-      return file.allowedUsers?.includes(userId) ?? false;
-    }
-    return false;
-  }
+  // ============================================================================
+  // ORGANIZATION
+  // ============================================================================
   /**
    * Move file to different folder
    */
@@ -1769,6 +2735,7 @@ var SchemaErrorCode = {
   // Protected Resources
   PROTECTED_OBJECT: "SCHEMA_PROTECTED_OBJECT",
   PROTECTED_ATTRIBUTE: "SCHEMA_PROTECTED_ATTRIBUTE",
+  PROTECTED_VIEW: "SCHEMA_PROTECTED_VIEW",
   PROTECTED_ROLE: "SCHEMA_PROTECTED_ROLE",
   // Permissions
   FORBIDDEN: "SCHEMA_FORBIDDEN",
@@ -1833,7 +2800,7 @@ var ValidationError = class _ValidationError extends SchemaError {
 };
 var ProtectedResourceError = class extends SchemaError {
   constructor(resourceType, resourceName, operation) {
-    const code = resourceType === "object" ? SchemaErrorCode.PROTECTED_OBJECT : SchemaErrorCode.PROTECTED_ATTRIBUTE;
+    const code = resourceType === "object" ? SchemaErrorCode.PROTECTED_OBJECT : resourceType === "view" ? SchemaErrorCode.PROTECTED_VIEW : SchemaErrorCode.PROTECTED_ATTRIBUTE;
     super(`Cannot ${operation} system ${resourceType} "${resourceName}"`, code, {
       resourceType,
       resourceName,
@@ -2598,10 +3565,12 @@ var fileConfigSchema = baseConfigSchema.extend({
   maxFiles: import_zod4.z.number().int().min(1).optional(),
   maxSize: import_zod4.z.number().int().min(1).optional(),
   allowedTypes: import_zod4.z.array(import_zod4.z.string()).optional(),
-  verification: fileVerificationConfigSchema.optional()
+  verification: fileVerificationConfigSchema.optional(),
+  multiple: import_zod4.z.boolean().optional()
 });
 var userConfigSchema = baseConfigSchema.extend({
-  allowedRoles: import_zod4.z.array(import_zod4.z.string()).optional()
+  allowedRoles: import_zod4.z.array(import_zod4.z.string()).optional(),
+  multiple: import_zod4.z.boolean().optional()
 });
 var relationConfigSchema = baseConfigSchema.extend({
   targets: import_zod4.z.array(relationTargetSchema).min(1),
@@ -2613,6 +3582,30 @@ 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"
+  ]),
+  decimals: import_zod4.z.number().int().min(0).max(10).optional(),
+  materialize: import_zod4.z.boolean().optional()
+});
 var attributeConfigSchemas = {
   text: textConfigSchema,
   textarea: textareaConfigSchema,
@@ -2629,7 +3622,9 @@ var attributeConfigSchemas = {
   file: fileConfigSchema,
   user: userConfigSchema,
   relation: relationConfigSchema,
-  rating: ratingConfigSchema
+  rating: ratingConfigSchema,
+  formula: formulaConfigSchema,
+  rollup: rollupConfigSchema
 };
 function getAttributeConfigSchema(type) {
   return attributeConfigSchemas[type];
@@ -2723,20 +3718,39 @@ function createLocationValidator(_attr) {
 function createTimestampValidator(_attr) {
   return import_zod4.z.number().int().positive();
 }
-function createFileValidator(_attr) {
-  return import_zod4.z.string().uuid();
+function createFileValidator(attr) {
+  const uuidSchema = import_zod4.z.uuid({
+    message: `${attr.label} must be a valid file ID`
+  });
+  if (attr.multiple) {
+    let arraySchema = import_zod4.z.array(uuidSchema);
+    if (attr.maxFiles) {
+      arraySchema = arraySchema.max(
+        attr.maxFiles,
+        `${attr.label} cannot have more than ${attr.maxFiles} file${attr.maxFiles > 1 ? "s" : ""}`
+      );
+    }
+    return arraySchema;
+  }
+  return uuidSchema;
 }
-function createUserValidator(_attr) {
-  return import_zod4.z.string().uuid();
+function createUserValidator(attr) {
+  const uuidSchema = import_zod4.z.uuid({
+    message: `${attr.label} must be a valid user ID`
+  });
+  if (attr.multiple) {
+    return import_zod4.z.array(uuidSchema);
+  }
+  return uuidSchema;
 }
 function createSingleRelationValidator(attr) {
-  const uuidSchema = import_zod4.z.string().uuid({
+  const uuidSchema = import_zod4.z.uuid({
     message: `${attr.label} must be a valid record ID`
   });
   return import_zod4.z.union([uuidSchema, import_zod4.z.null()]);
 }
 function createMultiRelationValidator(attr) {
-  const uuidSchema = import_zod4.z.string().uuid({
+  const uuidSchema = import_zod4.z.uuid({
     message: `Each ${attr.label} item must be a valid record ID`
   });
   let arraySchema = import_zod4.z.array(uuidSchema);
@@ -2767,6 +3781,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":
@@ -2799,6 +3819,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();
   }
@@ -4426,6 +5450,123 @@ var RelationService = class {
   }
 };
 
+// src/runtime/services/user.service.ts
+var UserService = class {
+  constructor(adapter, tenantId) {
+    this.adapter = adapter;
+    this.tenantId = tenantId;
+  }
+  /**
+   * Validate all user attributes in the data
+   *
+   * @param schema - Object schema containing attribute definitions
+   * @param data - Record data to validate
+   * @returns Validation result with errors if any
+   *
+   * @example
+   * ```typescript
+   * const result = await userService.validateUsers(schema, {
+   *   assignee: "user-123",
+   *   watchers: ["user-456", "user-789"]
+   * });
+   *
+   * if (!result.valid) {
+   *   console.log(result.errors);
+   *   // [{ attribute: "assignee", message: "User not found", invalidIds: ["user-123"] }]
+   * }
+   * ```
+   */
+  async validateUsers(schema, data) {
+    const errors = [];
+    const userAttrs = schema.attributes.filter(
+      (attr) => attr.type === "user"
+    );
+    for (const attr of userAttrs) {
+      const value = data[attr.name];
+      if (value === void 0 || value === null) {
+        continue;
+      }
+      const attrErrors = await this.validateUserAttribute(attr, value);
+      errors.push(...attrErrors);
+    }
+    return {
+      valid: errors.length === 0,
+      errors
+    };
+  }
+  /**
+   * Validate a single user attribute value
+   */
+  async validateUserAttribute(attr, value) {
+    const errors = [];
+    const ids = this.extractIds(attr, value);
+    if (ids.length === 0) {
+      return errors;
+    }
+    const invalidIds = [];
+    const roleErrors = [];
+    for (const id of ids) {
+      const user = await this.adapter.userProfiles.findById(id);
+      if (!user) {
+        invalidIds.push(id);
+        continue;
+      }
+      if (user.tenantId !== this.tenantId) {
+        invalidIds.push(id);
+        continue;
+      }
+      if (attr.allowedRoles && attr.allowedRoles.length > 0) {
+        if (!attr.allowedRoles.includes(user.role)) {
+          roleErrors.push(id);
+        }
+      }
+    }
+    if (invalidIds.length > 0) {
+      errors.push({
+        attribute: attr.name,
+        message: `Invalid or non-existent users for ${attr.label}`,
+        invalidIds
+      });
+    }
+    if (roleErrors.length > 0) {
+      errors.push({
+        attribute: attr.name,
+        message: `Users do not have required role for ${attr.label}. Allowed roles: ${attr.allowedRoles?.join(", ")}`,
+        invalidIds: roleErrors
+      });
+    }
+    return errors;
+  }
+  /**
+   * Extract IDs from user value based on multiple flag
+   */
+  extractIds(attr, value) {
+    if (attr.multiple) {
+      if (!Array.isArray(value)) {
+        return [];
+      }
+      return value.filter((v) => typeof v === "string" && v !== "");
+    }
+    if (typeof value === "string" && value !== "") {
+      return [value];
+    }
+    return [];
+  }
+  /**
+   * Validate users and throw if invalid
+   */
+  async validateUsersOrThrow(schema, data) {
+    const result = await this.validateUsers(schema, data);
+    if (!result.valid) {
+      const errors = result.errors.map((e) => ({
+        path: [e.attribute],
+        message: e.message
+      }));
+      throw new ValidationError("User validation failed", errors);
+    }
+  }
+};
+
 // src/runtime/services/record.service.ts
 var RecordService = class {
   constructor(adapter, tenantId, options) {
@@ -4433,6 +5574,7 @@ var RecordService = class {
     this.tenantId = tenantId;
     this.schemaService = new ObjectSchemaService(adapter, registry);
     this.relationService = new RelationService(adapter, registry);
+    this.userService = new UserService(adapter, tenantId);
     this.hookRegistry = options?.hookRegistry ?? new NoopHookRegistry();
     this.permissionService = options?.permissionService;
     this.auditService = options?.auditService ?? (adapter.audit ? new AuditService(adapter, tenantId) : void 0);
@@ -4573,6 +5715,9 @@ var RecordService = class {
       if (!options?.skipRelationValidation) {
         await this.relationService.validateRelationsOrThrow(schema, data);
       }
+      if (!options?.skipUserValidation) {
+        await this.userService.validateUsersOrThrow(schema, data);
+      }
     }
     const completionStatus = computeRecordStatus(schema, data);
     const label = await this.computeLabel(schema, data);
@@ -4617,13 +5762,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
@@ -4684,6 +5833,9 @@ var RecordService = class {
       if (!options?.skipRelationValidation) {
         await this.relationService.validateRelationsOrThrow(schema, data);
       }
+      if (!options?.skipUserValidation) {
+        await this.userService.validateUsersOrThrow(schema, data);
+      }
     }
     const completionStatus = computeRecordStatus(schema, mergedData);
     const label = await this.computeLabel(schema, mergedData);
@@ -4915,6 +6067,46 @@ 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));
+  }
   /**
    * Permanently delete a record (hard delete)
    *
@@ -4943,11 +6135,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
@@ -4958,11 +6157,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
@@ -5007,6 +6213,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, tenantId);
+      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, tenantId);
+      }
+    }
+  }
+  /**
+   * Execute a single recalculation
+   */
+  async executeRecalculation(parentId, parentObjectId, tenantId) {
+    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, tenantId);
+  }
+  /**
+   * 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) {
@@ -5341,7 +6772,7 @@ var ViewService = class {
       throw new NotFoundError("View", viewId);
     }
     if (dbView.system) {
-      throw new ProtectedResourceError("attribute", dbView.name, "modify");
+      throw new ProtectedResourceError("view", dbView.name, "modify");
     }
     const updated = await this.adapter.views.update(viewId, {
       label: input.label,
@@ -5364,7 +6795,7 @@ var ViewService = class {
       throw new NotFoundError("View", viewId);
     }
     if (dbView.system) {
-      throw new ProtectedResourceError("attribute", dbView.name, "delete");
+      throw new ProtectedResourceError("view", dbView.name, "delete");
     }
     await this.adapter.views.delete(viewId);
   }
@@ -5704,7 +7135,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) {
@@ -5783,25 +7215,54 @@ var NoopGeocodingAdapter = class {
   FlowService,
   GeocodingService,
   GlobalSearchService,
+  InvalidPathError,
+  MaxDepthExceededError,
   NoopGeocodingAdapter,
   NoopHookRegistry,
   ObjectSchemaService,
   PermissionService,
   RecordService,
+  RelationResolverService,
   RelationService,
+  RollupScheduler,
+  RollupService,
   UserProfileService,
+  UserService,
   ViewService,
   buildAuditChanges,
   createMockAdapter,
+  createRollupHooks,
   enrichValuesWithSelectLabels,
+  evaluateFormula,
+  evaluateFormulaAttribute,
+  evaluateFormulaAttributeWithRelations,
+  evaluateFormulaWithRelations,
+  evaluateFormulaWithResult,
   extractAttributeNames,
+  extractFormulaVariables,
+  extractRelationNames,
+  extractRelationReferences,
+  flattenRelationsForEval,
+  formatFormulaResult,
+  getPathDepth,
+  getRelationPath,
   getSyncPreview,
+  getTargetAttributeName,
   getViewSyncPreview,
+  hasRelationReferences,
   isLabelExpression,
+  parsePath,
+  pathHasManyCardinality,
+  registerAllRollupHooks,
   renderLabelExpression,
+  resolveMultiplePaths,
+  resolveSingleValue,
   syncAll,
   syncNativeObjects,
   syncNativeViews,
+  traversePath,
+  validateFormulaExpression,
+  validatePath,
   verifyNativeObjectsSync,
   verifyNativeViewsSync
 });