@statezero/core 0.1.1 → 0.1.3-9.1

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

@@ -7,6 +7,7 @@ export class ModelStore {
     isSyncing: boolean;
     pruneThreshold: any;
     modelCache: Cache;
+    _lastRenderedData: Map<any, any>;
     /**
      * Load operations from data and add them to the operations map,
      * reusing existing operations from the registry if they exist

package/dist/syncEngine/stores/modelStore.js

@@ -1,12 +1,22 @@
 import { Operation, Status, Type, operationRegistry } from './operation.js';
-import { isNil, isEmpty, trim } from 'lodash-es';
+import { isNil, isEmpty, trim, isEqual } from 'lodash-es';
 import { modelEventEmitter } from './reactivity.js';
 import { Cache } from '../cache/cache.js';
 import { replaceTempPks, containsTempPk } from '../../flavours/django/tempPk.js';
-const emitEvents = (modelClass, events) => {
-    // helper method to emit every event
-    events.forEach(event => {
-        modelEventEmitter.emit(`${modelClass.configKey}::${modelClass.modelName}::render`, event);
+const emitEvents = (store, events) => {
+    if (!Array.isArray(events))
+        return;
+    events.forEach((event) => {
+        const pk = event.pk;
+        if (isNil(pk))
+            return;
+        const newRenderedDataArray = store.render([pk], true);
+        const newRenderedData = newRenderedDataArray.length > 0 ? newRenderedDataArray[0] : null;
+        const lastRenderedData = store._lastRenderedData.get(pk);
+        if (!isEqual(newRenderedData, lastRenderedData)) {
+            store._lastRenderedData.set(pk, newRenderedData);
+            modelEventEmitter.emit(`${store.modelClass.configKey}::${store.modelClass.modelName}::render`, event);
+        }
     });
 };
 class EventData {
@@ -62,6 +72,7 @@ export class ModelStore {
             this._loadOperations(initialOperations);
         }
         this.modelCache = new Cache('model-cache', {}, this.onHydrated.bind(this));
+        this._lastRenderedData = new Map();
     }
     /**
      * Load operations from data and add them to the operations map,
@@ -164,26 +175,26 @@ export class ModelStore {
         if (this.operationsMap.size > this.pruneThreshold) {
             this.prune();
         }
-        emitEvents(this.modelClass, EventData.fromOperation(operation));
+        emitEvents(this, EventData.fromOperation(operation));
     }
     updateOperation(operation) {
         if (!this.operationsMap.has(operation.operationId))
             return false;
         this.operationsMap.set(operation.operationId, operation);
-        emitEvents(this.modelClass, EventData.fromOperation(operation));
+        emitEvents(this, EventData.fromOperation(operation));
         return true;
     }
     confirm(operation) {
         if (!this.operationsMap.has(operation.operationId))
             return;
         this.operationsMap.set(operation.operationId, operation);
-        emitEvents(this.modelClass, EventData.fromOperation(operation));
+        emitEvents(this, EventData.fromOperation(operation));
     }
     reject(operation) {
         if (!this.operationsMap.has(operation.operationId))
             return;
         this.operationsMap.set(operation.operationId, operation);
-        emitEvents(this.modelClass, EventData.fromOperation(operation));
+        emitEvents(this, EventData.fromOperation(operation));
     }
     setOperations(operations = []) {
         const prevOps = this.operations;
@@ -192,7 +203,7 @@ export class ModelStore {
             this.operationsMap.set(op.operationId, op);
         });
         const allOps = [...prevOps, ...this.operations];
-        emitEvents(this.modelClass, EventData.fromOperations(allOps));
+        emitEvents(this, EventData.fromOperations(allOps));
     }
     // Ground truth data methods
     setGroundTruth(groundTruth) {
@@ -200,7 +211,7 @@ export class ModelStore {
         this.groundTruthArray = Array.isArray(groundTruth) ? groundTruth : [];
         // reactivity - gather all ops
         const allOps = [...prevGroundTruth, ...this.groundTruthArray];
-        emitEvents(this.modelClass, EventData.fromInstances(allOps, this.modelClass));
+        emitEvents(this, EventData.fromInstances(allOps, this.modelClass));
     }
     getGroundTruth() {
         return this.groundTruthArray;
@@ -263,7 +274,7 @@ export class ModelStore {
             console.log(`[ModelStore ${this.modelClass.modelName}] Created CHECKPOINT operation for ${checkpointInstances.length} existing instances`);
         }
         // reactivity - use all the newly added instances (both new and updated)
-        emitEvents(this.modelClass, EventData.fromInstances([...checkpointInstances, ...Array.from(pkMap.values())], this.modelClass));
+        emitEvents(this, EventData.fromInstances([...checkpointInstances, ...Array.from(pkMap.values())], this.modelClass));
     }
     _filteredOperations(pks, operations) {
         if (!pks)

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

@@ -6,8 +6,16 @@ export class QuerysetStore {
     operationsMap: Map<any, any>;
     groundTruthPks: never[];
     isSyncing: boolean;
+    lastSync: number | null;
+    needsSync: boolean;
+    isTemp: any;
     pruneThreshold: any;
+    getRootStore: any;
     qsCache: Cache;
+    _lastRenderedPks: any[] | null;
+    renderCallbacks: Set<any>;
+    _rootUnregister: any;
+    _currentRootStore: any;
     get cacheKey(): any;
     onHydrated(hydratedData: any): void;
     setCache(result: any): void;
@@ -25,7 +33,17 @@ export class QuerysetStore {
     getTrimmedOperations(): any[];
     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.
+     * @private
+     */
+    private _getValidatedAndFilteredPks;
     render(optimistic?: boolean, fromCache?: boolean): any[];
+    renderFromRoot(optimistic: boolean | undefined, rootStore: any): any[];
+    renderFromData(optimistic?: boolean): any[];
     applyOperation(operation: any, currentPks: any): any;
     sync(): Promise<void>;
 }

