@statezero/core 0.2.28 → 0.2.29

package/dist/syncEngine/stores/querysetStore.js

@@ -4,10 +4,8 @@ import { isNil, isEmpty, trim, isEqual } from 'lodash-es';
 import { replaceTempPks, containsTempPk } from '../../flavours/django/tempPk.js';
 import { modelStoreRegistry } from '../registries/modelStoreRegistry.js';
 import { processIncludedEntities } from '../../flavours/django/makeApiCall.js';
-import hash from 'object-hash';
 import { Cache } from '../cache/cache.js';
 import { filter } from "../../filtering/localFiltering.js";
-import { mod } from 'mathjs';
 export class QuerysetStore {
     constructor(modelClass, fetchFn, queryset, initialGroundTruthPks = null, initialOperations = null, options = {}) {
         this.modelClass = modelClass;
@@ -17,7 +15,6 @@ export class QuerysetStore {
         this.lastSync = null;
         this.isTemp = options.isTemp || false;
         this.pruneThreshold = options.pruneThreshold || 10;
-        this.getRootStore = options.getRootStore || null;
         this.groundTruthPks = initialGroundTruthPks || [];
         this.operationsMap = new Map();
         // Track which model PKs are in this queryset's included data
@@ -33,9 +30,7 @@ export class QuerysetStore {
         this.qsCache = new Cache("queryset-cache", {}, this.onHydrated.bind(this));
         this._lastRenderedPks = null;
         this.renderCallbacks = new Set();
-        this._rootUnregister = null;
-        this._currentRootStore = null;
-        this._ensureRootRegistration();
+        // Register for model store changes to re-render when model data changes
         const modelStore = modelStoreRegistry.getStore(this.modelClass);
         this._modelStoreUnregister = modelStore.registerRenderCallback(() => {
             this._emitRenderEvent();
@@ -155,28 +150,6 @@ export class QuerysetStore {
         this.renderCallbacks.add(callback);
         return () => this.renderCallbacks.delete(callback);
     }
-    _ensureRootRegistration() {
-        if (this.isTemp)
-            return;
-        const { isRoot, rootStore } = this.getRootStore(this.queryset);
-        // If the root store hasn't changed, nothing to do
-        if (this._currentRootStore === rootStore) {
-            return;
-        }
-        // Root store changed - clean up old registration if it exists
-        if (this._rootUnregister) {
-            this._rootUnregister();
-            this._rootUnregister = null;
-        }
-        // Set up new registration if we're derived and have a root store
-        if (!isRoot && rootStore) {
-            this._rootUnregister = rootStore.registerRenderCallback(() => {
-                this._emitRenderEvent();
-            });
-        }
-        // Update current root store reference (could be null now)
-        this._currentRootStore = rootStore;
-    }
     /**
      * Helper to validate PKs against the model store and apply local filtering/sorting.
      * This is the core of the rendering logic.
@@ -193,67 +166,29 @@ export class QuerysetStore {
         return finalPks;
     }
     render(optimistic = true, fromCache = false) {
-        this._ensureRootRegistration();
+        // Check cache first if requested
         if (fromCache) {
             const cachedResult = this.qsCache.get(this.cacheKey);
             if (Array.isArray(cachedResult)) {
                 return cachedResult;
             }
         }
-        let pks;
-        if (this.getRootStore &&
-            typeof this.getRootStore === "function" &&
-            !this.isTemp) {
-            const { isRoot, rootStore } = this.getRootStore(this.queryset);
-            // Only render from root if the root has been synced at least once
-            // This prevents child stores from getting empty data on first render
-            if (!isRoot && rootStore && rootStore.lastSync !== null) {
-                pks = this.renderFromRoot(optimistic, rootStore);
-            }
-        }
-        // For temp stores with no ground truth (e.g., chained optimistic filters),
-        // render from the model store instead of empty ground truth
-        if (isNil(pks) && this.isTemp && this.groundTruthPks.length === 0) {
-            pks = this.renderFromModelStore(optimistic);
-        }
-        if (isNil(pks)) {
-            pks = this.renderFromData(optimistic);
-        }
+        // If no ground truth AND hasn't been synced, render from model store
+        // This handles chained optimistic filters, newly created stores, etc.
+        // (If synced with empty results, that's valid ground truth)
+        const pks = this.groundTruthPks.length === 0 && this.lastSync === null
+            ? this.renderFromModelStore()
+            : this.renderFromData(optimistic);
+        // Validate against model store and apply local filtering/sorting
         let result = this._getValidatedAndFilteredPks(pks);
-        let limit = this.queryset.build().serializerOptions?.limit;
+        // Apply pagination limit
+        const limit = this.queryset.build().serializerOptions?.limit;
         if (limit) {
             result = result.slice(0, limit);
         }
         this.setCache(result);
         return result;
     }
-    renderFromRoot(optimistic = true, rootStore) {
-        let renderedPks = rootStore.render(optimistic);
-        let renderedData = renderedPks.map((pk) => {
-            return this.modelClass.fromPk(pk, this.queryset);
-        });
-        let ast = this.queryset.build();
-        let result = filter(renderedData, ast, this.modelClass, false);
-        return result;
-    }
-    /**
-     * Render by getting ALL instances from the model store and applying
-     * the queryset's filters locally. Used for temp stores (e.g., optimistic
-     * chained filters) that don't have their own ground truth.
-     */
-    renderFromModelStore(optimistic = true) {
-        const modelStore = modelStoreRegistry.getStore(this.modelClass);
-        // Get all PKs from the model store
-        const allPks = modelStore.groundTruthPks;
-        // Convert to model instances (like renderFromRoot does)
-        const allInstances = allPks.map((pk) => {
-            return this.modelClass.fromPk(pk, this.queryset);
-        });
-        // Apply the queryset's AST filters locally
-        const ast = this.queryset.build();
-        const result = filter(allInstances, ast, this.modelClass, false);
-        return result;
-    }
     renderFromData(optimistic = true) {
         const renderedPks = this.groundTruthSet;
         for (const op of this.operations) {
@@ -265,6 +200,17 @@ export class QuerysetStore {
         let result = Array.from(renderedPks);
         return result;
     }
+    /**
+     * Render by getting all instances from the model store and filtering locally.
+     * Used when a queryset has no ground truth (temp stores, newly created stores, etc.)
+     */
+    renderFromModelStore() {
+        const modelStore = modelStoreRegistry.getStore(this.modelClass);
+        const allPks = modelStore.groundTruthPks;
+        const allInstances = allPks.map((pk) => this.modelClass.fromPk(pk, this.queryset));
+        const ast = this.queryset.build();
+        return filter(allInstances, ast, this.modelClass, false);
+    }
     applyOperation(operation, currentPks) {
         const pkField = this.pkField;
         for (const instance of operation.instances) {
@@ -292,26 +238,16 @@ export class QuerysetStore {
         }
         return currentPks;
     }
-    async sync(forceFromDb = false) {
+    /**
+     * Sync this queryset with the database.
+     * Fetches from DB and sets ground truth.
+     */
+    async sync() {
         const id = this.modelClass.modelName;
         if (this.isSyncing) {
             console.warn(`[QuerysetStore ${id}] Already syncing, request ignored.`);
             return;
         }
-        // Check if we're delegating to a root store
-        if (!forceFromDb &&
-            this.getRootStore &&
-            typeof this.getRootStore === "function" &&
-            !this.isTemp) {
-            const { isRoot, rootStore } = this.getRootStore(this.queryset);
-            if (!isRoot && rootStore) {
-                // We're delegating to a root store - don't sync, just mark as needing sync
-                console.log(`[${id}] Delegating to root store.`);
-                this.setOperations(this.getInflightOperations());
-                return;
-            }
-        }
-        // We're in independent mode - proceed with normal sync
         this.isSyncing = true;
         console.log(`[${id}] Starting sync...`);
         try {
@@ -320,16 +256,14 @@ export class QuerysetStore {
                 modelClass: this.modelClass,
             });
             const { data, included } = response;
-            if (isNil(data)) {
-                return;
+            if (!isNil(data)) {
+                console.log(`[${id}] Sync fetch completed. Received: ${JSON.stringify(data)}.`);
+                // Clear previous included PKs tracking before processing new data
+                this.includedPks.clear();
+                // Persist all instances (including nested) to the model store
+                processIncludedEntities(modelStoreRegistry, included, this.modelClass, this.queryset);
+                this.setGroundTruth(data);
             }
-            console.log(`[${id}] Sync fetch completed. Received: ${JSON.stringify(data)}.`);
-            // Clear previous included PKs tracking before processing new data
-            this.includedPks.clear();
-            // Persists all the instances (including nested instances) to the model store
-            // Pass this queryset to track which PKs are in the included data
-            processIncludedEntities(modelStoreRegistry, included, this.modelClass, this.queryset);
-            this.setGroundTruth(data);
             this.setOperations(this.getInflightOperations());
             this.lastSync = Date.now();
             console.log(`[${id}] Sync completed.`);

package/dist/syncEngine/sync.js

@@ -9,6 +9,7 @@ import { getModelClass, getConfig } from "../config.js";
 import { isNil } from "lodash-es";
 import { QuerysetStore } from "./stores/querysetStore.js";
 import PQueue from "p-queue";
+import { v7 as uuidv7 } from "uuid";
 export class EventPayload {
     constructor(data) {
         this.event = data.event;
@@ -157,16 +158,19 @@ export class SyncManager {
     }
     syncStaleQuerysets() {
         let syncedCount = 0;
-        // Sync all followed querysets - keep it simple
         const querysetRegistry = this.registries.get(QuerysetStoreRegistry);
-        if (querysetRegistry) {
-            for (const [semanticKey, store] of querysetRegistry._stores.entries()) {
-                // Only sync if this store is actually being followed
-                const isFollowed = this.isStoreFollowed(querysetRegistry, semanticKey);
-                if (this.followAllQuerysets || isFollowed) {
-                    this.syncQueue.add(() => this.withTimeout(store.sync()));
-                    syncedCount++;
-                }
+        if (!querysetRegistry)
+            return;
+        // Generate operationId for this sync batch - querysets in same chain will coordinate
+        const operationId = `periodic-sync-${uuidv7()}`;
+        // Get dbSynced keys (followed querysets)
+        const dbSyncedKeys = new Set([...this.followedQuerysets].map(qs => qs.semanticKey));
+        for (const [semanticKey, store] of querysetRegistry._stores.entries()) {
+            // Only sync if this store is actually being followed
+            const isFollowed = this.isStoreFollowed(querysetRegistry, semanticKey);
+            if (this.followAllQuerysets || isFollowed) {
+                this.syncQueue.add(() => this.withTimeout(querysetRegistry.groupSync(store.queryset, operationId, dbSyncedKeys)));
+                syncedCount++;
             }
         }
         if (syncedCount > 0) {
@@ -308,8 +312,12 @@ export class SyncManager {
         }
         // Sync all relevant stores for this model
         console.log(`[SyncManager] Syncing ${storesToSync.length} queryset stores for ${representativeEvent.model}`);
+        // Generate operationId for this batch - querysets in same chain will coordinate
+        const operationId = `remote-event-${uuidv7()}`;
+        // Get dbSynced keys (followed querysets)
+        const dbSyncedKeys = new Set([...this.followedQuerysets].map(qs => qs.semanticKey));
         storesToSync.forEach((store) => {
-            this.syncQueue.add(() => this.withTimeout(store.sync()));
+            this.syncQueue.add(() => this.withTimeout(registry.groupSync(store.queryset, operationId, dbSyncedKeys)));
         });
     }
     processMetrics(event) {

package/package.json

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