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

package/dist/runtime.js

@@ -134,17 +134,22 @@ __export(runtime_exports, {
   NoopHookRegistry: () => NoopHookRegistry,
   ObjectSchemaService: () => ObjectSchemaService,
   PermissionService: () => PermissionService,
+  QueryBuilder: () => QueryBuilder,
+  QueryMultipleResultsError: () => QueryMultipleResultsError,
+  QueryNoResultError: () => QueryNoResultError,
   RecordService: () => RecordService,
   RelationResolverService: () => RelationResolverService,
   RelationService: () => RelationService,
   RollupScheduler: () => RollupScheduler,
   RollupService: () => RollupService,
+  SHORTCUT_TO_FILTER_OPERATOR: () => SHORTCUT_TO_FILTER_OPERATOR,
   UserProfileService: () => UserProfileService,
   UserService: () => UserService,
   ViewService: () => ViewService,
   buildAuditChanges: () => buildAuditChanges,
+  createDefaultState: () => createDefaultState,
   createMockAdapter: () => createMockAdapter,
-  createRollupHooks: () => createRollupHooks,
+  createQueryBuilder: () => createQueryBuilder,
   enrichValuesWithSelectLabels: () => enrichValuesWithSelectLabels,
   evaluateFormula: () => evaluateFormula,
   evaluateFormulaAttribute: () => evaluateFormulaAttribute,
@@ -157,6 +162,8 @@ __export(runtime_exports, {
   extractRelationReferences: () => extractRelationReferences,
   flattenRelationsForEval: () => flattenRelationsForEval,
   formatFormulaResult: () => formatFormulaResult,
+  formatRecord: () => formatRecord,
+  formatRecords: () => formatRecords,
   getPathDepth: () => getPathDepth,
   getRelationPath: () => getRelationPath,
   getSyncPreview: () => getSyncPreview,
@@ -166,7 +173,6 @@ __export(runtime_exports, {
   isLabelExpression: () => isLabelExpression,
   parsePath: () => parsePath,
   pathHasManyCardinality: () => pathHasManyCardinality,
-  registerAllRollupHooks: () => registerAllRollupHooks,
   renderLabelExpression: () => renderLabelExpression,
   resolveMultiplePaths: () => resolveMultiplePaths,
   resolveSingleValue: () => resolveSingleValue,
@@ -181,6 +187,477 @@ __export(runtime_exports, {
 });
 module.exports = __toCommonJS(runtime_exports);
 
+// src/runtime/client/types.ts
+function formatRecord(record) {
+  return {
+    id: record.id,
+    createdAt: record.createdAt,
+    updatedAt: record.updatedAt,
+    metadata: record.metadata ?? {},
+    ...record.values
+  };
+}
+function formatRecords(records) {
+  return records.map((r) => formatRecord(r));
+}
+function createDefaultState(objectName) {
+  return {
+    objectName,
+    filters: [],
+    combinator: "and",
+    sorts: [],
+    raw: false,
+    includeDeleted: false
+  };
+}
+var SHORTCUT_TO_FILTER_OPERATOR = {
+  eq: "is",
+  neq: "is_not",
+  gt: "gt",
+  gte: "gte",
+  lt: "lt",
+  lte: "lte",
+  contains: "contains",
+  notContains: "not_contains",
+  startsWith: "starts_with",
+  endsWith: "ends_with",
+  isEmpty: "is_empty",
+  isNotEmpty: "is_not_empty"
+};
+var QueryNoResultError = class extends Error {
+  constructor(objectName, filters) {
+    const filterInfo = filters?.length ? ` with filters: ${JSON.stringify(filters)}` : "";
+    super(`No record found in "${objectName}"${filterInfo}`);
+    this.name = "QueryNoResultError";
+    this.objectName = objectName;
+    this.filters = filters;
+  }
+};
+var QueryMultipleResultsError = class extends Error {
+  constructor(objectName, count) {
+    super(
+      `Expected single record in "${objectName}", but found ${count}. Use first() or add more filters.`
+    );
+    this.name = "QueryMultipleResultsError";
+    this.objectName = objectName;
+    this.count = count;
+  }
+};
+
+// src/runtime/client/query-builder.ts
+var QueryBuilder = class _QueryBuilder {
+  constructor(recordService, adapter, objectName, state) {
+    this.objectId = null;
+    this.recordService = recordService;
+    this.adapter = adapter;
+    this.state = {
+      ...createDefaultState(objectName),
+      ...state
+    };
+  }
+  /**
+   * Clone the builder with new state (immutability pattern)
+   */
+  clone(updates) {
+    return new _QueryBuilder(this.recordService, this.adapter, this.state.objectName, {
+      ...this.state,
+      ...updates
+    });
+  }
+  /**
+   * Resolve object name to object ID (cached)
+   */
+  async resolveObjectId() {
+    if (this.objectId) return this.objectId;
+    const tenantId = this.recordService.tenantId;
+    const dbObject = await this.adapter.objects.findByName(tenantId, this.state.objectName);
+    if (!dbObject) {
+      throw new Error(`Object "${this.state.objectName}" not found`);
+    }
+    this.objectId = dbObject.id;
+    return dbObject.id;
+  }
+  // ============================================================================
+  // FILTER METHODS
+  // ============================================================================
+  /**
+   * Add a filter rule with explicit operator
+   *
+   * @example
+   * ```typescript
+   * qb.where('status', 'is', 'active')
+   *   .where('price', 'gte', 100)
+   * ```
+   */
+  where(attribute, operator, value) {
+    const rule = { attribute, operator, value };
+    return this.clone({
+      filters: [...this.state.filters, rule]
+    });
+  }
+  /**
+   * Set filter combinator (default: 'and')
+   */
+  or() {
+    return this.clone({ combinator: "or" });
+  }
+  // ============================================================================
+  // SHORTCUT OPERATORS
+  // ============================================================================
+  /**
+   * Equal (is)
+   */
+  eq(attribute, value) {
+    return this.where(attribute, SHORTCUT_TO_FILTER_OPERATOR.eq, value);
+  }
+  /**
+   * Not equal (is_not)
+   */
+  neq(attribute, value) {
+    return this.where(attribute, SHORTCUT_TO_FILTER_OPERATOR.neq, value);
+  }
+  /**
+   * Greater than
+   */
+  gt(attribute, value) {
+    return this.where(attribute, SHORTCUT_TO_FILTER_OPERATOR.gt, value);
+  }
+  /**
+   * Greater than or equal
+   */
+  gte(attribute, value) {
+    return this.where(attribute, SHORTCUT_TO_FILTER_OPERATOR.gte, value);
+  }
+  /**
+   * Less than
+   */
+  lt(attribute, value) {
+    return this.where(attribute, SHORTCUT_TO_FILTER_OPERATOR.lt, value);
+  }
+  /**
+   * Less than or equal
+   */
+  lte(attribute, value) {
+    return this.where(attribute, SHORTCUT_TO_FILTER_OPERATOR.lte, value);
+  }
+  /**
+   * Contains (text/relation)
+   */
+  contains(attribute, value) {
+    return this.where(attribute, SHORTCUT_TO_FILTER_OPERATOR.contains, value);
+  }
+  /**
+   * Not contains
+   */
+  notContains(attribute, value) {
+    return this.where(attribute, SHORTCUT_TO_FILTER_OPERATOR.notContains, value);
+  }
+  /**
+   * Starts with (text)
+   */
+  startsWith(attribute, value) {
+    return this.where(attribute, SHORTCUT_TO_FILTER_OPERATOR.startsWith, value);
+  }
+  /**
+   * Ends with (text)
+   */
+  endsWith(attribute, value) {
+    return this.where(attribute, SHORTCUT_TO_FILTER_OPERATOR.endsWith, value);
+  }
+  /**
+   * Is empty
+   */
+  isEmpty(attribute) {
+    return this.where(attribute, SHORTCUT_TO_FILTER_OPERATOR.isEmpty, null);
+  }
+  /**
+   * Is not empty
+   */
+  isNotEmpty(attribute) {
+    return this.where(attribute, SHORTCUT_TO_FILTER_OPERATOR.isNotEmpty, null);
+  }
+  /**
+   * In list (any_of)
+   */
+  in(attribute, values) {
+    return this.where(attribute, "any_of", values);
+  }
+  /**
+   * Not in list (none_of)
+   */
+  notIn(attribute, values) {
+    return this.where(attribute, "none_of", values);
+  }
+  // ============================================================================
+  // SORT & PAGINATION
+  // ============================================================================
+  /**
+   * Add sort rule
+   */
+  orderBy(attribute, direction = "asc") {
+    return this.clone({
+      sorts: [...this.state.sorts, { attribute, direction }]
+    });
+  }
+  /**
+   * Set limit
+   */
+  limit(count) {
+    return this.clone({ limit: count });
+  }
+  /**
+   * Set offset
+   */
+  offset(count) {
+    return this.clone({ offset: count });
+  }
+  /**
+   * Include soft-deleted records
+   */
+  withDeleted() {
+    return this.clone({ includeDeleted: true });
+  }
+  // ============================================================================
+  // GROUP BY (KANBAN)
+  // ============================================================================
+  /**
+   * Group results by an attribute (for Kanban views).
+   * Only status and select attributes are supported.
+   *
+   * @example
+   * ```typescript
+   * const grouped = await qb
+   *   .groupBy('status')
+   *   .fetchGrouped();
+   * // → { groups: { 'pending': [...], 'active': [...] }, total: 50 }
+   * ```
+   */
+  groupBy(attribute) {
+    return this.clone({ groupBy: attribute });
+  }
+  // ============================================================================
+  // RAW MODE
+  // ============================================================================
+  /**
+   * Return raw ObjectRecord instead of formatted record.
+   * Includes all metadata (objectId, label, completionStatus, etc.)
+   */
+  raw() {
+    return this.clone({ raw: true });
+  }
+  // ============================================================================
+  // TERMINATION METHODS (READ)
+  // ============================================================================
+  /**
+   * Fetch records with current filters
+   * Returns formatted records by default, raw ObjectRecords if raw() was called
+   */
+  async fetch() {
+    const objectId = await this.resolveObjectId();
+    const filters = this.state.filters.length > 0 ? { combinator: this.state.combinator, rules: this.state.filters } : void 0;
+    const result = await this.recordService.listRecords(objectId, {
+      filters,
+      sorts: this.state.sorts.length > 0 ? this.state.sorts : void 0,
+      limit: this.state.limit,
+      offset: this.state.offset,
+      includeDeleted: this.state.includeDeleted
+    });
+    if (this.state.raw) {
+      return result;
+    }
+    return {
+      records: formatRecords(result.records),
+      total: result.total
+    };
+  }
+  /**
+   * Get a single record (throws if 0 or >1 results)
+   */
+  async single() {
+    const result = await this.limit(2).fetch();
+    if (result.records.length === 0) {
+      throw new QueryNoResultError(this.state.objectName, this.state.filters);
+    }
+    if (result.records.length > 1) {
+      throw new QueryMultipleResultsError(this.state.objectName, result.total);
+    }
+    return result.records[0];
+  }
+  /**
+   * Get first record or null
+   */
+  async first() {
+    const result = await this.limit(1).fetch();
+    return result.records[0] ?? null;
+  }
+  /**
+   * Get record by ID
+   */
+  async findById(id) {
+    const record = await this.recordService.getRecord(id);
+    if (!record) return null;
+    if (this.state.raw) {
+      return record;
+    }
+    return formatRecord(record);
+  }
+  /**
+   * Count records matching filters
+   */
+  async count() {
+    const result = await this.limit(0).fetch();
+    return result.total;
+  }
+  /**
+   * Fetch records grouped by the groupBy attribute (for Kanban views).
+   * Requires groupBy() to be called first.
+   *
+   * @example
+   * ```typescript
+   * const result = await schema.from('tasks')
+   *   .groupBy('status')
+   *   .fetchGrouped();
+   * // → { groups: { 'todo': [...], 'in_progress': [...], 'done': [...] }, total: 50 }
+   * ```
+   */
+  async fetchGrouped() {
+    if (!this.state.groupBy) {
+      throw new Error("groupBy() must be called before fetchGrouped()");
+    }
+    const result = await this.fetch();
+    const groupByAttr = this.state.groupBy;
+    const groups = {};
+    for (const record of result.records) {
+      const value = record[groupByAttr];
+      const key = value != null ? String(value) : "__null__";
+      if (!groups[key]) {
+        groups[key] = [];
+      }
+      groups[key].push(record);
+    }
+    return {
+      groups,
+      total: result.total
+    };
+  }
+  // ============================================================================
+  // TERMINATION METHODS (WRITE)
+  // ============================================================================
+  /**
+   * Create a new record
+   * System fields (id, createdAt, updatedAt) are managed automatically.
+   *
+   * @example
+   * ```typescript
+   * const product = await schema.from('products')
+   *   .insert({ name: 'iPhone', price: 999 });
+   *
+   * // Allow draft (missing required fields)
+   * const draft = await schema.from('products')
+   *   .insert({ name: 'Draft' }, { allowDraft: true });
+   *
+   * // With custom metadata
+   * const withMeta = await schema.from('products')
+   *   .insert({ name: 'iPhone' }, { metadata: { externalId: 'ext-123' } });
+   * ```
+   */
+  async insert(data, options) {
+    const objectId = await this.resolveObjectId();
+    const record = await this.recordService.createRecord(
+      objectId,
+      data,
+      {
+        allowDraft: options?.allowDraft,
+        validate: options?.validate,
+        metadata: options?.metadata
+      }
+    );
+    if (this.state.raw) {
+      return record;
+    }
+    return formatRecord(record);
+  }
+  /**
+   * Update records matching filters (expects exactly 1 record by default)
+   * Use with eq('id', ...) for single record update.
+   * System fields (id, createdAt, updatedAt) are managed automatically.
+   *
+   * @example
+   * ```typescript
+   * const updated = await schema.from('products')
+   *   .eq('id', 'rec-123')
+   *   .update({ price: 899 });
+   *
+   * // Update with metadata (replaces existing metadata)
+   * const withMeta = await schema.from('products')
+   *   .eq('id', 'rec-123')
+   *   .update({ price: 899 }, { metadata: { synced: true } });
+   * ```
+   */
+  async update(data, options) {
+    const existing = await this.single();
+    const recordId = this.state.raw ? existing.id : existing.id;
+    const record = await this.recordService.updateRecord(
+      recordId,
+      data,
+      {
+        partial: true,
+        metadata: options?.metadata
+      }
+    );
+    if (this.state.raw) {
+      return record;
+    }
+    return formatRecord(record);
+  }
+  /**
+   * Delete record matching filters (expects exactly 1 record)
+   *
+   * @example
+   * ```typescript
+   * await schema.from('products')
+   *   .eq('id', 'rec-123')
+   *   .delete();
+   * ```
+   */
+  async delete() {
+    const existing = await this.single();
+    const recordId = this.state.raw ? existing.id : existing.id;
+    await this.recordService.deleteRecord(recordId);
+  }
+  /**
+   * Upsert (update if exists by ID, insert otherwise)
+   * Provide 'id' for lookup. System fields (createdAt, updatedAt) are managed automatically.
+   *
+   * @example
+   * ```typescript
+   * // Insert if not exists, update if exists
+   * const product = await schema.from('products')
+   *   .upsert({ id: 'rec-123', name: 'iPhone', price: 999 });
+   *
+   * // With metadata
+   * const withMeta = await schema.from('products')
+   *   .upsert({ name: 'iPhone' }, { metadata: { source: 'import' } });
+   * ```
+   */
+  async upsert(data, options) {
+    const { id, ...rest } = data;
+    const writeData = rest;
+    if (id) {
+      const existing = await this.findById(id);
+      if (existing) {
+        return this.eq("id", id).update(writeData, {
+          metadata: options?.metadata
+        });
+      }
+    }
+    return this.insert(writeData, options);
+  }
+};
+function createQueryBuilder(recordService, adapter, objectName) {
+  return new QueryBuilder(recordService, adapter, objectName);
+}
+
 // src/runtime/formula/evaluator.ts
 var import_expr_eval = require("expr-eval");
 function createFormulaParser() {
@@ -565,260 +1042,6 @@ var NoopHookRegistry = 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, 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") {
@@ -1457,6 +1680,7 @@ function createMockObjectRecordsRepository(stores) {
         label: data.label,
         completionStatus: data.completionStatus,
         values: data.data,
+        metadata: data.metadata ?? {},
         createdAt: /* @__PURE__ */ new Date(),
         updatedAt: /* @__PURE__ */ new Date()
       };
@@ -1469,11 +1693,13 @@ function createMockObjectRecordsRepository(stores) {
       if (!existing) {
         return Promise.reject(new Error(`ObjectRecord ${id} not found`));
       }
-      const { __completionStatus, __label, ...valueData } = data;
+      const { __completionStatus, __label, __metadata, ...valueData } = data;
       const updated = {
         ...existing,
         label: __label ?? existing.label,
         completionStatus: __completionStatus ?? existing.completionStatus,
+        // Metadata uses replace behavior (not merge)
+        metadata: __metadata !== void 0 ? __metadata : existing.metadata,
         values: { ...existing.values, ...valueData },
         updatedAt: /* @__PURE__ */ new Date()
       };
@@ -3601,10 +3827,12 @@ var rollupConfigSchema = baseConfigSchema.extend({
     "countValues",
     "countEmpty",
     "percentEmpty",
-    "percentFilled"
+    "percentFilled",
+    "collect"
   ]),
   decimals: import_zod4.z.number().int().min(0).max(10).optional(),
-  materialize: import_zod4.z.boolean().optional()
+  showAsOriginal: import_zod4.z.boolean().optional(),
+  targetAttributeType: import_zod4.z.string().optional()
 });
 var attributeConfigSchemas = {
   text: textConfigSchema,
@@ -3669,7 +3897,7 @@ function createCheckboxValidator(_attr) {
   return import_zod4.z.boolean();
 }
 function createDateValidator(attr) {
-  return import_zod4.z.string().datetime({ message: `${attr.label} must be a valid ISO date` });
+  return import_zod4.z.coerce.date({ message: `${attr.label} must be a valid ISO date` });
 }
 function createPhoneValidator(_attr) {
   return import_zod4.z.object({
@@ -3775,7 +4003,7 @@ function createRelationValidator(attr) {
   return createSingleRelationValidator(attr);
 }
 function createRatingValidator(attr) {
-  let schema = import_zod4.z.number().int().min(0);
+  let schema = import_zod4.z.number().min(0);
   if (attr.max !== void 0) {
     schema = schema.max(attr.max, `${attr.label} must be at most ${attr.max}`);
   }
@@ -3929,7 +4157,7 @@ function computeRecordStatus(objectDef, data) {
 }
 
 // src/runtime/services/object-schema.service.ts
-var ObjectSchemaService = class {
+var _ObjectSchemaService = class _ObjectSchemaService {
   constructor(adapter, nativeRegistry, options) {
     this.adapter = adapter;
     this.nativeRegistry = nativeRegistry;
@@ -4352,6 +4580,14 @@ var ObjectSchemaService = class {
         "Invalid attribute name format.\nName must be a valid variable identifier:\n  \u2705 Valid: 'firstName', 'first_name', 'FirstName', 'FIRST_NAME'\n  \u274C Invalid: 'first-name', 'first name', '123name', 'first.name'"
       );
     }
+    if (_ObjectSchemaService.RESERVED_ATTRIBUTE_NAMES.includes(
+      name
+    )) {
+      throw new Error(
+        `"${name}" is a reserved name and cannot be used as an attribute name.
+Reserved names: ${_ObjectSchemaService.RESERVED_ATTRIBUTE_NAMES.join(", ")}`
+      );
+    }
   }
   /**
    * Get complete object schema (system + custom attributes)
@@ -4598,6 +4834,17 @@ var ObjectSchemaService = class {
     return baseAttr;
   }
 };
+/**
+ * Reserved attribute names that cannot be used.
+ * These names conflict with system fields on ObjectRecord.
+ */
+_ObjectSchemaService.RESERVED_ATTRIBUTE_NAMES = [
+  "id",
+  "createdAt",
+  "updatedAt",
+  "metadata"
+];
+var ObjectSchemaService = _ObjectSchemaService;
 
 // src/runtime/services/permission.service.ts
 var PermissionService = class {
@@ -5450,6 +5697,328 @@ 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)];
+  }
+  /**
+   * Find records that have forward rollups pointing to the modified record.
+   *
+   * Forward rollups are rollups where the record has a relation attribute
+   * pointing to another object, and the rollup aggregates values from that target.
+   * When the target record changes, we need to recalculate these rollups.
+   *
+   * Example: Order has relation "company" → Company, and rollup "capitalSocial"
+   * aggregating from the Company. When Company.capitalSocial changes,
+   * all Orders pointing to that Company need their rollup recalculated.
+   *
+   * @param changedRecord - The record that was modified
+   * @param changedSchema - Schema of the changed record's object
+   * @returns Array of records that need their forward rollups recalculated
+   */
+  async findRecordsWithForwardRollup(changedRecord, changedSchema) {
+    const affectedRecords = [];
+    const recordObject = await this.adapter.objects.findById(changedRecord.objectId);
+    if (!recordObject) {
+      return affectedRecords;
+    }
+    const tenantId = recordObject.tenantId;
+    const allObjects = await this.adapter.objects.list(tenantId);
+    for (const obj of allObjects) {
+      if (obj.id === changedRecord.objectId) {
+        continue;
+      }
+      const attributes = await this.adapter.attributes.findByObjectId(obj.id);
+      const rollupAttrs = attributes.filter((a) => a.type === "rollup");
+      if (rollupAttrs.length === 0) {
+        continue;
+      }
+      for (const rollupDbAttr of rollupAttrs) {
+        const rollupConfig = rollupDbAttr.config;
+        if (!rollupConfig?.relationAttribute) {
+          continue;
+        }
+        const relationAttr = attributes.find(
+          (a) => a.type === "relation" && a.name === rollupConfig.relationAttribute
+        );
+        if (!relationAttr) {
+          continue;
+        }
+        const relationConfig = relationAttr.config;
+        const targetsChangedObject = relationConfig?.targets?.some(
+          (t) => t.object === changedSchema.name
+        );
+        if (!targetsChangedObject) {
+          continue;
+        }
+        const recordsPointingToChanged = await this.adapter.objectRecords.findByRelation(
+          tenantId,
+          obj.id,
+          relationAttr.name,
+          changedRecord.id
+        );
+        affectedRecords.push(...recordsPointingToChanged);
+      }
+    }
+    const uniqueRecords = /* @__PURE__ */ new Map();
+    for (const record of affectedRecords) {
+      uniqueRecords.set(record.id, record);
+    }
+    return Array.from(uniqueRecords.values());
+  }
+};
+
 // src/runtime/services/user.service.ts
 var UserService = class {
   constructor(adapter, tenantId) {
@@ -5572,9 +6141,14 @@ var RecordService = class {
   constructor(adapter, tenantId, options) {
     this.adapter = adapter;
     this.tenantId = tenantId;
-    this.schemaService = new ObjectSchemaService(adapter, registry);
+    this.schemaService = new ObjectSchemaService(adapter, registry, {
+      userId: options?.userId,
+      userEmail: options?.userEmail,
+      auditService: options?.auditService
+    });
     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);
@@ -5726,7 +6300,8 @@ var RecordService = class {
       objectId,
       data,
       label,
-      completionStatus
+      completionStatus,
+      metadata: options?.metadata
     });
     if (!options?.skipHooks) {
       const afterCtx = {
@@ -5736,6 +6311,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",
@@ -5839,11 +6415,15 @@ var RecordService = class {
     }
     const completionStatus = computeRecordStatus(schema, mergedData);
     const label = await this.computeLabel(schema, mergedData);
-    const updated = await this.adapter.objectRecords.update(recordId, {
+    const updatePayload = {
       ...data,
       __completionStatus: completionStatus,
       __label: label
-    });
+    };
+    if (options?.metadata !== void 0) {
+      updatePayload.__metadata = options.metadata;
+    }
+    const updated = await this.adapter.objectRecords.update(recordId, updatePayload);
     if (!options?.skipHooks) {
       const afterCtx = {
         ...hookCtx,
@@ -5851,6 +6431,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,
@@ -5978,6 +6559,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",
@@ -6107,6 +6689,47 @@ var RecordService = class {
     }
     return records.map((record) => this.enrichWithFormulas(record, schema));
   }
+  /**
+   * Recalculate rollups after a record changes
+   *
+   * This handles three 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 (reverse pattern)
+   * 3. Records that have forward rollups pointing to this record (forward pattern)
+   *
+   * @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) {
+      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);
+        }
+      }
+    }
+    const affectedForwardRecords = await this.rollupService.findRecordsWithForwardRollup(
+      record,
+      schema
+    );
+    for (const forwardRecord of affectedForwardRecords) {
+      const forwardSchema = await this.schemaService.getObjectSchema(forwardRecord.objectId);
+      await this.rollupService.recalculateAndUpdate(forwardRecord, forwardSchema);
+    }
+  }
   /**
    * Permanently delete a record (hard delete)
    *
@@ -6380,7 +7003,7 @@ var RollupScheduler = class {
       clearTimeout(existing.timeout);
     }
     const timeout = setTimeout(async () => {
-      await this.executeRecalculation(parentId, parentObjectId, tenantId);
+      await this.executeRecalculation(parentId, parentObjectId);
       this.pending.delete(key);
     }, this.debounceMs);
     this.pending.set(key, { parentId, parentObjectId, tenantId, timeout });
@@ -6407,19 +7030,19 @@ var RollupScheduler = class {
       const schema = await this.getSchemaById(record.objectId);
       const tenantId = tenantMap.get(record.id);
       if (schema && tenantId) {
-        await this.rollupService.recalculateAndUpdate(record, schema, tenantId);
+        await this.rollupService.recalculateAndUpdate(record, schema);
       }
     }
   }
   /**
    * Execute a single recalculation
    */
-  async executeRecalculation(parentId, parentObjectId, tenantId) {
+  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, tenantId);
+    await this.rollupService.recalculateAndUpdate(record, schema);
   }
   /**
    * Get number of pending recalculations
@@ -7221,17 +7844,22 @@ var NoopGeocodingAdapter = class {
   NoopHookRegistry,
   ObjectSchemaService,
   PermissionService,
+  QueryBuilder,
+  QueryMultipleResultsError,
+  QueryNoResultError,
   RecordService,
   RelationResolverService,
   RelationService,
   RollupScheduler,
   RollupService,
+  SHORTCUT_TO_FILTER_OPERATOR,
   UserProfileService,
   UserService,
   ViewService,
   buildAuditChanges,
+  createDefaultState,
   createMockAdapter,
-  createRollupHooks,
+  createQueryBuilder,
   enrichValuesWithSelectLabels,
   evaluateFormula,
   evaluateFormulaAttribute,
@@ -7244,6 +7872,8 @@ var NoopGeocodingAdapter = class {
   extractRelationReferences,
   flattenRelationsForEval,
   formatFormulaResult,
+  formatRecord,
+  formatRecords,
   getPathDepth,
   getRelationPath,
   getSyncPreview,
@@ -7253,7 +7883,6 @@ var NoopGeocodingAdapter = class {
   isLabelExpression,
   parsePath,
   pathHasManyCardinality,
-  registerAllRollupHooks,
   renderLabelExpression,
   resolveMultiplePaths,
   resolveSingleValue,