@statezero/core 0.2.53 → 0.2.55

package/dist/syncEngine/stores/querysetStore.js

@@ -3,6 +3,7 @@ import { querysetEventEmitter } from './reactivity.js';
 import { isNil, isEmpty, trim, isEqual } from 'lodash-es';
 import { replaceTempPks, containsTempPk } from '../../flavours/django/tempPk.js';
 import { modelStoreRegistry } from '../registries/modelStoreRegistry.js';
+import { querysetStoreRegistry } from '../registries/querysetStoreRegistry.js';
 import { processIncludedEntities } from '../../flavours/django/makeApiCall.js';
 import { Cache } from '../cache/cache.js';
 import { filter } from "../../filtering/localFiltering.js";
@@ -14,6 +15,8 @@ export class QuerysetStore {
         this.queryset = queryset;
         this.isSyncing = false;
         this.lastSync = null;
+        this.lastHydrated = null;
+        this._createdAt = Date.now();
         this.isTemp = options.isTemp || false;
         this.pruneThreshold = options.pruneThreshold || 10;
         this.groundTruthPks = initialGroundTruthPks || [];
@@ -46,20 +49,22 @@ export class QuerysetStore {
         return this.queryset.semanticKey;
     }
     onHydrated(hydratedData) {
-        // Only use cached data if we haven't synced yet and have no ground truth.
-        // This prevents stale cache from overwriting real server data.
         if (this.lastSync !== null)
             return;
         if (this.groundTruthPks.length > 0 || this.operationsMap.size > 0)
             return;
         const cached = this.qsCache.get(this.cacheKey);
-        if (!isNil(cached) && !isEmpty(cached)) {
-            // Set ground truth WITHOUT updating lastSync — hydration is not a real sync
+        if (!isNil(cached)) {
             this.groundTruthPks = Array.isArray(cached) ? cached : [];
-            this._emitRenderEvent();
+            this.lastHydrated = Date.now();
+            if (cached.length > 0) {
+                this._emitRenderEvent();
+            }
         }
     }
     setCache(result) {
+        if (this.lastSync === null)
+            return;
         let nonTempPks = [];
         result.forEach((pk) => {
             if (typeof pk === "string" && containsTempPk(pk)) {
@@ -191,6 +196,56 @@ export class QuerysetStore {
         const finalPks = filter(instances, ast, this.modelClass, false); // false = return PKs
         return finalPks;
     }
+    /**
+     * For offset pages that aren't full, expand with creates from the model store
+     * that sort after the first item on the page (direction-adjusted).
+     */
+    _fillOffsetPage(currentPks, optimistic) {
+        const modelStore = modelStoreRegistry.getStore(this.modelClass);
+        if (!modelStore)
+            return null;
+        const orderBy = this.queryset._orderBy;
+        if (!orderBy || orderBy.length === 0)
+            return null;
+        // Get sort field and direction from first ordering field
+        const field = orderBy[0].replace(/^-/, '');
+        const isDesc = orderBy[0].startsWith('-');
+        // Get first item's sort value as the page boundary
+        const firstInstance = this.modelClass.fromPk(currentPks[0], this.queryset);
+        if (!firstInstance)
+            return null;
+        const boundary = firstInstance[field];
+        if (boundary == null)
+            return null;
+        // Find CREATE-type instances that sort into this page
+        const pkField = this.pkField;
+        const currentSet = new Set(currentPks);
+        const candidates = new Set(currentPks);
+        for (const op of modelStore.operations) {
+            if (op.status === Status.REJECTED)
+                continue;
+            if (!optimistic && op.status !== Status.CONFIRMED)
+                continue;
+            if (op.type !== Type.CREATE && op.type !== Type.BULK_CREATE &&
+                op.type !== Type.GET_OR_CREATE && op.type !== Type.UPDATE_OR_CREATE)
+                continue;
+            for (const inst of op.instances) {
+                if (!inst || inst[pkField] == null)
+                    continue;
+                if (currentSet.has(inst[pkField]))
+                    continue;
+                const val = inst[field];
+                if (val == null)
+                    continue;
+                const sortsAfter = isDesc ? val <= boundary : val >= boundary;
+                if (sortsAfter)
+                    candidates.add(inst[pkField]);
+            }
+        }
+        if (candidates.size === currentSet.size)
+            return null;
+        return this._getValidatedAndFilteredPks(Array.from(candidates));
+    }
     render(optimistic = true, fromCache = false) {
         // Check cache first if requested
         if (fromCache) {
@@ -210,32 +265,26 @@ export class QuerysetStore {
                 return cachedResult;
             }
         }
-        // If no ground truth AND hasn't been synced, render from model store
-        // This handles chained optimistic filters, newly created stores, etc.
-        // (If synced with empty results, that's valid ground truth)
-        // Skip model store seeding for paginated querysets (offset > 0) — the model
-        // store contains items from other pages, so seeding would show wrong results.
-        const offset = this.queryset.build().serializerOptions?.offset;
-        const canSeedFromModelStore = this.groundTruthPks.length === 0
-            && this.lastSync === null
-            && !(offset != null && offset > 0);
-        const pks = canSeedFromModelStore
-            ? this.renderFromModelStore()
-            : this.renderFromData(optimistic);
+        const pks = this.renderFromData(optimistic);
         // Validate against model store and apply local filtering/sorting
         let result = this._getValidatedAndFilteredPks(pks);
         const preLimitCount = result.length;
         // Apply pagination limit
         const limit = this.queryset.build().serializerOptions?.limit;
+        const hasOffset = (this.queryset._serializerOptions?.offset ?? 0) > 0;
+        // Offset page not full: fill with creates from model store that sort into this page
+        if (hasOffset && limit && result.length > 0 && result.length < limit) {
+            const expanded = this._fillOffsetPage(result, optimistic);
+            if (expanded)
+                result = expanded;
+        }
         if (limit) {
             result = result.slice(0, limit);
         }
         this.setCache(result);
         recordDebugEvent({
             type: "render",
-            source: this.groundTruthPks.length === 0 && this.lastSync === null
-                ? "modelStore"
-                : "groundTruth",
+            source: "groundTruth",
             semanticKey: this.queryset.semanticKey,
             modelName: this.modelClass.modelName,
             configKey: this.modelClass.configKey,
@@ -250,26 +299,79 @@ export class QuerysetStore {
         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);
+        const modelStore = modelStoreRegistry.getStore(this.modelClass);
+        // Temp stores: greedy seed from all model data (for op targeting, ignores pagination)
+        if (this.isTemp && this.lastSync === null && modelStore) {
+            const pkField = this.pkField;
+            return modelStore.render().map(inst => inst[pkField]).filter(pk => pk != null);
+        }
+        // Permanent never-synced and never-hydrated: seed from local data
+        if (!this.isTemp && this.lastSync === null && this.lastHydrated === null && modelStore) {
+            const hasOffset = (this.queryset._serializerOptions?.offset ?? 0) > 0;
+            if (!hasOffset) {
+                // No offset: seed from all model store data, filter handles membership
+                const pkField = this.pkField;
+                return modelStore.render().map(inst => inst[pkField]).filter(pk => pk != null);
+            }
+            // Offset: seed from root store if it's been synced
+            const { root: rootKey } = querysetStoreRegistry.querysetStoreGraph.findRoot(this.queryset);
+            const rootStore = rootKey ? querysetStoreRegistry._stores.get(rootKey) : null;
+            if (rootStore && rootStore !== this && rootStore.lastSync !== null) {
+                return rootStore.render();
             }
         }
-        let result = Array.from(renderedPks);
-        return result;
+        const hasOffset = (this.queryset._serializerOptions?.offset ?? 0) > 0;
+        // Offset querysets after sync: just ground truth.
+        // Filled pages shouldn't mix in local ops (makes mess).
+        // Last-page fill is handled by _fillOffsetPage in render().
+        if (hasOffset) {
+            return Array.from(this.groundTruthSet);
+        }
+        // No-offset: greedy — filtering is perfect, so include all fresh ops.
+        if (!modelStore || !this._hasRecentOps(modelStore)) {
+            return Array.from(this.groundTruthSet);
+        }
+        const freshPks = this._buildFreshPks(modelStore, optimistic);
+        const basePks = this.groundTruthSet;
+        for (const pk of freshPks)
+            basePks.add(pk);
+        return Array.from(basePks);
     }
-    /**
-     * Render by getting all instances from the model store and filtering locally.
-     * Used when a queryset has no ground truth (temp stores, newly created stores, etc.)
-     */
-    renderFromModelStore() {
-        const modelStore = modelStoreRegistry.getStore(this.modelClass);
-        const allPks = modelStore.groundTruthPks;
-        const allInstances = allPks.map((pk) => this.modelClass.fromPk(pk, this.queryset));
-        const ast = this.queryset.build();
-        return filter(allInstances, ast, this.modelClass, false);
+    /** Are there any inflight or recent confirmed ops in the model store? */
+    _hasRecentOps(modelStore) {
+        const ops = modelStore.operations;
+        const cutoff = this.lastSync ?? this._createdAt;
+        for (let i = ops.length - 1; i >= 0; i--) {
+            if (ops[i].status === Status.REJECTED)
+                continue;
+            // Inflight ops are always relevant (not yet in ground truth)
+            if (ops[i].status !== Status.CONFIRMED)
+                return true;
+            // Confirmed ops: only relevant if newer than last sync
+            return ops[i].timestamp >= cutoff;
+        }
+        return false;
+    }
+    /** Build set of PKs from ops newer than lastSync. Only used for no-offset querysets. */
+    _buildFreshPks(modelStore, optimistic) {
+        const freshPks = new Set();
+        const pkField = this.pkField;
+        const cutoff = this.lastSync ?? this._createdAt;
+        for (const op of modelStore.operations) {
+            if (op.status === Status.REJECTED)
+                continue;
+            if (!optimistic && op.status !== Status.CONFIRMED)
+                continue;
+            // Inflight ops always included (not yet in ground truth).
+            // Confirmed ops: skip if older than last sync (already in ground truth).
+            if (op.status === Status.CONFIRMED && op.timestamp < cutoff)
+                continue;
+            for (const inst of op.instances) {
+                if (inst && inst[pkField] != null)
+                    freshPks.add(inst[pkField]);
+            }
+        }
+        return freshPks;
     }
     applyOperation(operation, currentPks) {
         const pkField = this.pkField;
@@ -279,26 +381,9 @@ export class QuerysetStore {
                 continue;
             }
             let pk = instance[pkField];
-            switch (operation.type) {
-                case Type.CREATE:
-                case Type.BULK_CREATE:
-                    currentPks.add(pk);
-                    break;
-                case Type.CHECKPOINT:
-                    break;
-                case Type.UPDATE:
-                case Type.UPDATE_INSTANCE:
-                    // Add PKs as candidates so items can move into this queryset
-                    // when an update makes them match the filter.
-                    // _getValidatedAndFilteredPks will filter out non-matching items.
-                    currentPks.add(pk);
-                    break;
-                case Type.DELETE:
-                case Type.DELETE_INSTANCE:
-                    currentPks.delete(pk);
-                    break;
-                default:
-                    console.error(`[QuerysetStore ${this.modelClass.modelName}] Unknown operation type: ${operation.type}`);
+            // Only CREATE types add PKs. UPDATE/DELETE are handled by model store + refiltering.
+            if (CREATE_TYPES.has(operation.type)) {
+                currentPks.add(pk);
             }
         }
         return currentPks;

package/dist/syncEngine/sync.js

@@ -377,8 +377,8 @@ export class SyncManager {
                     entry.store.sync();
                     continue;
                 }
-                // Check if this queryset (or any parent) is being followed
-                if (this.isQuerysetFollowed(entry.queryset)) {
+                // Sync if the metric itself is followed, or its queryset is followed
+                if (registry.followedMetrics.has(key) || this.isQuerysetFollowed(entry.queryset)) {
                     entry.store.sync();
                 }
             }

package/package.json

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