package/dist/syncEngine/stores/querysetStore.js

@@ -1,18 +1,24 @@
 import { Operation, Status, Type, operationRegistry } from './operation.js';
 import { querysetEventEmitter } from './reactivity.js';
-import { isNil, isEmpty, trim } from 'lodash-es';
+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;
         this.fetchFn = fetchFn;
         this.queryset = queryset;
         this.isSyncing = false;
+        this.lastSync = null;
+        this.needsSync = false;
+        this.isTemp = options.isTemp || false;
         this.pruneThreshold = options.pruneThreshold || 10;
+        this.getRootStore = options.getRootStore || null;
         this.groundTruthPks = initialGroundTruthPks || [];
         this.operationsMap = new Map();
         if (Array.isArray(initialOperations)) {
@@ -22,7 +28,12 @@ export class QuerysetStore {
                 this.operationsMap.set(op.operationId, op);
             }
         }
-        this.qsCache = new Cache('queryset-cache', {}, this.onHydrated.bind(this));
+        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();
     }
     // Caching
     get cacheKey() {
@@ -40,7 +51,7 @@ export class QuerysetStore {
     setCache(result) {
         let nonTempPks = [];
         result.forEach((pk) => {
-            if (typeof pk === 'string' && containsTempPk(pk)) {
+            if (typeof pk === "string" && containsTempPk(pk)) {
                 pk = replaceTempPks(pk);
                 if (isNil(pk) || isEmpty(trim(pk))) {
                     return;
@@ -64,7 +75,22 @@ export class QuerysetStore {
         return new Set(this.groundTruthPks);
     }
     _emitRenderEvent() {
-        querysetEventEmitter.emit(`${this.modelClass.configKey}::${this.modelClass.modelName}::queryset::render`, { ast: this.queryset.build(), ModelClass: this.modelClass });
+        const newPks = this.render(true, false);
+        // 1. Always notify direct child stores to trigger their own re-evaluation.
+        //    They will perform their own check to see if their own results have changed.
+        this.renderCallbacks.forEach((callback) => {
+            try {
+                callback();
+            }
+            catch (error) {
+                console.warn("Error in render callback:", error);
+            }
+        });
+        // 2. Only emit the global event for UI components if the final list of PKs has actually changed.
+        if (!isEqual(newPks, this._lastRenderedPks)) {
+            this._lastRenderedPks = newPks; // Update the cache with the new state
+            querysetEventEmitter.emit(`${this.modelClass.configKey}::${this.modelClass.modelName}::queryset::render`, { ast: this.queryset.build(), ModelClass: this.modelClass });
+        }
     }
     async addOperation(operation) {
         this.operationsMap.set(operation.operationId, operation);
@@ -93,9 +119,7 @@ export class QuerysetStore {
         this._emitRenderEvent();
     }
     async setGroundTruth(groundTruthPks) {
-        this.groundTruthPks = Array.isArray(groundTruthPks)
-            ? groundTruthPks
-            : [];
+        this.groundTruthPks = Array.isArray(groundTruthPks) ? groundTruthPks : [];
         this._emitRenderEvent();
     }
     async setOperations(operations) {
@@ -109,10 +133,10 @@ export class QuerysetStore {
     }
     getTrimmedOperations() {
         const cutoff = Date.now() - 1000 * 60 * 2;
-        return this.operations.filter(op => op.timestamp > cutoff);
+        return this.operations.filter((op) => op.timestamp > cutoff);
     }
     getInflightOperations() {
-        return this.operations.filter(operation => operation.status != Status.CONFIRMED &&
+        return this.operations.filter((operation) => operation.status != Status.CONFIRMED &&
             operation.status != Status.REJECTED);
     }
     prune() {
@@ -120,20 +144,68 @@ export class QuerysetStore {
         this.setGroundTruth(renderedPks);
         this.setOperations(this.getInflightOperations());
     }
+    registerRenderCallback(callback) {
+        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.
+     * @private
+     */
+    _getValidatedAndFilteredPks(pks) {
+        // 1. Convert PKs to instances, filtering out any that are null (deleted).
+        const instances = Array.from(pks)
+            .map((pk) => this.modelClass.fromPk(pk, this.queryset))
+            .filter((instance) => modelStoreRegistry.getEntity(this.modelClass, instance.pk) !== null);
+        // 2. Apply the queryset's AST (filters, ordering) to the validated instances.
+        const ast = this.queryset.build();
+        const finalPks = filter(instances, ast, this.modelClass, false); // false = return PKs
+        return finalPks;
+    }
     render(optimistic = true, fromCache = false) {
+        this._ensureRootRegistration();
         if (fromCache) {
             const cachedResult = this.qsCache.get(this.cacheKey);
             if (Array.isArray(cachedResult)) {
                 return cachedResult;
             }
         }
-        const renderedPks = this.groundTruthSet;
-        for (const op of this.operations) {
-            if (op.status !== Status.REJECTED && (optimistic || op.status === Status.CONFIRMED)) {
-                this.applyOperation(op, renderedPks);
+        let pks;
+        if (this.getRootStore &&
+            typeof this.getRootStore === "function" &&
+            !this.isTemp) {
+            const { isRoot, rootStore } = this.getRootStore(this.queryset);
+            if (!isRoot && rootStore) {
+                pks = this.renderFromRoot(optimistic, rootStore);
             }
         }
-        let result = Array.from(renderedPks);
+        if (isNil(pks)) {
+            pks = this.renderFromData(optimistic);
+        }
+        let result = this._getValidatedAndFilteredPks(pks);
         let limit = this.queryset.build().serializerOptions?.limit;
         if (limit) {
             result = result.slice(0, limit);
@@ -141,12 +213,30 @@ export class QuerysetStore {
         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;
+    }
+    renderFromData(optimistic = true) {
+        const renderedPks = this.groundTruthSet;
+        for (const op of this.operations) {
+            if (op.status !== Status.REJECTED &&
+                (optimistic || op.status === Status.CONFIRMED)) {
+                this.applyOperation(op, renderedPks);
+            }
+        }
+        let result = Array.from(renderedPks);
+        return result;
+    }
     applyOperation(operation, currentPks) {
         const pkField = this.pkField;
         for (const instance of operation.instances) {
-            if (!instance ||
-                typeof instance !== 'object' ||
-                !(pkField in instance)) {
+            if (!instance || typeof instance !== "object" || !(pkField in instance)) {
                 console.warn(`[QuerysetStore ${this.modelClass.modelName}] Skipping instance in operation ${operation.operationId} due to missing PK '${String(pkField)}' or invalid format.`);
                 continue;
             }
@@ -175,23 +265,44 @@ export class QuerysetStore {
             console.warn(`[QuerysetStore ${id}] Already syncing, request ignored.`);
             return;
         }
+        // Check if we're delegating to a root store
+        if (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, marking sync needed.`);
+                this.needsSync = true;
+                this.lastSync = null; // Clear last sync since we're not actually syncing
+                this.setOperations(this.getInflightOperations());
+                return;
+            }
+        }
+        // We're in independent mode - proceed with normal sync
         this.isSyncing = true;
         console.log(`[${id}] Starting sync...`);
         try {
             const response = await this.fetchFn({
                 ast: this.queryset.build(),
-                modelClass: this.modelClass
+                modelClass: this.modelClass,
             });
             const { data, included } = response;
+            if (isNil(data)) {
+                return;
+            }
             console.log(`[${id}] Sync fetch completed. Received: ${JSON.stringify(data)}.`);
             // Persists all the instances (including nested instances) to the model store
             processIncludedEntities(modelStoreRegistry, included, this.modelClass);
             this.setGroundTruth(data);
             this.setOperations(this.getInflightOperations());
+            this.lastSync = Date.now();
+            this.needsSync = false;
             console.log(`[${id}] Sync completed.`);
         }
         catch (e) {
             console.error(`[${id}] Failed to sync ground truth:`, e);
+            this.needsSync = true; // Mark as needing sync on error
         }
         finally {
             this.isSyncing = false;

package/dist/syncEngine/sync.d.ts

@@ -15,10 +15,15 @@ export class SyncManager {
     followedModels: Map<any, any>;
     followAllQuerysets: boolean;
     followedQuerysets: Map<any, any>;
+    periodicSyncTimer: NodeJS.Timeout | null;
     /**
      * Initialize event handlers for all event receivers
      */
     initialize(): void;
+    startPeriodicSync(): void;
+    syncStaleQuerysets(): void;
+    isStoreFollowed(registry: any, semanticKey: any): boolean;
+    cleanup(): void;
     followModel(registry: any, modelClass: any): void;
     unfollowModel(registry: any, modelClass: any): void;
     manageRegistry(registry: any): void;

package/dist/syncEngine/sync.js

@@ -58,6 +58,7 @@ export class SyncManager {
         // Map of querysets to keep synced
         this.followAllQuerysets = true;
         this.followedQuerysets = new Map();
+        this.periodicSyncTimer = null;
     }
     /**
      * Initialize event handlers for all event receivers
@@ -74,13 +75,68 @@ export class SyncManager {
                 receiver.addModelEventHandler(this.handleEvent.bind(this));
             }
         });
+        this.startPeriodicSync();
+    }
+    startPeriodicSync() {
+        if (this.periodicSyncTimer)
+            return;
+        try {
+            const config = getConfig();
+            const intervalSeconds = config.periodicSyncIntervalSeconds;
+            // If null or undefined, don't start periodic sync
+            if (!intervalSeconds) {
+                console.log("[SyncManager] Periodic sync disabled (set to null)");
+                return;
+            }
+            const intervalMs = intervalSeconds * 1000;
+            this.periodicSyncTimer = setInterval(() => {
+                this.syncStaleQuerysets();
+            }, intervalMs);
+            console.log(`[SyncManager] Periodic sync started: ${intervalSeconds}s intervals`);
+        }
+        catch (error) {
+            // If no config, don't start periodic sync by default
+            console.log("[SyncManager] No config found, periodic sync disabled by default");
+        }
+    }
+    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) {
+                    store.sync();
+                    syncedCount++;
+                }
+            }
+        }
+        if (syncedCount > 0) {
+            console.log(`[SyncManager] Periodic sync: ${syncedCount} stores synced`);
+        }
+    }
+    isStoreFollowed(registry, semanticKey) {
+        const followingQuerysets = registry.followingQuerysets.get(semanticKey);
+        if (!followingQuerysets)
+            return false;
+        return [...followingQuerysets].some((queryset) => {
+            return this.isQuerysetFollowed(queryset);
+        });
+    }
+    cleanup() {
+        if (this.periodicSyncTimer) {
+            clearInterval(this.periodicSyncTimer);
+            this.periodicSyncTimer = null;
+        }
     }
     followModel(registry, modelClass) {
         const models = this.followedModels.get(registry) || new Set();
         this.followedModels.set(registry, models);
         if (models.has(modelClass))
             return;
-        const alreadyFollowed = [...this.followedModels.values()].some(set => set.has(modelClass));
+        const alreadyFollowed = [...this.followedModels.values()].some((set) => set.has(modelClass));
         models.add(modelClass);
         if (!alreadyFollowed) {
             getEventReceiver(modelClass.configKey)?.subscribe(modelClass.modelName, this.handleEvent);
@@ -91,7 +147,7 @@ export class SyncManager {
         if (!models)
             return;
         models.delete(modelClass);
-        const stillFollowed = [...this.followedModels.values()].some(set => set.has(modelClass));
+        const stillFollowed = [...this.followedModels.values()].some((set) => set.has(modelClass));
         if (!stillFollowed) {
             getEventReceiver(modelClass.configKey)?.unsubscribe(modelClass.modelName, this.handleEvent);
         }
@@ -104,10 +160,10 @@ export class SyncManager {
         this.registries.delete(registry.constructor.name);
     }
     isQuerysetFollowed(queryset) {
+        const activeSemanticKeys = new Set([...this.followedQuerysets].map((qs) => qs.semanticKey));
         let current = queryset;
-        // All followed querysets and their descendents get updated
         while (current) {
-            if (this.followedQuerysets.has(current)) {
+            if (activeSemanticKeys.has(current.semanticKey)) {
                 return true;
             }
             current = current.__parent;
@@ -127,7 +183,7 @@ export class SyncManager {
                 const followingQuerysets = registry.followingQuerysets.get(semanticKey);
                 if (followingQuerysets) {
                     // Use some() to break early when we find a match
-                    const shouldSync = [...followingQuerysets].some(queryset => {
+                    const shouldSync = [...followingQuerysets].some((queryset) => {
                         return this.isQuerysetFollowed(queryset);
                     });
                     if (shouldSync) {