@statezero/core 0.1.3-9.1 → 0.1.3-9.2

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

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() {

package/package.json

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