@statezero/core 0.2.28 → 0.2.30

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

@@ -9,13 +9,10 @@ export class QuerysetStore {
     lastSync: number | null;
     isTemp: any;
     pruneThreshold: any;
-    getRootStore: any;
     includedPks: Map<any, any>;
     qsCache: Cache;
     _lastRenderedPks: any[] | null;
     renderCallbacks: Set<any>;
-    _rootUnregister: any;
-    _currentRootStore: any;
     _modelStoreUnregister: any;
     get cacheKey(): any;
     onHydrated(hydratedData: any): void;
@@ -35,7 +32,6 @@ export class QuerysetStore {
     getInflightOperations(): any[];
     prune(): void;
     registerRenderCallback(callback: any): () => boolean;
-    _ensureRootRegistration(): void;
     /**
      * Helper to validate PKs against the model store and apply local filtering/sorting.
      * This is the core of the rendering logic.
@@ -43,15 +39,17 @@ export class QuerysetStore {
      */
     private _getValidatedAndFilteredPks;
     render(optimistic?: boolean, fromCache?: boolean): any[];
-    renderFromRoot(optimistic: boolean | undefined, rootStore: any): any[];
+    renderFromData(optimistic?: boolean): any[];
     /**
-     * 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.
+     * 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(optimistic?: boolean): any[];
-    renderFromData(optimistic?: boolean): any[];
+    renderFromModelStore(): any[];
     applyOperation(operation: any, currentPks: any): any;
-    sync(forceFromDb?: boolean): Promise<void>;
+    /**
+     * Sync this queryset with the database.
+     * Fetches from DB and sets ground truth.
+     */
+    sync(): Promise<void>;
 }
 import { Cache } from '../cache/cache.js';

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.d.ts

@@ -22,15 +22,13 @@ export class SyncManager {
     debounceMs: number;
     maxWaitMs: number;
     batchStartTime: number | null;
-    /** @type {PQueue} */
-    syncQueue: PQueue;
     withTimeout(promise: any, ms: any): Promise<any>;
     /**
      * Initialize event handlers for all event receivers
      */
     initialize(): void;
     startPeriodicSync(): void;
-    syncStaleQuerysets(): void;
+    syncStaleQuerysets(): Promise<void>;
     pruneUnreferencedModels(): void;
     isStoreFollowed(registry: any, semanticKey: any): boolean;
     cleanup(): void;
@@ -45,5 +43,4 @@ export class SyncManager {
     processMetrics(event: any): void;
     processModels(event: any): void;
 }
-import PQueue from "p-queue";
 export const syncManager: SyncManager;

package/dist/syncEngine/sync.js

@@ -8,7 +8,7 @@ import { metricRegistry, MetricRegistry } from "./registries/metricRegistry.js";
 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;
@@ -95,9 +95,6 @@ export class SyncManager {
         this.debounceMs = 100; // Wait for rapid events to settle
         this.maxWaitMs = 2000; // Maximum time to hold events
         this.batchStartTime = null;
-        // SyncQueue
-        /** @type {PQueue} */
-        this.syncQueue = new PQueue({ concurrency: 1 });
     }
     withTimeout(promise, ms) {
         // If no timeout specified, use 2x the periodic sync interval, or 30s as fallback
@@ -155,22 +152,26 @@ export class SyncManager {
             console.log("[SyncManager] No config found, periodic sync disabled by default");
         }
     }
-    syncStaleQuerysets() {
-        let syncedCount = 0;
-        // Sync all followed querysets - keep it simple
+    async syncStaleQuerysets() {
         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));
+        // Collect all stores to sync
+        const storesToSync = [];
+        for (const [semanticKey, store] of querysetRegistry._stores.entries()) {
+            const isFollowed = this.isStoreFollowed(querysetRegistry, semanticKey);
+            if (this.followAllQuerysets || isFollowed) {
+                storesToSync.push(store);
             }
         }
-        if (syncedCount > 0) {
-            console.log(`[SyncManager] Periodic sync: ${syncedCount} stores pushed to the sync queue`);
+        if (storesToSync.length > 0) {
+            console.log(`[SyncManager] Periodic sync: syncing ${storesToSync.length} stores`);
+            // Run all groupSync calls in parallel - they coordinate via shared promise cache
+            await Promise.all(storesToSync.map(store => querysetRegistry.groupSync(store.queryset, operationId, dbSyncedKeys)));
         }
         // Prune unreferenced model instances
         this.pruneUnreferencedModels();
@@ -306,11 +307,16 @@ export class SyncManager {
                 }
             }
         }
+        if (storesToSync.length === 0)
+            return;
         // Sync all relevant stores for this model
         console.log(`[SyncManager] Syncing ${storesToSync.length} queryset stores for ${representativeEvent.model}`);
-        storesToSync.forEach((store) => {
-            this.syncQueue.add(() => this.withTimeout(store.sync()));
-        });
+        // 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));
+        // Run all groupSync calls in parallel - they coordinate via shared promise cache
+        Promise.all(storesToSync.map(store => registry.groupSync(store.queryset, operationId, dbSyncedKeys)));
     }
     processMetrics(event) {
         const registry = this.registries.get(MetricRegistry);
@@ -372,7 +378,7 @@ export class SyncManager {
         });
         if (pksToSync.length > 0) {
             console.log(`[SyncManager] Syncing ${pksToSync.length} nested-only PKs for ${event.model}: ${pksToSync}`);
-            this.syncQueue.add(() => this.withTimeout(modelStore.sync(pksToSync)));
+            modelStore.sync(pksToSync);
         }
     }
 }

package/package.json

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