@statezero/core 0.1.68 → 0.1.70

package/dist/syncEngine/stores/modelStore.js

@@ -128,8 +128,15 @@ export class ModelStore {
                     return;
                 }
             }
-            item[pkField] = pk;
-            nonTempPkItems.push(item);
+            if (item && typeof item.serialize === "function") {
+                const serializedItem = item.serialize();
+                serializedItem[pkField] = pk;
+                nonTempPkItems.push(serializedItem);
+            }
+            else {
+                item[pkField] = pk;
+                nonTempPkItems.push(item);
+            }
         });
         this.modelCache.set(this.cacheKey, nonTempPkItems);
     }

package/dist/syncEngine/sync.d.ts

@@ -16,6 +16,12 @@ export class SyncManager {
     followAllQuerysets: boolean;
     followedQuerysets: Map<any, any>;
     periodicSyncTimer: NodeJS.Timeout | null;
+    eventBatch: Map<any, any>;
+    debounceTimer: NodeJS.Timeout | null;
+    maxWaitTimer: NodeJS.Timeout | null;
+    debounceMs: number;
+    maxWaitMs: number;
+    batchStartTime: number | null;
     /**
      * Initialize event handlers for all event receivers
      */
@@ -29,8 +35,9 @@ export class SyncManager {
     manageRegistry(registry: any): void;
     removeRegistry(registry: any): void;
     handleEvent: (event: any) => void;
+    processBatch(reason?: string): void;
     isQuerysetFollowed(queryset: any): boolean;
-    processQuerysets(event: any): void;
+    processQuerysetsBatch(representativeEvent: any, allEvents: any): void;
     processMetrics(event: any): void;
     processModels(event: any): void;
 }

package/dist/syncEngine/sync.js

@@ -2,8 +2,8 @@ import { getAllEventReceivers } from "../core/eventReceivers";
 import { operationRegistry } from "./stores/operation";
 import { initializeAllEventReceivers } from "../config";
 import { getEventReceiver } from "../core/eventReceivers";
-import { querysetStoreRegistry, QuerysetStoreRegistry } from "./registries/querysetStoreRegistry";
-import { modelStoreRegistry, ModelStoreRegistry } from "./registries/modelStoreRegistry";
+import { querysetStoreRegistry, QuerysetStoreRegistry, } from "./registries/querysetStoreRegistry";
+import { modelStoreRegistry, ModelStoreRegistry, } from "./registries/modelStoreRegistry";
 import { metricRegistry, MetricRegistry } from "./registries/metricRegistry";
 import { getModelClass, getConfig } from "../config";
 import { isNil } from "lodash-es";
@@ -22,14 +22,15 @@ export class EventPayload {
         return getModelClass(this.model, this.configKey);
     }
     async getFullInstances() {
-        if (this.event === 'delete') {
+        if (this.event === "delete") {
             throw new Error("Cannot fetch full instances for delete operation bozo...");
         }
         if (isNil(this._cachedInstances)) {
             this._cachedInstances = await this.modelClass.objects
                 .filter({
                 [`${this.modelClass.primaryKeyField}__in`]: this.instances.map((instance) => instance[this.modelClass.primaryKeyField]),
-            }).fetch();
+            })
+                .fetch();
         }
         return this._cachedInstances;
     }
