@statezero/core 0.2.52 → 0.2.54

package/dist/syncEngine/stores/metricStore.d.ts

@@ -1,5 +1,8 @@
 /**
- * Store for managing a single metric with optimistic updates
+ * Store for managing a single metric with optimistic updates.
+ *
+ * Uses a delta-based approach: groundTruthValue + sum(deltas) = current value.
+ * Deltas are computed externally (by processMetricStores) and stored by operationId.
  */
 export class MetricStore {
     constructor(metricType: any, modelClass: any, queryset: any, field: null | undefined, ast: null | undefined, fetchFn: any);
@@ -11,40 +14,37 @@ export class MetricStore {
     fetchFn: any;
     groundTruthValue: any;
     isSyncing: boolean;
-    strategy: import("../metrics/metricOptCalcs.js").MetricCalculationStrategy;
-    operations: any[];
-    confirmedOps: Set<any>;
+    deltas: Map<any, any>;
     metricCache: Cache;
     _lastCalculatedValue: any;
     reset(): void;
     get cacheKey(): string;
     /**
-     * Add an operation to this metric store
-     * @param {Operation} operation - The operation to add
+     * Add a delta for an operation
      */
-    addOperation(operation: Operation): void;
+    addDelta(opId: any, delta: any): void;
     /**
-     * Update an operation in this metric store
-     * @param {Operation} operation - The operation to update
+     * Mark a delta as confirmed
      */
-    updateOperation(operation: Operation): void;
+    confirmDelta(opId: any): void;
     /**
-     * Confirm an operation in this metric store
-     * @param {Operation} operation - The operation to confirm
+     * Remove a rejected delta
      */
-    confirm(operation: Operation): void;
+    rejectDelta(opId: any): void;
     /**
-     * Reject an operation in this metric store
-     * @param {Operation} operation - The operation to reject
+     * Update a delta (e.g., when operation is mutated)
      */
-    reject(operation: Operation): void;
+    updateDelta(opId: any, delta: any): void;
+    addOperation(operation: any): void;
+    updateOperation(operation: any): void;
+    confirm(operation: any): void;
+    reject(operation: any): void;
     onHydrated(): void;
     setCache(): void;
     clearCache(): void;
     setGroundTruth(value: any): void;
     /**
-     * Render the metric with current operations
-     * @returns {any} Calculated metric value
+     * Render: groundTruthValue + sum of all deltas
      */
     render(): any;
     /**

package/dist/syncEngine/stores/metricStore.js

@@ -1,11 +1,12 @@
 import { Cache } from '../cache/cache.js';
-import { MetricStrategyFactory } from "../metrics/metricOptCalcs.js";
 import hash from 'object-hash';
 import { isNil, isEmpty, isEqual } from 'lodash-es';
 import { metricEventEmitter } from './reactivity.js';
-import { Status } from './operation.js';
 /**
- * Store for managing a single metric with optimistic updates
+ * Store for managing a single metric with optimistic updates.
+ *
+ * Uses a delta-based approach: groundTruthValue + sum(deltas) = current value.
+ * Deltas are computed externally (by processMetricStores) and stored by operationId.
  */
 export class MetricStore {
     constructor(metricType, modelClass, queryset, field = null, ast = null, fetchFn) {
@@ -17,21 +18,16 @@ export class MetricStore {
         this.fetchFn = fetchFn;
         this.groundTruthValue = null;
         this.isSyncing = false;
-        this.strategy = MetricStrategyFactory.getStrategy(metricType, modelClass);
-        // Store operations related to this metric
-        this.operations = [];
-        // Keep track of which operations have been confirmed
-        this.confirmedOps = new Set();
+        // Delta storage: opId → { delta: number, confirmed: boolean }
+        this.deltas = new Map();
         // Initialize cache with AST-specific key
         this.metricCache = new Cache("metric-store-cache", {}, this.onHydrated.bind(this));
-        // Initialize _lastCalculatedValue
         this._lastCalculatedValue = null;
     }
     reset() {
         this.groundTruthValue = null;
         this._lastCalculatedValue = null;
-        this.operations = [];
-        this.confirmedOps = new Set();
+        this.deltas = new Map();
         this.isSyncing = false;
         this.clearCache();
     }
@@ -39,86 +35,56 @@ export class MetricStore {
         return `${this.modelClass.configKey}::${this.modelClass.modelName}::metric::${this.metricType}::${this.field || "null"}::${this.ast ? hash(this.ast) : "global"}`;
     }
     /**
-     * Add an operation to this metric store
-     * @param {Operation} operation - The operation to add
+     * Add a delta for an operation
      */
-    addOperation(operation) {
-        // Only track operations for this model
-        if (operation.queryset.ModelClass !== this.modelClass) {
-            return;
-        }
-        // Check if operation already exists to avoid duplicates
-        const existingIndex = this.operations.findIndex((op) => op.operationId === operation.operationId);
-        if (existingIndex !== -1) {
-            // Update existing operation instead of adding a duplicate
-            this.operations[existingIndex] = operation;
-        }
-        else {
-            // Add to our operations list
-            this.operations.push(operation);
-        }
-        // Trigger a render to update the metric value
-        if (!isNil(this.groundTruthValue)) {
-            this.render();
-        }
+    addDelta(opId, delta) {
+        this.deltas.set(opId, { delta, confirmed: false });
+        this.render();
     }
     /**
-     * Update an operation in this metric store
-     * @param {Operation} operation - The operation to update
+     * Mark a delta as confirmed
      */
-    updateOperation(operation) {
-        // Only track operations for this model
-        if (operation.queryset.ModelClass !== this.modelClass) {
-            return;
-        }
-        // Find and update the operation - use operationId not id
-        const index = this.operations.findIndex((op) => op.operationId === operation.operationId);
-        if (index !== -1) {
-            this.operations[index] = operation;
-        }
-        else {
-            // If not found, add it
-            this.operations.push(operation);
-        }
-        // Trigger a render to update the metric value
-        if (!isNil(this.groundTruthValue)) {
+    confirmDelta(opId) {
+        const entry = this.deltas.get(opId);
+        if (entry) {
+            entry.confirmed = true;
             this.render();
         }
     }
     /**
-     * Confirm an operation in this metric store
-     * @param {Operation} operation - The operation to confirm
+     * Remove a rejected delta
      */
-    confirm(operation) {
-        // Only track operations for this model
-        if (operation.queryset.ModelClass !== this.modelClass) {
-            return;
-        }
-        // Update operation status in our list and mark as confirmed - use operationId not id
-        const index = this.operations.findIndex((op) => op.operationId === operation.operationId);
-        if (index !== -1) {
-            this.operations[index] = operation;
-            this.confirmedOps.add(operation.operationId);
+    rejectDelta(opId) {
+        if (this.deltas.delete(opId)) {
+            this.render();
         }
-        // Trigger a sync to update ground truth
-        this.render();
     }
     /**
-     * Reject an operation in this metric store
-     * @param {Operation} operation - The operation to reject
+     * Update a delta (e.g., when operation is mutated)
      */
-    reject(operation) {
-        // Only track operations for this model
-        if (operation.queryset.ModelClass !== this.modelClass) {
-            return;
-        }
-        // Remove the operation as it's now rejected - use operationId not id
-        this.operations = this.operations.filter((op) => op.operationId !== operation.operationId);
-        this.confirmedOps.delete(operation.operationId);
-        // Trigger a render to update the metric value
-        if (!isNil(this.groundTruthValue)) {
+    updateDelta(opId, delta) {
+        const entry = this.deltas.get(opId);
+        if (entry) {
+            entry.delta = delta;
             this.render();
         }
+        else {
+            this.addDelta(opId, delta);
+        }
+    }
+    // Legacy API — kept for backward compatibility with existing callers.
+    // processMetricStores in operationEventHandlers still calls these.
+    addOperation(operation) {
+        // No-op: deltas are computed externally
+    }
+    updateOperation(operation) {
+        // No-op: deltas are computed externally
+    }
+    confirm(operation) {
+        this.confirmDelta(operation.operationId);
+    }
+    reject(operation) {
+        this.rejectDelta(operation.operationId);
     }
     onHydrated() {
         if (this.groundTruthValue === null) {
@@ -141,11 +107,9 @@ export class MetricStore {
         this.metricCache.delete(this.cacheKey);
     }
     setGroundTruth(value) {
-        // Check if the value has actually changed
         const valueChanged = !isEqual(this.groundTruthValue, value);
         this.groundTruthValue = value;
         this.setCache();
-        // Only emit event if the value changed
         if (valueChanged) {
             metricEventEmitter.emit("metric::render", {
                 metricType: this.metricType,
@@ -157,20 +121,18 @@ export class MetricStore {
         }
     }
     /**
-     * Render the metric with current operations
-     * @returns {any} Calculated metric value
+     * Render: groundTruthValue + sum of all deltas
      */
     render() {
-        // Check if ground truth value is null
         if (isNil(this.groundTruthValue)) {
             return null;
         }
-        // Calculate the new value using the operations-based approach
-        const newValue = this.strategy.calculateWithOperations(this.groundTruthValue, this.operations, this.field, this.modelClass);
-        // Check if the value has actually changed
+        let newValue = this.groundTruthValue;
+        for (const { delta } of this.deltas.values()) {
+            newValue += delta;
+        }
         if (!isEqual(this._lastCalculatedValue, newValue)) {
             this._lastCalculatedValue = newValue;
-            // Only emit event if the value changed
             metricEventEmitter.emit("metric::render", {
                 metricType: this.metricType,
                 ModelClass: this.modelClass,
@@ -191,19 +153,18 @@ export class MetricStore {
         }
         this.isSyncing = true;
         try {
-            // Use fetchFn to get server metric value
             const result = await this.fetchFn({
                 metricType: this.metricType,
                 modelClass: this.modelClass,
                 field: this.field,
                 ast: this.ast,
             });
-            // After syncing, remove all confirmed operations
-            if (this.confirmedOps.size > 0) {
-                this.operations = this.operations.filter((op) => !this.confirmedOps.has(op.operationId));
-                this.confirmedOps.clear();
+            // Remove confirmed deltas — server value already includes them
+            for (const [opId, entry] of this.deltas) {
+                if (entry.confirmed) {
+                    this.deltas.delete(opId);
+                }
             }
-            // Update ground truth
             this.setGroundTruth(result);
             return result;
         }

package/dist/syncEngine/stores/modelStore.js

@@ -308,19 +308,35 @@ export class ModelStore {
         // Add completely new instances (these don't need checkpoint operations)
         updatedGroundTruth.push(...Array.from(pkMap.values()));
         this.groundTruthArray = updatedGroundTruth;
-        // Create CHECKPOINT operation for instances that already existed
+        // Create CHECKPOINT operation for instances that already existed,
+        // but skip instances that have inflight UPDATE operations — a stale re-fetch
+        // must not overwrite optimistic update data.
         if (checkpointInstances.length > 0) {
-            const checkpointOperation = new Operation({
-                operationId: `checkpoint_${Date.now()}_${Math.random()
-                    .toString(36)
-                    .substr(2, 9)}`,
-                type: Type.CHECKPOINT,
-                instances: checkpointInstances,
-                status: Status.CONFIRMED,
-                timestamp: Date.now(),
-                queryset: this.modelClass.objects.all(),
-            });
-            this.operationsMap.set(checkpointOperation.operationId, checkpointOperation);
+            const inflightUpdatePks = new Set();
+            for (const op of this.operations) {
+                if ((op.type === Type.UPDATE || op.type === Type.UPDATE_INSTANCE) &&
+                    op.status !== Status.CONFIRMED && op.status !== Status.REJECTED) {
+                    for (const inst of op.instances) {
+                        if (inst && inst[pkField] != null) {
+                            inflightUpdatePks.add(inst[pkField]);
+                        }
+                    }
+                }
+            }
+            const safeCheckpointInstances = checkpointInstances.filter(inst => !inflightUpdatePks.has(inst[pkField]));
+            if (safeCheckpointInstances.length > 0) {
+                const checkpointOperation = new Operation({
+                    operationId: `checkpoint_${Date.now()}_${Math.random()
+                        .toString(36)
+                        .substr(2, 9)}`,
+                    type: Type.CHECKPOINT,
+                    instances: safeCheckpointInstances,
+                    status: Status.CONFIRMED,
+                    timestamp: Date.now(),
+                    queryset: this.modelClass.objects.all(),
+                });
+                this.operationsMap.set(checkpointOperation.operationId, checkpointOperation);
+            }
         }
         // reactivity - use all the newly added instances (both new and updated)
         emitEvents(this, EventData.fromInstances([...checkpointInstances, ...Array.from(pkMap.values())], this.modelClass));