@statezero/core 0.1.38 → 0.1.41

package/dist/adaptors/vue/composables.js

@@ -1,9 +1,8 @@
-import { computed, getCurrentInstance, onBeforeUnmount } from "vue";
-import { querysetStoreRegistry } from "../../syncEngine/registries/querysetStoreRegistry";
-import { metricRegistry } from "../../syncEngine/registries/metricRegistry";
-import { syncManager } from "../../syncEngine/sync";
-import { wrappedQuerysetCache } from "./reactivity.js";
-import { v7 } from "uuid";
+import { computed, getCurrentInstance, onBeforeUnmount } from 'vue';
+import { querysetStoreRegistry } from '../../syncEngine/registries/querysetStoreRegistry';
+import { metricRegistry } from '../../syncEngine/registries/metricRegistry';
+import { syncManager } from '../../syncEngine/sync';
+import { v7 } from 'uuid';
 syncManager.followAllQuerysets = false;
 export const querysets = new Map(); // Map of composableId -> queryset
 function updateSyncManager() {
@@ -14,16 +13,11 @@ function updateSyncManager() {
 export function useQueryset(querysetFactory) {
     const instance = getCurrentInstance();
     if (!instance) {
-        throw new Error("useQueryset must be called within a component setup function");
+        throw new Error('useQueryset must be called within a component setup function');
     }
     const composableId = v7();
     let lastQueryset = null;
     onBeforeUnmount(() => {
-        // Clear cache when component unmounts
-        if (lastQueryset?.semanticKey &&
-            wrappedQuerysetCache.has(lastQueryset.semanticKey)) {
-            wrappedQuerysetCache.delete(lastQueryset.semanticKey);
-        }
         querysets.delete(composableId);
         updateSyncManager();
     });
@@ -33,12 +27,6 @@ export function useQueryset(querysetFactory) {
         const queryset = original?.queryset || original;
         // Only update if queryset actually changed
         if (lastQueryset !== queryset) {
-            // Clear cache for previous queryset if it changed
-            if (lastQueryset?.semanticKey &&
-                lastQueryset !== queryset &&
-                wrappedQuerysetCache.has(lastQueryset.semanticKey)) {
-                wrappedQuerysetCache.delete(lastQueryset.semanticKey);
-            }
             querysets.set(composableId, queryset);
             updateSyncManager();
             lastQueryset = queryset;

package/dist/adaptors/vue/reactivity.d.ts

@@ -16,4 +16,3 @@ export function ModelAdaptor(modelInstance: Object, reactivityFn?: Function): an
  */
 export function QuerySetAdaptor(liveQuerySet: Object, reactivityFn?: Function): any | import("vue").Ref;
 export function MetricAdaptor(metric: any): any;
-export const wrappedQuerysetCache: Map<any, any>;

package/dist/adaptors/vue/reactivity.js

@@ -123,4 +123,3 @@ export function MetricAdaptor(metric) {
     }
     return wrapper;
 }
-export { wrappedQuerysetCache };

package/dist/syncEngine/registries/querysetStoreRegistry.js

@@ -102,7 +102,7 @@ export class LiveQueryset {
      * @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();
@@ -113,9 +113,7 @@ export class LiveQueryset {
             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();

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

@@ -8,6 +8,8 @@ export class ModelStore {
     pruneThreshold: any;
     modelCache: Cache;
     _lastRenderedData: Map<any, any>;
+    renderCallbacks: Set<any>;
+    registerRenderCallback(callback: any): () => boolean;
     /**
      * 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

@@ -16,6 +16,14 @@ const emitEvents = (store, events) => {
         if (!isEqual(newRenderedData, lastRenderedData)) {
             store._lastRenderedData.set(pk, newRenderedData);
             modelEventEmitter.emit(`${store.modelClass.configKey}::${store.modelClass.modelName}::render`, event);
+            store.renderCallbacks.forEach((callback) => {
+                try {
+                    callback();
+                }
+                catch (error) {
+                    console.warn("Error in model store render callback:", error);
+                }
+            });
         }
     });
 };
@@ -71,15 +79,20 @@ export class ModelStore {
         if (initialOperations && initialOperations.length > 0) {
             this._loadOperations(initialOperations);
         }
-        this.modelCache = new Cache('model-cache', {}, this.onHydrated.bind(this));
+        this.modelCache = new Cache("model-cache", {}, this.onHydrated.bind(this));
         this._lastRenderedData = new Map();
+        this.renderCallbacks = new Set();
+    }
+    registerRenderCallback(callback) {
+        this.renderCallbacks.add(callback);
+        return () => this.renderCallbacks.delete(callback);
     }
     /**
      * Load operations from data and add them to the operations map,
      * reusing existing operations from the registry if they exist
      */
     _loadOperations(operationsData) {
-        operationsData.forEach(opData => {
+        operationsData.forEach((opData) => {
             const existingOp = operationRegistry.get(opData.operationId);
             if (existingOp) {
                 // If the operation exists in the registry, use it
@@ -109,7 +122,7 @@ export class ModelStore {
         let nonTempPkItems = [];
         result.forEach((item) => {
             let pk = item[pkField];
-            if (typeof pk === 'string' && containsTempPk(pk)) {
+            if (typeof pk === "string" && containsTempPk(pk)) {
                 pk = replaceTempPks(item[pkField]);
                 if (isNil(pk) || isEmpty(trim(pk))) {
                     return;
@@ -128,7 +141,7 @@ export class ModelStore {
         let nonTempPkItems = [];
         items.forEach((item) => {
             let pk = item[pkField];
-            if (typeof pk === 'string' && containsTempPk(pk)) {
+            if (typeof pk === "string" && containsTempPk(pk)) {
                 pk = replaceTempPks(item[pkField]);
                 if (isNil(pk) || isEmpty(trim(pk))) {
                     return;
@@ -145,16 +158,16 @@ export class ModelStore {
         // Otherwise, we're rendering specific items - update only those items
         const currentCache = this.modelCache.get(this.cacheKey) || [];
         // Filter out items that were requested but not in the result (they were deleted)
-        const filteredCache = currentCache.filter(item => item &&
-            typeof item === 'object' &&
+        const filteredCache = currentCache.filter((item) => item &&
+            typeof item === "object" &&
             pkField in item &&
             (!requestedPks.has(item[pkField]) ||
-                nonTempPkItems.some(newItem => newItem[pkField] === item[pkField])));
+                nonTempPkItems.some((newItem) => newItem[pkField] === item[pkField])));
         // Create a map for faster lookups
-        const cacheMap = new Map(filteredCache.map(item => [item[pkField], item]));
+        const cacheMap = new Map(filteredCache.map((item) => [item[pkField], item]));
         // Add or update items from the result
         for (const item of nonTempPkItems) {
-            if (item && typeof item === 'object' && pkField in item) {
+            if (item && typeof item === "object" && pkField in item) {
                 cacheMap.set(item[pkField], item);
             }
         }
@@ -199,7 +212,7 @@ export class ModelStore {
     setOperations(operations = []) {
         const prevOps = this.operations;
         this.operationsMap.clear();
-        operations.forEach(op => {
+        operations.forEach((op) => {
             this.operationsMap.set(op.operationId, op);
         });
         const allOps = [...prevOps, ...this.operations];
@@ -219,16 +232,16 @@ export class ModelStore {
     get groundTruthPks() {
         const pk = this.pkField;
         return this.groundTruthArray
-            .filter(instance => instance && typeof instance === 'object' && pk in instance)
-            .map(instance => instance[pk]);
+            .filter((instance) => instance && typeof instance === "object" && pk in instance)
+            .map((instance) => instance[pk]);
     }
     addToGroundTruth(instances) {
         if (!Array.isArray(instances) || instances.length === 0)
             return;
         const pkField = this.pkField;
         const pkMap = new Map();
-        instances.forEach(inst => {
-            if (inst && typeof inst === 'object' && pkField in inst) {
+        instances.forEach((inst) => {
+            if (inst && typeof inst === "object" && pkField in inst) {
                 pkMap.set(inst[pkField], inst);
             }
             else {
@@ -241,7 +254,9 @@ export class ModelStore {
         const processedPks = new Set();
         const checkpointInstances = []; // Track instances that need CHECKPOINT operations
         for (const existingItem of this.groundTruthArray) {
-            if (!existingItem || typeof existingItem !== 'object' || !(pkField in existingItem)) {
+            if (!existingItem ||
+                typeof existingItem !== "object" ||
+                !(pkField in existingItem)) {
                 continue;
             }
             const pk = existingItem[pkField];
@@ -263,12 +278,14 @@ export class ModelStore {
         // Create CHECKPOINT operation for instances that already existed
         if (checkpointInstances.length > 0) {
             const checkpointOperation = new Operation({
-                operationId: `checkpoint_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+                operationId: `checkpoint_${Date.now()}_${Math.random()
+                    .toString(36)
+                    .substr(2, 9)}`,
                 type: Type.CHECKPOINT,
                 instances: checkpointInstances,
                 status: Status.CONFIRMED,
                 timestamp: Date.now(),
-                queryset: this.modelClass.objects.all()
+                queryset: this.modelClass.objects.all(),
             });
             this.operationsMap.set(checkpointOperation.operationId, checkpointOperation);
             console.log(`[ModelStore ${this.modelClass.modelName}] Created CHECKPOINT operation for ${checkpointInstances.length} existing instances`);
@@ -282,7 +299,7 @@ export class ModelStore {
         const pkField = this.pkField;
         let filteredOps = [];
         for (const op of operations) {
-            let relevantInstances = op.instances.filter(instance => pks.has(instance[pkField] || instance));
+            let relevantInstances = op.instances.filter((instance) => pks.has(instance[pkField] || instance));
             if (relevantInstances.length > 0) {
                 filteredOps.push({
                     operationId: op.operationId,
@@ -291,7 +308,7 @@ export class ModelStore {
                     queryset: op.queryset,
                     type: op.type,
                     status: op.status,
-                    args: op.args
+                    args: op.args,
                 });
             }
         }
@@ -301,7 +318,7 @@ export class ModelStore {
         const pkField = this.pkField;
         let groundTruthMap = new Map();
         for (const instance of groundTruthArray) {
-            if (!instance || typeof instance !== 'object' || !(pkField in instance)) {
+            if (!instance || typeof instance !== "object" || !(pkField in instance)) {
                 continue;
             }
             const pk = instance[pkField];
@@ -314,7 +331,7 @@ export class ModelStore {
     applyOperation(operation, currentInstances) {
         const pkField = this.pkField;
         for (const instance of operation.instances) {
-            if (!instance || typeof instance !== 'object' || !(pkField in instance)) {
+            if (!instance || typeof instance !== "object" || !(pkField in instance)) {
                 console.warn(`[ModelStore ${this.modelClass.modelName}] Skipping instance ${instance} in operation ${operation.operationId} during applyOperation due to missing PK field '${String(pkField)}' or invalid format.`);
                 continue;
             }
@@ -333,9 +350,9 @@ export class ModelStore {
                         currentInstances.set(pk, { ...existing, ...instance });
                     }
                     else {
-                        const wasDeletedLocally = this.operations.some(op => op.type === Type.DELETE &&
+                        const wasDeletedLocally = this.operations.some((op) => op.type === Type.DELETE &&
                             op.status !== Status.REJECTED &&
-                            op.instances.some(inst => inst && inst[pkField] === pk));
+                            op.instances.some((inst) => inst && inst[pkField] === pk));
                         if (!wasDeletedLocally) {
                             currentInstances.set(pk, instance);
                         }
@@ -354,10 +371,10 @@ export class ModelStore {
     }
     getTrimmedOperations() {
         const twoMinutesAgo = Date.now() - 1000 * 60 * 2;
-        return this.operations.filter(operation => operation.timestamp > twoMinutesAgo);
+        return this.operations.filter((operation) => operation.timestamp > twoMinutesAgo);
     }
     getInflightOperations() {
-        return this.operations.filter(operation => operation.status != Status.CONFIRMED &&
+        return this.operations.filter((operation) => operation.status != Status.CONFIRMED &&
             operation.status != Status.REJECTED);
     }
     // Pruning
@@ -369,12 +386,16 @@ export class ModelStore {
     }
     // Render methods
     render(pks = null, optimistic = true) {
-        const pksSet = pks === null ? null :
-            (pks instanceof Set ? pks : new Set(Array.isArray(pks) ? pks : [pks]));
+        const pksSet = pks === null
+            ? null
+            : pks instanceof Set
+                ? pks
+                : new Set(Array.isArray(pks) ? pks : [pks]);
         const renderedInstancesMap = this._filteredGroundTruth(pksSet, this.groundTruthArray);
         const relevantOperations = this._filteredOperations(pksSet, this.operations);
         for (const op of relevantOperations) {
-            if (op.status !== Status.REJECTED && (optimistic || op.status === Status.CONFIRMED)) {
+            if (op.status !== Status.REJECTED &&
+                (optimistic || op.status === Status.CONFIRMED)) {
                 this.applyOperation(op, renderedInstancesMap);
             }
         }
@@ -397,7 +418,10 @@ export class ModelStore {
                 this.setOperations(trimmedOps);
                 return;
             }
-            const newGroundTruth = await this.fetchFn({ pks: currentPks, modelClass: this.modelClass });
+            const newGroundTruth = await this.fetchFn({
+                pks: currentPks,
+                modelClass: this.modelClass,
+            });
             if (pks) {
                 this.addToGroundTruth(newGroundTruth);
                 return;

package/dist/syncEngine/stores/operationEventHandlers.js

@@ -35,38 +35,6 @@ function relatedQuerysets(queryset) {
     });
     return result;
 }
-/**
- * Returns querysets that contain any of the specified instances
- * @param {Operation} operation - The operation containing instances to check
- * @returns {Map<QuerySet, Store>}
- */
-function querysetsContainingInstances(operation) {
-    const ModelClass = operation.queryset.ModelClass;
-    const pkField = ModelClass.primaryKeyField;
-    const instancePks = new Set(operation.instances
-        .filter(instance => instance && typeof instance === 'object' && pkField in instance)
-        .map(instance => instance[pkField]));
-    if (instancePks.size === 0) {
-        return new Map();
-    }
-    const result = new Map();
-    Array.from(querysetStoreRegistry._stores.entries()).forEach(([queryset, store]) => {
-        if (store.modelClass !== ModelClass)
-            return;
-        try {
-            // Check if this queryset contains any of the instances
-            const renderedPks = new Set(store.render(false)); // Get without optimistic updates
-            const hasIntersection = [...instancePks].some(pk => renderedPks.has(pk));
-            if (hasIntersection) {
-                result.set(store.queryset, store);
-            }
-        }
-        catch (e) {
-            console.warn('Error checking queryset for instances', e);
-        }
-    });
-    return result;
-}
 /**
  * Process an operation in the model store
  *
@@ -133,12 +101,12 @@ function processQuerysetStores(operation, actionType) {
         case Type.UPDATE_INSTANCE:
         case Type.DELETE:
         case Type.DELETE_INSTANCE:
-            // For updates and deletes, only route to querysets that actually contain the instances
-            querysetStoreMap = querysetsContainingInstances(operation);
+            // No need to do anything, the model will change the queryset local filtering will handle it
+            querysetStoreMap = new Map();
             break;
         case Type.CHECKPOINT:
-            // For checkpoints, route to querysets that contain the instances
-            querysetStoreMap = querysetsContainingInstances(operation);
+            // No need to do anything, the model will change the queryset local filtering will handle it
+            querysetStoreMap = new Map();
             break;
         default:
             // For other operation types, use the existing related querysets logic

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

@@ -16,6 +16,7 @@ export class QuerysetStore {
     renderCallbacks: Set<any>;
     _rootUnregister: any;
     _currentRootStore: any;
+    _modelStoreUnregister: any;
     get cacheKey(): any;
     onHydrated(hydratedData: any): void;
     setCache(result: any): void;
@@ -35,6 +36,12 @@ export class QuerysetStore {
     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[];

package/dist/syncEngine/stores/querysetStore.js

@@ -34,6 +34,10 @@ export class QuerysetStore {
         this._rootUnregister = null;
         this._currentRootStore = null;
         this._ensureRootRegistration();
+        const modelStore = modelStoreRegistry.getStore(this.modelClass);
+        this._modelStoreUnregister = modelStore.registerRenderCallback(() => {
+            this._emitRenderEvent();
+        });
     }
     // Caching
     get cacheKey() {
@@ -170,6 +174,21 @@ export class QuerysetStore {
         // Update current root store reference (could be null now)
         this._currentRootStore = rootStore;
     }
+    /**
+     * Helper to validate PKs against the model store and apply local filtering/sorting.
+     * This is the core of the rendering logic.
+     * @private
+     */
+    _getValidatedAndFilteredPks(pks) {
+        // 1. Convert PKs to instances, filtering out any that are null (deleted).
+        const instances = Array.from(pks)
+            .map((pk) => this.modelClass.fromPk(pk, this.queryset))
+            .filter((instance) => modelStoreRegistry.getEntity(this.modelClass, instance.pk) !== null);
+        // 2. Apply the queryset's AST (filters, ordering) to the validated instances.
+        const ast = this.queryset.build();
+        const finalPks = filter(instances, ast, this.modelClass, false); // false = return PKs
+        return finalPks;
+    }
     render(optimistic = true, fromCache = false) {
         this._ensureRootRegistration();
         if (fromCache) {
@@ -178,18 +197,19 @@ export class QuerysetStore {
                 return cachedResult;
             }
         }
-        let result;
+        let pks;
         if (this.getRootStore &&
             typeof this.getRootStore === "function" &&
             !this.isTemp) {
             const { isRoot, rootStore } = this.getRootStore(this.queryset);
             if (!isRoot && rootStore) {
-                result = this.renderFromRoot(optimistic, rootStore);
+                pks = this.renderFromRoot(optimistic, rootStore);
             }
         }
-        if (isNil(result)) {
-            result = this.renderFromData(optimistic);
+        if (isNil(pks)) {
+            pks = this.renderFromData(optimistic);
         }
+        let result = this._getValidatedAndFilteredPks(pks);
         let limit = this.queryset.build().serializerOptions?.limit;
         if (limit) {
             result = result.slice(0, limit);

package/package.json

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