@statezero/core 0.1.2 → 0.1.3-9.1

package/dist/setup.js

@@ -2,6 +2,9 @@ import { configInstance } from "./config.js";
 import { setAdapters } from "./reactiveAdaptor.js";
 import { syncManager } from "./syncEngine/sync.js";
 import { initEventHandler } from "./syncEngine/stores/operationEventHandlers.js";
+import { querysetStoreRegistry } from "./syncEngine/registries/querysetStoreRegistry.js";
+import { modelStoreRegistry } from "./syncEngine/registries/modelStoreRegistry.js";
+import { metricRegistry } from "./syncEngine/registries/metricRegistry.js";
 /**
  * Initialize StateZero with the provided configuration
  *
@@ -19,4 +22,12 @@ export function setupStateZero(config, getModelClass, adapters) {
     setAdapters(adapters.ModelAdaptor, adapters.QuerySetAdaptor, adapters.MetricAdaptor);
     initEventHandler();
     syncManager.initialize();
+    // Expose registries and sync manager for devtools de
+    if (typeof window !== "undefined") {
+        window.__STATEZERO_DEVTOOLS__ = {
+            querysetStoreRegistry,
+            modelStoreRegistry,
+            metricRegistry,
+        };
+    }
 }

package/dist/syncEngine/registries/metricRegistry.d.ts

@@ -8,6 +8,11 @@ export class LiveMetric {
     metricType: any;
     field: any;
     get lqs(): import("./querysetStoreRegistry").LiveQueryset;
+    /**
+     * Refresh the metric data from the database
+     * Delegates to the underlying store's sync method
+     */
+    refreshFromDb(): any;
     /**
      * Getter that always returns the current value from the store
      */

package/dist/syncEngine/registries/metricRegistry.js

