@statezero/core 0.2.28 → 0.2.30

package/dist/models/default/django_app/m2mdepthtestlevel3.schema.json

@@ -5,17 +5,17 @@
     "plural_title": "M2M Depth Test Level3S",
     "primary_key_field": "id",
     "filterable_fields": [
-        "name",
         "id",
-        "category",
-        "value"
+        "value",
+        "name",
+        "category"
     ],
     "searchable_fields": [
         "name"
     ],
     "ordering_fields": [
-        "name",
-        "value"
+        "value",
+        "name"
     ],
     "properties": {
         "id": {

package/dist/models/default/django_app/modelwithrestrictedfields.schema.json

@@ -5,9 +5,9 @@
     "plural_title": "Model With Restricted Fieldss",
     "primary_key_field": "id",
     "filterable_fields": [
-        "name",
         "id",
         "admin_only_field",
+        "name",
         "restricted_related"
     ],
     "searchable_fields": [

package/dist/models/default/django_app/namefiltercustompkmodel.schema.json

@@ -5,15 +5,15 @@
     "plural_title": "Name Filter Custom Pk Models",
     "primary_key_field": "custom_pk",
     "filterable_fields": [
-        "name",
-        "custom_pk"
+        "custom_pk",
+        "name"
     ],
     "searchable_fields": [
         "name"
     ],
     "ordering_fields": [
-        "name",
-        "custom_pk"
+        "custom_pk",
+        "name"
     ],
     "properties": {
         "custom_pk": {

package/dist/models/default/django_app/order.schema.json

@@ -5,18 +5,18 @@
     "plural_title": "Orders",
     "primary_key_field": "id",
     "filterable_fields": [
+        "status",
+        "total",
         "id",
-        "customer_email",
+        "created_at",
         "customer_name",
-        "status",
-        "order_number",
+        "customer_email",
         "last_updated",
-        "created_at",
-        "total"
+        "order_number"
     ],
     "searchable_fields": [
-        "order_number",
-        "customer_name"
+        "customer_name",
+        "order_number"
     ],
     "ordering_fields": [
         "created_at",
@@ -134,7 +134,7 @@
             "format": "date-time",
             "max_length": null,
             "choices": null,
-            "default": "2026-01-18T17:05:59.982046+00:00",
+            "default": "2026-01-29T14:56:44.889107+00:00",
             "validators": [],
             "max_digits": null,
             "decimal_places": null,

package/dist/models/default/django_app/orderitem.schema.json

@@ -7,8 +7,8 @@
     "filterable_fields": [
         "id",
         "order",
-        "price",
         "product",
+        "price",
         "quantity"
     ],
     "searchable_fields": [],

package/dist/models/default/django_app/product.schema.json

@@ -5,22 +5,22 @@
     "plural_title": "Products",
     "primary_key_field": "id",
     "filterable_fields": [
-        "id",
         "name",
-        "description",
+        "id",
         "price",
-        "category",
         "created_at",
-        "created_by",
-        "in_stock"
+        "category",
+        "in_stock",
+        "description",
+        "created_by"
     ],
     "searchable_fields": [
-        "name",
-        "description"
+        "description",
+        "name"
     ],
     "ordering_fields": [
-        "name",
         "price",
+        "name",
         "created_at"
     ],
     "properties": {
@@ -129,7 +129,7 @@
             "format": "date-time",
             "max_length": null,
             "choices": null,
-            "default": "2026-01-18T17:05:59.911294+00:00",
+            "default": "2026-01-29T14:56:44.816661+00:00",
             "validators": [],
             "max_digits": null,
             "decimal_places": null,

package/dist/models/default/django_app/productcategory.schema.json

@@ -5,8 +5,8 @@
     "plural_title": "Product Categorys",
     "primary_key_field": "id",
     "filterable_fields": [
-        "name",
-        "id"
+        "id",
+        "name"
     ],
     "searchable_fields": [
         "name"

package/dist/models/default/django_app/rateplan.schema.json

@@ -5,8 +5,8 @@
     "plural_title": "Rate Plans",
     "primary_key_field": "id",
     "filterable_fields": [
-        "name",
-        "id"
+        "id",
+        "name"
     ],
     "searchable_fields": [
         "name"

package/dist/models/default/django_app/restrictedfieldrelatedmodel.schema.json

@@ -5,9 +5,9 @@
     "plural_title": "Restricted Field Related Models",
     "primary_key_field": "id",
     "filterable_fields": [
-        "name",
         "id",
-        "admin_only_field"
+        "admin_only_field",
+        "name"
     ],
     "searchable_fields": [
         "name"

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

@@ -2,20 +2,30 @@
  * 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
+     * Find the root (topmost ancestor) of a queryset chain within a subset.
+     * Traverses up the graph but only considers nodes that are in the subset.
+     * Uses the graph to "jump" through nodes not in subset to find connections.
+     *
      * @param {Object} queryset - The queryset to analyze
+     * @param {Set|null} subset - Set of semanticKeys to consider. If null, considers all nodes in graph.
      * @returns {Object} { isRoot: boolean, root: semanticKey|null }
      */
-    findRoot(queryset: Object): Object;
+    findRoot(queryset: Object, subset?: Set<any> | null): Object;
+    /**
+     * Check if parent queryset is a valid data source for creating an edge.
+     * Parent must have data that is a superset of what child needs.
+     *
+     * @param {Object} parentOpts - Parent's serializerOptions
+     * @param {Object} childOpts - Child's serializerOptions
+     * @returns {boolean} - True if parent is valid for edge creation
+     */
+    _isValidParentForEdge(parentOpts?: Object, childOpts?: Object): boolean;
     clear(): void;
 }

package/dist/syncEngine/registries/querysetStoreGraph.js

@@ -3,14 +3,10 @@ import { Graph } from "graphlib";
  * Simple graph for tracking queryset store ancestry
  */
 export class QuerysetStoreGraph {
-    constructor(hasStoreFn = null) {
+    constructor() {
         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
      */
@@ -29,7 +25,11 @@ export class QuerysetStoreGraph {
             if (current.__parent) {
                 const parentKey = current.__parent.semanticKey;
                 this.graph.setNode(parentKey);
-                if (currentKey !== parentKey) {
+                // Determine if we can create an edge to parent
+                // Parent must be a valid data source (superset of child's data needs)
+                const canLinkToParent = currentKey !== parentKey &&
+                    this._isValidParentForEdge(current.__parent._serializerOptions, current._serializerOptions);
+                if (canLinkToParent) {
                     this.graph.setEdge(currentKey, parentKey);
                 }
                 current = current.__parent;
@@ -40,11 +40,15 @@ export class QuerysetStoreGraph {
         }
     }
     /**
-     * Find the root store for a queryset
+     * Find the root (topmost ancestor) of a queryset chain within a subset.
+     * Traverses up the graph but only considers nodes that are in the subset.
+     * Uses the graph to "jump" through nodes not in subset to find connections.
+     *
      * @param {Object} queryset - The queryset to analyze
+     * @param {Set|null} subset - Set of semanticKeys to consider. If null, considers all nodes in graph.
      * @returns {Object} { isRoot: boolean, root: semanticKey|null }
      */
-    findRoot(queryset) {
+    findRoot(queryset, subset = null) {
         // Validate input - null/undefined is a programming error
         if (!queryset) {
             throw new Error("findRoot was called with a null object, instead of a queryset");
@@ -57,39 +61,77 @@ export class QuerysetStoreGraph {
         if (!this.graph.hasNode(semanticKey)) {
             this.addQueryset(queryset);
         }
-        // Traverse ALL the way up to find the HIGHEST ancestor with a store
+        // If no subset provided, consider all nodes in the graph
+        subset = subset || new Set(this.graph.nodes());
+        // Traverse ALL the way up to find the HIGHEST ancestor in the subset
         const visited = new Set();
         let current = semanticKey;
-        let highestAncestorWithStore = null;
+        let highestInSubset = null;
         while (current && !visited.has(current)) {
             visited.add(current);
-            // Check if current node has a store
-            if (this.hasStoreFn(current)) {
-                highestAncestorWithStore = current;
+            // Check if current node is in subset
+            if (subset.has(current)) {
+                highestInSubset = current;
             }
-            // Move to parent
+            // Move to parent (continue jumping even if current not in subset)
             const parents = this.graph.successors(current) || [];
             if (parents.length > 0) {
-                current = parents[0]; // Follow the parent chain
+                current = parents[0];
             }
             else {
-                break; // No more parents
+                break;
             }
         }
-        if (highestAncestorWithStore) {
-            if (highestAncestorWithStore === semanticKey) {
-                // This queryset itself is the highest with a store
+        if (highestInSubset) {
+            if (highestInSubset === semanticKey) {
+                // This queryset itself is the highest in subset
                 return { isRoot: true, root: semanticKey };
             }
             else {
-                // Found a higher ancestor with a store
-                return { isRoot: false, root: highestAncestorWithStore };
+                // Found a higher ancestor in subset
+                return { isRoot: false, root: highestInSubset };
             }
         }
-        // No stores found anywhere in the chain
+        // No nodes found in subset
         return { isRoot: true, root: null };
     }
+    /**
+     * Check if parent queryset is a valid data source for creating an edge.
+     * Parent must have data that is a superset of what child needs.
+     *
+     * @param {Object} parentOpts - Parent's serializerOptions
+     * @param {Object} childOpts - Child's serializerOptions
+     * @returns {boolean} - True if parent is valid for edge creation
+     */
+    _isValidParentForEdge(parentOpts = {}, childOpts = {}) {
+        // Cannot link if parent has pagination (limit/offset)
+        // Paginated parent only has a subset of data
+        if (parentOpts.limit != null || parentOpts.offset != null) {
+            return false;
+        }
+        // Cannot link if parent has different depth
+        // Different depth means different nested data structure
+        if (parentOpts.depth != null && parentOpts.depth !== childOpts.depth) {
+            return false;
+        }
+        // Cannot link if parent has fields that are not a superset of child's fields
+        // Parent must have all fields that child needs
+        if (parentOpts.fields != null) {
+            // If child needs all fields (null) but parent restricts fields, cannot link
+            if (childOpts.fields == null) {
+                return false;
+            }
+            // Check if parent's fields contain all of child's fields
+            const parentFields = new Set(parentOpts.fields);
+            const childHasFieldsNotInParent = childOpts.fields.some(f => !parentFields.has(f));
+            if (childHasFieldsNotInParent) {
+                return false;
+            }
+        }
+        return true;
+    }
     clear() {
         this.graph = new Graph({ directed: true });
+        this.processedQuerysets = new Set();
     }
 }

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

@@ -28,28 +28,21 @@ export class QuerysetStoreRegistry {
     followingQuerysets: Map<any, any>;
     syncManager: () => void;
     querysetStoreGraph: QuerysetStoreGraph;
+    _groupSyncCache: Map<any, any>;
     clear(): void;
     setSyncManager(syncManager: any): void;
     /**
      * Add a queryset to the following set for a semantic key
      */
     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;
-    };
+    getStore(queryset: any): any;
     /**
      * Get the current state of the queryset, wrapped in a LiveQueryset
      * @param {Object} queryset - The queryset
-     * @param {Boolean} seed - Should we optimistically seed the queryset with relevant items from the parent?
      * @param {Boolean} sync - Schedule a sync of the queryset with the backend
      * @returns {LiveQueryset} - A live view of the queryset
      */
-    getEntity(queryset: Object, seed?: boolean, sync?: boolean): LiveQueryset;
+    getEntity(queryset: Object, sync?: boolean): LiveQueryset;
     /**
      * Set ground truth for a queryset
      * @param {Object} queryset - The queryset
@@ -63,6 +56,17 @@ export class QuerysetStoreRegistry {
      * @returns {Array} - Array of queryset stores for this model
      */
     getAllStoresForModel(ModelClass: any): any[];
+    /**
+     * Sync a queryset, coordinating with its chain to minimize DB calls.
+     * The root fetches from DB, children filter from cached results.
+     * Uses operationId to coordinate - whoever arrives first creates the promise,
+     * the root takes over and resolves it.
+     *
+     * @param {Object} queryset - The queryset to sync
+     * @param {string} operationId - Unique ID for this sync operation (for coordination)
+     * @param {Set} dbSyncedKeys - Set of semanticKeys that are dbSynced (followedQuerysets)
+     */
+    groupSync(queryset: Object, operationId: string, dbSyncedKeys: Set<any>): Promise<void>;
 }
 export const querysetStoreRegistry: QuerysetStoreRegistry;
 import { QuerysetStoreGraph } from './querysetStoreGraph.js';

package/dist/syncEngine/registries/querysetStoreRegistry.js

@@ -123,9 +123,10 @@ export 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);
-        });
+        this.querysetStoreGraph = new QuerysetStoreGraph();
+        // Cache for groupSync coordination
+        // Map<operationId, { promise, resolve, rootKey, pks, ModelClass }>
+        this._groupSyncCache = new Map();
     }
     clear() {
         this._stores.forEach((store) => {
@@ -147,7 +148,7 @@ export class QuerysetStoreRegistry {
         }
         this.followingQuerysets.get(semanticKey).add(queryset);
     }
-    getStore(queryset, seed = false) {
+    getStore(queryset) {
         if (isNil(queryset) || isNil(queryset.ModelClass)) {
             throw new Error("QuerysetStoreRegistry.getStore requires a valid queryset");
         }
@@ -183,55 +184,25 @@ export class QuerysetStoreRegistry {
             };
             const response = await makeApiCall(queryset, 'list', payload, null, // operationId
             null, // beforeExit
-            canonical_id // canonical_id for caching
+            canonical_id, // canonical_id for caching
+            { namespace: 'sync', timeout: 30000 } // Sync ops on separate queue
             );
             return response.data;
         };
-        let initialGroundTruthPks = null;
-        let ast = queryset.build();
-        let ModelClass = queryset.ModelClass;
-        if (queryset.__parent && seed) {
-            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
+        const store = new QuerysetStore(queryset.ModelClass, fetchQueryset, queryset, null, // No initial ground truth - will render from model store if needed
         null, // Initial operations
-        {
-            getRootStore: this.getRootStore.bind(this),
-            isTemp: true,
-        });
+        { 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
-     * @param {Boolean} seed - Should we optimistically seed the queryset with relevant items from the parent?
      * @param {Boolean} sync - Schedule a sync of the queryset with the backend
      * @returns {LiveQueryset} - A live view of the queryset
      */
-    getEntity(queryset, seed = true, sync = false) {
+    getEntity(queryset, sync = false) {
         if (isNil(queryset))
             throw new Error(`qsStoreRegistry: getEntity cannot be called without a queryset`);
         const semanticKey = queryset.semanticKey;
@@ -246,7 +217,7 @@ export class QuerysetStoreRegistry {
         }
         // Otherwise, ensure we have a permanent store
         else if (!this._stores.has(semanticKey)) {
-            store = this.getStore(queryset, seed);
+            store = this.getStore(queryset);
             store.isTemp = false;
             this._stores.set(semanticKey, store);
             this.syncManager.followModel(this, queryset.ModelClass);
@@ -301,5 +272,60 @@ export class QuerysetStoreRegistry {
             return [];
         return Array.from(this._stores.values()).filter(store => store.modelClass === ModelClass);
     }
+    /**
+     * Sync a queryset, coordinating with its chain to minimize DB calls.
+     * The root fetches from DB, children filter from cached results.
+     * Uses operationId to coordinate - whoever arrives first creates the promise,
+     * the root takes over and resolves it.
+     *
+     * @param {Object} queryset - The queryset to sync
+     * @param {string} operationId - Unique ID for this sync operation (for coordination)
+     * @param {Set} dbSyncedKeys - Set of semanticKeys that are dbSynced (followedQuerysets)
+     */
+    async groupSync(queryset, operationId, dbSyncedKeys) {
+        if (isNil(queryset))
+            return;
+        const semanticKey = queryset.semanticKey;
+        const ModelClass = queryset.ModelClass;
+        // Convert dbSyncedKeys to semanticKeys if needed
+        const subset = new Set();
+        for (const item of dbSyncedKeys) {
+            subset.add(typeof item === 'string' ? item : item?.semanticKey);
+        }
+        // Find the dbSynced root
+        const { isRoot, root: rootKey } = this.querysetStoreGraph.findRoot(queryset, subset);
+        const iAmRoot = isRoot || rootKey === semanticKey;
+        // Get or create cache entry - whoever arrives first creates it
+        if (!this._groupSyncCache.has(operationId)) {
+            let resolve;
+            const promise = new Promise(r => { resolve = r; });
+            this._groupSyncCache.set(operationId, { promise, resolve, pks: null, ModelClass });
+            setTimeout(() => this._groupSyncCache.delete(operationId), 5000);
+        }
+        const cached = this._groupSyncCache.get(operationId);
+        const store = this._stores.get(semanticKey);
+        if (!store) {
+            console.warn(`[groupSync] No store found for queryset: ${semanticKey}`);
+            return;
+        }
+        if (iAmRoot) {
+            // I'm the root - sync from DB (store handles everything)
+            await store.sync();
+            cached.pks = store.groundTruthPks;
+            cached.resolve();
+        }
+        else {
+            // Wait for root to finish
+            await cached.promise;
+            // Filter from cached root data
+            const rootInstances = cached.pks.map(pk => ModelClass.fromPk(pk, queryset));
+            const ast = queryset.build();
+            const filteredPks = filter(rootInstances, ast, ModelClass, false);
+            // Set ground truth and clean up inflight ops (like sync does)
+            store.setGroundTruth(filteredPks);
+            store.setOperations(store.getInflightOperations());
+            store.lastSync = Date.now();
+        }
+    }
 }
 export const querysetStoreRegistry = new QuerysetStoreRegistry();

package/dist/syncEngine/stores/operationEventHandlers.js

@@ -7,27 +7,19 @@ import { QuerySet } from '../../flavours/django/querySet.js';
 import { isEqual, isNil } from 'lodash-es';
 import hash from 'object-hash';
 /**
- * Returns querysets that are in root mode (materialized with no materialized parent)
- * Since filtered querysets render by filtering their parent's data, we only need
- * to route operations to root querysets. Filtered children will see the operations
- * when they filter their parent's rendered data.
+ * Returns all querysets (stores) for the same model.
+ * Each queryset has its own ground truth and applies local filtering.
  * @param {QuerySet} queryset
  * @returns {Map<QuerySet, Store>}
  */
-function getRootQuerysets(queryset) {
+function getAllQuerysets(queryset) {
     const modelClass = queryset.ModelClass;
     const result = new Map();
-    // Route only to querysets that are in root mode
-    // Note: _stores is Map<semanticKey, Store>, so we get the queryset from store.queryset
+    // Route to all stores for this model
     Array.from(querysetStoreRegistry._stores.entries()).forEach(([semanticKey, store]) => {
         if (store.modelClass !== modelClass)
             return;
-        // Use the graph to determine if this store is in root mode
-        const { isRoot, root } = querysetStoreRegistry.querysetStoreGraph.findRoot(store.queryset);
-        // A queryset is in root mode if isRoot=true and root is its own semantic key
-        if (isRoot && root === store.queryset.semanticKey) {
-            result.set(store.queryset, store);
-        }
+        result.set(store.queryset, store);
     });
     return result;
 }
@@ -85,29 +77,29 @@ function processQuerysetStores(operation, actionType) {
         }
     };
     let querysetStoreMap;
-    // Different routing strategies based on operation type
+    // Route to all querysets for the model - each applies local filtering
     switch (operation.type) {
         case Type.CREATE:
         case Type.BULK_CREATE:
         case Type.GET_OR_CREATE:
         case Type.UPDATE_OR_CREATE:
-            // For creates, route to root querysets (they might want to include the new item)
-            querysetStoreMap = getRootQuerysets(queryset);
+            // For creates, route to all querysets (each checks if new item matches its filter)
+            querysetStoreMap = getAllQuerysets(queryset);
             break;
         case Type.UPDATE:
         case Type.UPDATE_INSTANCE:
         case Type.DELETE:
         case Type.DELETE_INSTANCE:
-            // No need to do anything, the model will change the queryset local filtering will handle it
+            // Model store handles the change, querysets re-render via local filtering
             querysetStoreMap = new Map();
             break;
         case Type.CHECKPOINT:
-            // No need to do anything, the model will change the queryset local filtering will handle it
+            // Model store handles the change, querysets re-render via local filtering
             querysetStoreMap = new Map();
             break;
         default:
-            // For other operation types, use the existing root querysets logic
-            querysetStoreMap = getRootQuerysets(queryset);
+            // For other operation types, route to all querysets
+            querysetStoreMap = getAllQuerysets(queryset);
             break;
     }
     Array.from(querysetStoreMap.values()).forEach(applyAction);