@statezero/core 0.1.1 → 0.1.3-9.1

package/dist/flavours/django/model.js

@@ -1,10 +1,18 @@
-import { Manager } from './manager.js';
-import { ValidationError } from './errors.js';
-import { modelStoreRegistry } from '../../syncEngine/registries/modelStoreRegistry.js';
-import { isNil } from 'lodash-es';
-import { QueryExecutor } from './queryExecutor';
-import { wrapReactiveModel } from '../../reactiveAdaptor.js';
-import { DateParsingHelpers } from './dates.js';
+var __setFunctionName = (this && this.__setFunctionName) || function (f, name, prefix) {
+    if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
+    return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
+};
+import { Manager } from "./manager.js";
+import { ValidationError } from "./errors.js";
+import { modelStoreRegistry } from "../../syncEngine/registries/modelStoreRegistry.js";
+import { isNil } from "lodash-es";
+import { QueryExecutor } from "./queryExecutor";
+import { wrapReactiveModel } from "../../reactiveAdaptor.js";
+import { DateParsingHelpers } from "./dates.js";
+import { FileObject } from './files.js';
+import { configInstance } from "../../config.js";
+import { parseStateZeroError, MultipleObjectsReturned, DoesNotExist, } from "./errors.js";
+import axios from "axios";
 /**
  * A constructor for a Model.
  *
@@ -54,7 +62,7 @@ export class Model {
      * Instantiate from pk using queryset scoped singletons
      */
     static fromPk(pk, querySet) {
-        let qsId = querySet ? querySet.__uuid : '';
+        let qsId = querySet ? querySet.__uuid : "";
         let key = `${qsId}__${this.configKey}__${this.modelName}__${pk}`;
         if (!this.instanceCache.has(key)) {
             const instance = new this();
@@ -70,6 +78,7 @@ export class Model {
      * @returns {any} The field value
      */
     getField(field) {
+        var _a;
         // Access the reactive __version property to establish dependency for vue integration
         const trackVersion = this.__version;
         const ModelClass = this.constructor;
@@ -78,11 +87,39 @@ export class Model {
         // check local overrides
         let value = this._data[field];
         // if its not been overridden, get it from the store
-        if (isNil(value) && !isNil(this._pk)) {
+        if (value === undefined && !isNil(this._pk)) {
             let storedValue = modelStoreRegistry.getEntity(ModelClass, this._pk);
             if (storedValue)
                 value = storedValue[field]; // if stops null -> undefined
         }
+        // Date/DateTime fields need special handling - convert to Date objects
+        const dateFormats = ["date", "datetime", "date-time"];
+        if (ModelClass.schema &&
+            dateFormats.includes(ModelClass.schema.properties[field]?.format) &&
+            value) {
+            // Let DateParsingHelpers.parseDate throw if it fails
+            return DateParsingHelpers.parseDate(value, field, ModelClass.schema);
+        }
+        // File/Image fields need special handling - wrap as FileObject
+        const fileFormats = ["file-path", "image-path"];
+        if (ModelClass.schema &&
+            fileFormats.includes(ModelClass.schema.properties[field]?.format) &&
+            value) {
+            // Check if it's already a FileObject
+            if (value instanceof FileObject) {
+                return value;
+            }
+            // If it's stored file data from API, wrap it as FileObject
+            if (typeof value === "object" && value.file_path) {
+                // Create anonymous subclass with correct configKey
+                const BackendFileObject = (_a = class extends FileObject {
+                    },
+                    __setFunctionName(_a, "BackendFileObject"),
+                    _a.configKey = ModelClass.configKey,
+                    _a);
+                return new BackendFileObject(value);
+            }
+        }
         // relationship fields need special handling
         if (ModelClass.relationshipFields.has(field) && value) {
             // fetch the stored value
@@ -90,15 +127,15 @@ export class Model {
             // footgun - fieldInfo.ModelClass() calls the arrow function that lazily gets the model class
             let relPkField = fieldInfo.ModelClass().primaryKeyField;
             switch (fieldInfo.relationshipType) {
-                case 'many-to-many':
+                case "many-to-many":
                     // value is an array
                     if (!Array.isArray(value) && value)
                         throw new Error(`Data corruption: m2m field for ${ModelClass.modelName} stored as ${value}`);
                     // set each pk to the full model object for that pk
-                    value = value.map(pk => fieldInfo.ModelClass().fromPk(pk));
+                    value = value.map((pk) => fieldInfo.ModelClass().fromPk(pk));
                     break;
-                case 'one-to-one':
-                case 'foreign-key':
+                case "one-to-one":
+                case "foreign-key":
                     // footgun - fieldInfo.ModelClass() calls the arrow function that lazily gets the model class
                     if (!isNil(value))
                         value = fieldInfo.ModelClass().fromPk(value);
@@ -135,13 +172,13 @@ export class Model {
             return;
         const allowedFields = this.fields;
         for (const key of Object.keys(data)) {
-            if (key === 'repr' || key === 'type')
+            if (key === "repr" || key === "type")
                 continue;
             // Handle nested fields by splitting on double underscore
             // and taking just the base field name
-            const baseField = key.split('__')[0];
+            const baseField = key.split("__")[0];
             if (!allowedFields.includes(baseField)) {
-                let errorMsg = `Invalid field: ${baseField}. Allowed fields are: ${allowedFields.join(', ')}`;
+                let errorMsg = `Invalid field: ${baseField}. Allowed fields are: ${allowedFields.join(", ")}`;
                 console.error(errorMsg);
                 throw new ValidationError(errorMsg);
             }
@@ -160,11 +197,19 @@ export class Model {
         // check local overrides
         let value = this._data[field];
         // if it's not been overridden, get it from the store
-        if (isNil(value) && !isNil(this._pk)) {
+        if (value === undefined && !isNil(this._pk)) {
             let storedValue = modelStoreRegistry.getEntity(ModelClass, this._pk);
             if (storedValue)
                 value = storedValue[field];
         }
+        // Date/DateTime fields need special handling - convert Date objects to strings for API
+        const dateFormats = ["date", "date-time"];
+        if (ModelClass.schema &&
+            dateFormats.includes(ModelClass.schema.properties[field]?.format) &&
+            value instanceof Date) {
+            // Let DateParsingHelpers.serializeDate throw if it fails
+            return DateParsingHelpers.serializeDate(value, field, ModelClass.schema);
+        }
         return value;
     }
     /**
@@ -192,16 +237,20 @@ export class Model {
     async save() {
         const ModelClass = this.constructor;
         const pkField = ModelClass.primaryKeyField;
-        const querySet = !this.pk ? ModelClass.objects.newQuerySet() : ModelClass.objects.filter({ [pkField]: this.pk });
+        const querySet = !this.pk
+            ? ModelClass.objects.newQuerySet()
+            : ModelClass.objects.filter({ [pkField]: this.pk });
         const data = this.serialize();
         let instance;
         if (!this.pk) {
             // Create new instance
-            instance = await QueryExecutor.execute(querySet, 'create', { data });
+            instance = await QueryExecutor.execute(querySet, "create", { data });
         }
         else {
             // Update existing instance
-            instance = await QueryExecutor.execute(querySet, 'update_instance', { data });
+            instance = await QueryExecutor.execute(querySet, "update_instance", {
+                data,
+            });
         }
         this._pk = instance.pk;
         this._data = {};
@@ -218,14 +267,14 @@ export class Model {
      */
     async delete() {
         if (!this.pk) {
-            throw new Error('Cannot delete unsaved instance');
+            throw new Error("Cannot delete unsaved instance");
         }
         const ModelClass = this.constructor;
         const pkField = ModelClass.primaryKeyField;
         const querySet = ModelClass.objects.filter({ [pkField]: this.pk });
         // Pass the instance data with primary key as the args
         const args = { [pkField]: this.pk };
-        const result = await QueryExecutor.execute(querySet, 'delete_instance', args);
+        const result = await QueryExecutor.execute(querySet, "delete_instance", args);
         // result -> [deletedCount, { [modelName]: deletedCount }];
         return result;
     }
@@ -237,13 +286,83 @@ export class Model {
      */
     async refreshFromDb() {
         if (!this.pk) {
-            throw new Error('Cannot refresh unsaved instance');
+            throw new Error("Cannot refresh unsaved instance");
         }
         const ModelClass = this.constructor;
-        const fresh = await ModelClass.objects.get({ [ModelClass.primaryKeyField]: this.pk });
+        const fresh = await ModelClass.objects.get({
+            [ModelClass.primaryKeyField]: this.pk,
+        });
         // clear the current data and fresh data will flow
         this._data = {};
     }
+    /**
+     * Validates the model instance using the same serialize behavior as save()
+     * @param {string} validateType - 'create' or 'update' (defaults to auto-detect)
+     * @param {boolean} partial - Whether to allow partial validation
+     * @returns {Promise<boolean>} Promise that resolves to true if valid, throws error if invalid
+     */
+    async validate(validateType = null, partial = false) {
+        const ModelClass = this.constructor;
+        if (!validateType) {
+            validateType = this.pk ? "update" : "create";
+        }
+        // Validate the validateType parameter
+        if (!["update", "create"].includes(validateType)) {
+            throw new Error(`Validation type must be 'update' or 'create', not '${validateType}'`);
+        }
+        // Use the same serialize logic as save()
+        const data = this.serialize();
+        // Delegate to static method
+        return ModelClass.validate(data, validateType, partial);
+    }
+    /**
+     * Static method to validate data without creating an instance
+     * @param {Object} data - Data to validate
+     * @param {string} validateType - 'create' or 'update'
+     * @param {boolean} partial - Whether to allow partial validation
+     * @returns {Promise<boolean>} Promise that resolves to true if valid, throws error if invalid
+     */
+    static async validate(data, validateType = "create", partial = false) {
+        const ModelClass = this;
+        // Validate the validateType parameter
+        if (!["update", "create"].includes(validateType)) {
+            throw new Error(`Validation type must be 'update' or 'create', not '${validateType}'`);
+        }
+        // Get backend config and check if it exists
+        const config = configInstance.getConfig();
+        const backend = config.backendConfigs[ModelClass.configKey];
+        if (!backend) {
+            throw new Error(`No backend configuration found for key: ${ModelClass.configKey}`);
+        }
+        // Build URL for validate endpoint
+        const baseUrl = backend.API_URL.replace(/\/+$/, "");
+        const url = `${baseUrl}/${ModelClass.modelName}/validate/`;
+        // Prepare headers
+        const headers = {
+            "Content-Type": "application/json",
+            ...(backend.getAuthHeaders ? backend.getAuthHeaders() : {}),
+        };
+        // Make direct API call to validate endpoint
+        try {
+            const response = await axios.post(url, {
+                data: data,
+                validate_type: validateType,
+                partial: partial,
+            }, { headers });
+            // Backend returns {"valid": true} on success
+            return response.data.valid === true;
+        }
+        catch (error) {
+            if (error.response && error.response.data) {
+                const parsedError = parseStateZeroError(error.response.data);
+                if (Error.captureStackTrace) {
+                    Error.captureStackTrace(parsedError, ModelClass.validate);
+                }
+                throw parsedError;
+            }
+            throw new Error(`Validation failed: ${error.message}`);
+        }
+    }
 }
 /**
  * Creates a new Model instance.

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