@@ -39,19 +40,36 @@ export class SyncManager {
         this.handleEvent = (event) => {
             let payload = new EventPayload(event);
             let isLocalOperation = operationRegistry.has(payload.operation_id);
+            // Always process metrics immediately (they're lightweight)
             if (this.registries.has(MetricRegistry)) {
                 this.processMetrics(payload);
             }
             if (isLocalOperation) {
-                // This is a local operation, so don't resync querysets or models
                 return;
             }
-            if (this.registries.has(QuerysetStoreRegistry)) {
-                this.processQuerysets(payload);
+            // Add to batch for queryset/model processing
+            const key = `${event.model}::${event.configKey}`;
+            const now = Date.now();
+            // If this is the first event in the batch, start max wait timer
+            if (this.eventBatch.size === 0) {
+                this.batchStartTime = now;
+                this.maxWaitTimer = setTimeout(() => {
+                    this.processBatch("maxWait");
+                }, this.maxWaitMs);
             }
-            if (this.registries.has(ModelStoreRegistry)) {
-                this.processModels(payload);
+            this.eventBatch.set(key, {
+                event: payload,
+                firstSeen: this.eventBatch.has(key)
+                    ? this.eventBatch.get(key).firstSeen
+                    : now,
+            });
+            // Reset debounce timer
+            if (this.debounceTimer) {
+                clearTimeout(this.debounceTimer);
             }
+            this.debounceTimer = setTimeout(() => {
+                this.processBatch("debounce");
+            }, this.debounceMs);
         };
         this.registries = new Map();
         // Map of registries to model sets
@@ -60,6 +78,13 @@ export class SyncManager {
         this.followAllQuerysets = true;
         this.followedQuerysets = new Map();
         this.periodicSyncTimer = null;
+        // Batching for event processing
+        this.eventBatch = new Map(); // model::configKey -> { event, firstSeen }
+        this.debounceTimer = null;
+        this.maxWaitTimer = null;
+        this.debounceMs = 100; // Wait for rapid events to settle
+        this.maxWaitMs = 2000; // Maximum time to hold events
+        this.batchStartTime = null;
     }
     /**
      * Initialize event handlers for all event receivers
@@ -131,6 +156,15 @@ export class SyncManager {
             clearInterval(this.periodicSyncTimer);
             this.periodicSyncTimer = null;
         }
+        // Clean up batch timers
+        if (this.debounceTimer) {
+            clearTimeout(this.debounceTimer);
+            this.debounceTimer = null;
+        }
+        if (this.maxWaitTimer) {
+            clearTimeout(this.maxWaitTimer);
+            this.maxWaitTimer = null;
+        }
     }
     followModel(registry, modelClass) {
         const models = this.followedModels.get(registry) || new Set();
@@ -160,6 +194,43 @@ export class SyncManager {
     removeRegistry(registry) {
         this.registries.delete(registry.constructor);
     }
+    processBatch(reason = "unknown") {
+        if (this.eventBatch.size === 0)
+            return;
+        // Clear timers
+        if (this.debounceTimer) {
+            clearTimeout(this.debounceTimer);
+            this.debounceTimer = null;
+        }
+        if (this.maxWaitTimer) {
+            clearTimeout(this.maxWaitTimer);
+            this.maxWaitTimer = null;
+        }
+        const events = Array.from(this.eventBatch.values()).map((item) => item.event);
+        const waitTime = Date.now() - this.batchStartTime;
+        this.eventBatch.clear();
+        this.batchStartTime = null;
+        console.log(`[SyncManager] Processing batch of ${events.length} events (reason: ${reason}, waited: ${waitTime}ms)`);
+        // Group events by model for efficient processing
+        const eventsByModel = new Map();
+        events.forEach((event) => {
+            const key = `${event.model}::${event.configKey}`;
+            if (!eventsByModel.has(key)) {
+                eventsByModel.set(key, []);
+            }
+            eventsByModel.get(key).push(event);
+        });
+        // Process each model's events as a batch
+        eventsByModel.forEach((modelEvents, modelKey) => {
+            const event = modelEvents[0]; // Use first event as representative
+            if (this.registries.has(QuerysetStoreRegistry)) {
+                this.processQuerysetsBatch(event, modelEvents);
+            }
+            if (this.registries.has(ModelStoreRegistry)) {
+                this.processModels(event);
+            }
+        });
+    }
     isQuerysetFollowed(queryset) {
         const activeSemanticKeys = new Set([...this.followedQuerysets].map((qs) => qs.semanticKey));
         let current = queryset;
@@ -171,29 +242,36 @@ export class SyncManager {
         }
         return false;
     }
-    processQuerysets(event) {
+    processQuerysetsBatch(representativeEvent, allEvents) {
         const registry = this.registries.get(QuerysetStoreRegistry);
+        // Collect all stores that need syncing for this model
+        const storesToSync = [];
         for (const [semanticKey, store] of registry._stores.entries()) {
-            if (store.modelClass.modelName === event.model &&
-                store.modelClass.configKey === event.configKey) {
+            if (store.modelClass.modelName === representativeEvent.model &&
+                store.modelClass.configKey === representativeEvent.configKey) {
                 if (this.followAllQuerysets) {
-                    store.sync();
+                    storesToSync.push(store);
                     continue;
                 }
-                // Get the set of querysets following this semantic key
                 const followingQuerysets = registry.followingQuerysets.get(semanticKey);
                 if (followingQuerysets) {
-                    // Use some() to break early when we find a match
                     const shouldSync = [...followingQuerysets].some((queryset) => {
                         return this.isQuerysetFollowed(queryset);
                     });
                     if (shouldSync) {
-                        console.log(`syncing store for semantic key: ${semanticKey}`);
-                        store.sync();
+                        storesToSync.push(store);
                     }
                 }
             }
         }
+        // Sync all relevant stores for this model
+        console.log(`[SyncManager] Syncing ${storesToSync.length} queryset stores for ${representativeEvent.model}`);
+        storesToSync.forEach((store) => {
+            // Don't await - let them run in parallel
+            store.sync().catch((error) => {
+                console.error(`[SyncManager] Failed to sync queryset store:`, error);
+            });
+        });
     }
     processMetrics(event) {
         const registry = this.registries.get(MetricRegistry);
@@ -215,8 +293,32 @@ export class SyncManager {
         }
     }
     processModels(event) {
-        // No need to sync models, because everything that is live, is synced
-        return;
+        const registry = this.registries.get(ModelStoreRegistry);
+        if (!registry)
+            return;
+        // Get the model class for this event
+        const modelClass = event.modelClass;
+        if (!modelClass)
+            return;
+        // Get the model store for this model class
+        const modelStore = registry.getStore(modelClass);
+        if (!modelStore)
+            return;
+        // Event instances are just PKs - find which ones we have locally
+        const eventPks = event.instances || [];
+        // Get all currently rendered instances (includes ground truth + operations)
+        const renderedInstances = modelStore.render();
+        const localPks = new Set(renderedInstances.map((instance) => instance[modelClass.primaryKeyField]));
+        const pksToSync = eventPks.filter((pk) => localPks.has(pk));
+        if (pksToSync.length === 0) {
+            console.log(`[SyncManager] No locally cached instances to sync for ${event.model}`);
+            return;
+        }
+        // Sync only the PKs that are both in the event and locally cached
+        console.log(`[SyncManager] Syncing ${pksToSync.length} model instances for ${event.model}`);
+        modelStore.sync(pksToSync).catch((error) => {
+            console.error(`[SyncManager] Failed to sync model store for ${event.model}:`, error);
+        });
     }
 }
 const syncManager = new SyncManager();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@statezero/core",
-  "version": "0.1.68",
+  "version": "0.1.70",
   "type": "module",
   "module": "ESNext",
   "description": "The type-safe frontend client for StateZero - connect directly to your backend models with zero boilerplate",