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

package/dist/runtime.js

@@ -134,16 +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,
+  createQueryBuilder: () => createQueryBuilder,
   enrichValuesWithSelectLabels: () => enrichValuesWithSelectLabels,
   evaluateFormula: () => evaluateFormula,
   evaluateFormulaAttribute: () => evaluateFormulaAttribute,
@@ -156,6 +162,8 @@ __export(runtime_exports, {
   extractRelationReferences: () => extractRelationReferences,
   flattenRelationsForEval: () => flattenRelationsForEval,
   formatFormulaResult: () => formatFormulaResult,
+  formatRecord: () => formatRecord,
+  formatRecords: () => formatRecords,
   getPathDepth: () => getPathDepth,
   getRelationPath: () => getRelationPath,
   getSyncPreview: () => getSyncPreview,
@@ -179,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() {
@@ -1201,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()
       };
@@ -1213,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()
       };
@@ -3415,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({
@@ -3521,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}`);
   }
@@ -3675,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;
@@ -4098,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)
@@ -4344,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 {
@@ -5451,6 +5952,71 @@ var RollupService = class {
     }
     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
@@ -5575,7 +6141,11 @@ 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);
@@ -5730,7 +6300,8 @@ var RecordService = class {
       objectId,
       data,
       label,
-      completionStatus
+      completionStatus,
+      metadata: options?.metadata
     });
     if (!options?.skipHooks) {
       const afterCtx = {
@@ -5844,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,
@@ -6117,9 +6692,10 @@ var RecordService = class {
   /**
    * Recalculate rollups after a record changes
    *
-   * This handles two cases:
+   * 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
+   * 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
@@ -6133,19 +6709,26 @@ var RecordService = class {
       await this.rollupService.recalculateAndUpdate(record, schema);
     }
     const affectedParentIds = await this.rollupService.findAffectedParentRecords(record, schema);
-    if (affectedParentIds.length === 0) {
-      return;
-    }
-    const parentRecords = await this.adapter.objectRecords.findByIds(affectedParentIds);
-    for (const parentRecord of parentRecords) {
-      const parentSchema = await this.schemaService.getObjectSchema(parentRecord.objectId);
-      const rollupAttrs = parentSchema.attributes.filter(
-        (a) => a.type === "rollup"
-      );
-      if (rollupAttrs.length > 0) {
-        await this.rollupService.recalculateAndUpdate(parentRecord, parentSchema);
+    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)
@@ -7261,16 +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,
+  createQueryBuilder,
   enrichValuesWithSelectLabels,
   evaluateFormula,
   evaluateFormulaAttribute,
@@ -7283,6 +7872,8 @@ var NoopGeocodingAdapter = class {
   extractRelationReferences,
   flattenRelationsForEval,
   formatFormulaResult,
+  formatRecord,
+  formatRecords,
   getPathDepth,
   getRelationPath,
   getSyncPreview,