@@ -17,6 +17,14 @@ export class LiveMetric {
     get lqs() {
         return querysetStoreRegistry.getEntity(this.queryset);
     }
+    /**
+     * Refresh the metric data from the database
+     * Delegates to the underlying store's sync method
+     */
+    refreshFromDb() {
+        const store = metricRegistry.getStore(this.metricType, this.queryset, this.field);
+        return store.sync();
+    }
     /**
      * Getter that always returns the current value from the store
      */

package/dist/syncEngine/registries/querysetStoreGraph.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Simple graph for tracking queryset store ancestry
+ */
+export class QuerysetStoreGraph {
+    constructor(hasStoreFn?: null);
+    graph: any;
+    hasStoreFn: () => boolean;
+    processedQuerysets: Set<any>;
+    setHasStoreFn(hasStoreFn: any): void;
+    /**
+     * Add a queryset and its parent relationship to the graph
+     */
+    addQueryset(queryset: any): void;
+    /**
+     * Find the root store for a queryset
+     * @param {Object} queryset - The queryset to analyze
+     * @returns {Object} { isRoot: boolean, root: semanticKey|null }
+     */
+    findRoot(queryset: Object): Object;
+    clear(): void;
+}

package/dist/syncEngine/registries/querysetStoreGraph.js

@@ -0,0 +1,95 @@
+import { Graph } from "graphlib";
+/**
+ * Simple graph for tracking queryset store ancestry
+ */
+export class QuerysetStoreGraph {
+    constructor(hasStoreFn = null) {
+        this.graph = new Graph({ directed: true });
+        this.hasStoreFn = hasStoreFn || (() => false);
+        this.processedQuerysets = new Set(); // Track UUIDs of processed querysets
+    }
+    setHasStoreFn(hasStoreFn) {
+        this.hasStoreFn = hasStoreFn;
+    }
+    /**
+     * Add a queryset and its parent relationship to the graph
+     */
+    addQueryset(queryset) {
+        if (!queryset)
+            return;
+        if (this.processedQuerysets.has(queryset.key)) {
+            return; // Already processed, skip
+        }
+        let current = queryset;
+        while (current && !this.processedQuerysets.has(current.key)) {
+            const currentKey = current.semanticKey;
+            const currentUuid = current.key;
+            this.processedQuerysets.add(currentUuid);
+            this.graph.setNode(currentKey);
+            if (current.__parent) {
+                const parentKey = current.__parent.semanticKey;
+                this.graph.setNode(parentKey);
+                if (currentKey !== parentKey) {
+                    this.graph.setEdge(currentKey, parentKey);
+                }
+                current = current.__parent;
+            }
+            else {
+                break;
+            }
+        }
+    }
+    /**
+     * Find the root store for a queryset
+     * @param {Object} queryset - The queryset to analyze
+     * @returns {Object} { isRoot: boolean, root: semanticKey|null }
+     */
+    findRoot(queryset) {
+        // Validate input - null/undefined is a programming error
+        if (!queryset) {
+            throw new Error("findRoot was called with a null object, instead of a queryset");
+        }
+        // Handle queryset without semanticKey
+        if (!queryset.semanticKey) {
+            throw new Error("findRoot was called on an object without a semanticKey, which means its not a queryset. findRoot only works on querysets");
+        }
+        const semanticKey = queryset.semanticKey;
+        if (!this.graph.hasNode(semanticKey)) {
+            this.addQueryset(queryset);
+        }
+        // Traverse ALL the way up to find the HIGHEST ancestor with a store
+        const visited = new Set();
+        let current = semanticKey;
+        let highestAncestorWithStore = null;
+        while (current && !visited.has(current)) {
+            visited.add(current);
+            // Check if current node has a store
+            if (this.hasStoreFn(current)) {
+                highestAncestorWithStore = current;
+            }
+            // Move to parent
+            const parents = this.graph.successors(current) || [];
+            if (parents.length > 0) {
+                current = parents[0]; // Follow the parent chain
+            }
+            else {
+                break; // No more parents
+            }
+        }
+        if (highestAncestorWithStore) {
+            if (highestAncestorWithStore === semanticKey) {
+                // This queryset itself is the highest with a store
+                return { isRoot: true, root: semanticKey };
+            }
+            else {
+                // Found a higher ancestor with a store
+                return { isRoot: false, root: highestAncestorWithStore };
+            }
+        }
+        // No stores found anywhere in the chain
+        return { isRoot: true, root: null };
+    }
+    clear() {
+        this.graph = new Graph({ directed: true });
+    }
+}

package/dist/syncEngine/registries/querysetStoreRegistry.d.ts

@@ -9,6 +9,11 @@ export class LiveQueryset {
      * Serializes the lqs as a simple array of objects, for freezing e.g in the metric stores
      */
     serialize(): any;
+    /**
+     * Refresh the queryset data from the database
+     * Delegates to the underlying store's sync method
+     */
+    refreshFromDb(): any;
     /**
      * Get the current items from the store
      * @private
@@ -23,6 +28,7 @@ declare class QuerysetStoreRegistry {
     _tempStores: WeakMap<object, any>;
     followingQuerysets: Map<any, any>;
     syncManager: () => void;
+    querysetStoreGraph: QuerysetStoreGraph;
     clear(): void;
     setSyncManager(syncManager: any): void;
     /**
@@ -30,6 +36,13 @@ declare class QuerysetStoreRegistry {
      */
     addFollowingQueryset(semanticKey: any, queryset: any): void;
     getStore(queryset: any, seed?: boolean): any;
+    /**
+     * Function to return the root store for a queryset
+     */
+    getRootStore(queryset: any): {
+        isRoot: boolean;
+        rootStore: any;
+    };
     /**
      * Get the current state of the queryset, wrapped in a LiveQueryset
      * @param {Object} queryset - The queryset
@@ -52,4 +65,5 @@ declare class QuerysetStoreRegistry {
      */
     getAllStoresForModel(ModelClass: any): any[];
 }
+import { QuerysetStoreGraph } from './querysetStoreGraph.js';
 export {};

package/dist/syncEngine/registries/querysetStoreRegistry.js

@@ -16,6 +16,7 @@ import { wrapReactiveQuerySet } from '../../reactiveAdaptor.js';
 import { processQuery, getRequiredFields, pickRequiredFields } from '../../filtering/localFiltering.js';
 import { filter } from '../../filtering/localFiltering.js';
 import { makeApiCall } from '../../flavours/django/makeApiCall.js';
+import { QuerysetStoreGraph } from './querysetStoreGraph.js';
 import { isNil, pick } from 'lodash-es';
 import hash from 'object-hash';
 import { Operation } from '../stores/operation.js';
@@ -40,28 +41,37 @@ export class LiveQueryset {
         __classPrivateFieldSet(this, _LiveQueryset_proxy, new Proxy(__classPrivateFieldGet(this, _LiveQueryset_array, "f"), {
             get: (target, prop, receiver) => {
                 // Expose the touch method through the proxy
-                if (prop === 'touch') {
+                if (prop === "touch") {
                     return () => this.touch();
                 }
-                if (prop === 'serialize') {
+                if (prop === "serialize") {
                     return () => this.serialize();
                 }
                 // Special handling for iterators and common array methods
                 if (prop === Symbol.iterator) {
                     return () => this.getCurrentItems()[Symbol.iterator]();
                 }
-                else if (typeof prop === 'string' && ['forEach', 'map', 'filter', 'reduce', 'some', 'every', 'find'].includes(prop)) {
+                else if (typeof prop === "string" &&
+                    [
+                        "forEach",
+                        "map",
+                        "filter",
+                        "reduce",
+                        "some",
+                        "every",
+                        "find",
+                    ].includes(prop)) {
                     return (...args) => this.getCurrentItems()[prop](...args);
                 }
-                else if (prop === 'length') {
+                else if (prop === "length") {
                     return this.getCurrentItems().length;
                 }
-                else if (typeof prop === 'string' && !isNaN(parseInt(prop))) {
+                else if (typeof prop === "string" && !isNaN(parseInt(prop))) {
                     // Handle numeric indices
                     return this.getCurrentItems()[prop];
                 }
                 return target[prop];
-            }
+            },
         }), "f");
         return __classPrivateFieldGet(this, _LiveQueryset_proxy, "f");
     }
@@ -73,30 +83,37 @@ export class LiveQueryset {
         // Get the current primary keys from the store
         const pks = store.render();
         // Map primary keys to full model objects
-        return pks.map(pk => {
+        return pks.map((pk) => {
             // Get the full model instance from the model store
             const pkField = __classPrivateFieldGet(this, _LiveQueryset_ModelClass, "f").primaryKeyField;
             return __classPrivateFieldGet(this, _LiveQueryset_ModelClass, "f").fromPk(pk, __classPrivateFieldGet(this, _LiveQueryset_queryset, "f")).serialize();
         });
     }
+    /**
+     * Refresh the queryset data from the database
+     * Delegates to the underlying store's sync method
+     */
+    refreshFromDb() {
+        const store = querysetStoreRegistry.getStore(__classPrivateFieldGet(this, _LiveQueryset_queryset, "f"));
+        return store.sync();
+    }
     /**
      * Get the current items from the store
      * @private
      * @returns {Array} The current items in the queryset
      */
-    getCurrentItems(sortAndFilter = true) {
+    getCurrentItems() {
         const store = querysetStoreRegistry.getStore(__classPrivateFieldGet(this, _LiveQueryset_queryset, "f"));
         // Get the current primary keys from the store
         const pks = store.render();
         // Map primary keys to full model objects
-        const instances = pks.map(pk => {
+        const instances = pks
+            .map((pk) => {
             // Get the full model instance from the model store
             const pkField = __classPrivateFieldGet(this, _LiveQueryset_ModelClass, "f").primaryKeyField;
             return __classPrivateFieldGet(this, _LiveQueryset_ModelClass, "f").fromPk(pk, __classPrivateFieldGet(this, _LiveQueryset_queryset, "f"));
         });
-        if (!sortAndFilter)
-            return instances;
-        return filter(instances, __classPrivateFieldGet(this, _LiveQueryset_queryset, "f").build(), __classPrivateFieldGet(this, _LiveQueryset_ModelClass, "f"), true);
+        return instances;
     }
 }
 _LiveQueryset_queryset = new WeakMap(), _LiveQueryset_ModelClass = new WeakMap(), _LiveQueryset_proxy = new WeakMap(), _LiveQueryset_array = new WeakMap();
@@ -106,6 +123,9 @@ class QuerysetStoreRegistry {
         this._tempStores = new WeakMap(); // WeakMap<Queryset, Store>
         this.followingQuerysets = new Map(); // Map<semanticKey, Set<queryset>>
         this.syncManager = () => { console.warn("SyncManager not set for QuerysetStoreRegistry"); };
+        this.querysetStoreGraph = new QuerysetStoreGraph((semanticKey) => {
+            return this._stores.has(semanticKey);
+        });
     }
     clear() {
         this._stores.forEach((store) => {
@@ -113,6 +133,7 @@ class QuerysetStoreRegistry {
         });
         this._stores = new Map();
         this.followingQuerysets = new Map();
+        this.querysetStoreGraph.clear();
     }
     setSyncManager(syncManager) {
         this.syncManager = syncManager;
@@ -130,6 +151,7 @@ class QuerysetStoreRegistry {
         if (isNil(queryset) || isNil(queryset.ModelClass)) {
             throw new Error("QuerysetStoreRegistry.getStore requires a valid queryset");
         }
+        this.querysetStoreGraph.addQueryset(queryset);
         // Check if we already have a temporary store for this exact QuerySet instance
         if (this._tempStores.has(queryset)) {
             return this._tempStores.get(queryset);
@@ -156,17 +178,39 @@ class QuerysetStoreRegistry {
         let ast = queryset.build();
         let ModelClass = queryset.ModelClass;
         if (queryset.__parent && seed) {
-            let parentLiveQuerySet = this.getEntity(queryset.__parent);
-            initialGroundTruthPks = filter(parentLiveQuerySet, ast, ModelClass, false);
+            const parentKey = queryset.__parent.semanticKey;
+            if (this._stores.has(parentKey)) {
+                let parentLiveQuerySet = this.getEntity(queryset.__parent);
+                initialGroundTruthPks = filter(parentLiveQuerySet, ast, ModelClass, false);
+            }
         }
         // Get the parent registry    
         const store = new QuerysetStore(ModelClass, fetchQueryset, queryset, initialGroundTruthPks, // Initial ground truth PKs
-        null // Initial operations
-        );
+        null, // Initial operations
+        {
+            getRootStore: this.getRootStore.bind(this),
+            isTemp: true,
+        });
         // Store it in the temp store map
         this._tempStores.set(queryset, store);
         return store;
     }
+    /**
+     * Function to return the root store for a queryset
+     */
+    getRootStore(queryset) {
+        if (isNil(queryset)) {
+            throw new Error("QuerysetStoreRegistry.getRootStore requires a valid queryset");
+        }
+        const { isRoot, root } = this.querysetStoreGraph.findRoot(queryset);
+        const rootStore = this._stores.get(root);
+        if (!isRoot && rootStore) {
+            return { isRoot: false, rootStore: rootStore };
+        }
+        else {
+            return { isRoot: true, rootStore: null };
+        }
+    }
     /**
      * Get the current state of the queryset, wrapped in a LiveQueryset
      * @param {Object} queryset - The queryset
@@ -183,12 +227,14 @@ class QuerysetStoreRegistry {
         // If we have a temporary store, promote it
         if (this._tempStores.has(queryset)) {
             store = this._tempStores.get(queryset);
+            store.isTemp = false; // Promote to permanent store
             this._stores.set(semanticKey, store);
             this.syncManager.followModel(this, queryset.ModelClass);
         }
         // Otherwise, ensure we have a permanent store
         else if (!this._stores.has(semanticKey)) {
             store = this.getStore(queryset, seed);
+            store.isTemp = false;
             this._stores.set(semanticKey, store);
             this.syncManager.followModel(this, queryset.ModelClass);
         }
@@ -219,11 +265,13 @@ class QuerysetStoreRegistry {
             // If we have a temp store, promote it
             if (this._tempStores.has(queryset)) {
                 store = this._tempStores.get(queryset);
+                store.isTemp = false; // Promote to permanent store
                 this._stores.set(semanticKey, store);
             }
             else {
                 // Create a new permanent store
                 store = this.getStore(queryset);
+                store.isTemp = false;
                 this._stores.set(semanticKey, store);
             }
         }

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>;
 }