@statezero/core 0.1.24 → 0.1.26

package/dist/flavours/django/dates.js

@@ -23,7 +23,7 @@ export class DateParsingHelpers {
         // Get field-specific format from schema
         const formatStrings = {
             'date': schema.date_format,
-            'datetime': schema.datetime_format
+            'date-time': schema.datetime_format
         };
         const dateFormat = formatStrings[fieldFormat];
         // Check if format is supported
@@ -56,13 +56,13 @@ export class DateParsingHelpers {
             return date;
         }
         const fieldFormat = schema.properties[fieldName].format;
-        if (!["date", "datetime"].includes(fieldFormat)) {
+        if (!["date", "date-time"].includes(fieldFormat)) {
             throw new Error(`Only date and date-time fields can be processed to JS date objects. ${fieldName} has format ${fieldFormat}`);
         }
         // Get field-specific format from schema
         const formatStrings = {
             'date': schema.date_format,
-            'datetime': schema.datetime_format
+            'date-time': schema.datetime_format
         };
         const dateFormat = formatStrings[fieldFormat];
         // Check if format is supported

package/dist/flavours/django/model.js

@@ -89,6 +89,14 @@ export class Model {
             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 &&
@@ -191,6 +199,14 @@ export class Model {
             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;
     }
     /**

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

@@ -7,6 +7,7 @@ export class ModelStore {
     isSyncing: boolean;
     pruneThreshold: any;
     modelCache: Cache;
+    _lastRenderedData: Map<any, any>;
     /**
      * 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

@@ -1,12 +1,22 @@
 import { Operation, Status, Type, operationRegistry } from './operation.js';
-import { isNil, isEmpty, trim } from 'lodash-es';
+import { isNil, isEmpty, trim, isEqual } from 'lodash-es';
 import { modelEventEmitter } from './reactivity.js';
 import { Cache } from '../cache/cache.js';
 import { replaceTempPks, containsTempPk } from '../../flavours/django/tempPk.js';
-const emitEvents = (modelClass, events) => {
-    // helper method to emit every event
-    events.forEach(event => {
-        modelEventEmitter.emit(`${modelClass.configKey}::${modelClass.modelName}::render`, event);
+const emitEvents = (store, events) => {
+    if (!Array.isArray(events))
+        return;
+    events.forEach((event) => {
+        const pk = event.pk;
+        if (isNil(pk))
+            return;
+        const newRenderedDataArray = store.render([pk], true);
+        const newRenderedData = newRenderedDataArray.length > 0 ? newRenderedDataArray[0] : null;
+        const lastRenderedData = store._lastRenderedData.get(pk);
+        if (!isEqual(newRenderedData, lastRenderedData)) {
+            store._lastRenderedData.set(pk, newRenderedData);
+            modelEventEmitter.emit(`${store.modelClass.configKey}::${store.modelClass.modelName}::render`, event);
+        }
     });
 };
 class EventData {
@@ -62,6 +72,7 @@ export class ModelStore {
             this._loadOperations(initialOperations);
         }
         this.modelCache = new Cache('model-cache', {}, this.onHydrated.bind(this));
+        this._lastRenderedData = new Map();
     }
     /**
      * Load operations from data and add them to the operations map,
@@ -164,26 +175,26 @@ export class ModelStore {
         if (this.operationsMap.size > this.pruneThreshold) {
             this.prune();
         }
-        emitEvents(this.modelClass, EventData.fromOperation(operation));
+        emitEvents(this, EventData.fromOperation(operation));
     }
     updateOperation(operation) {
         if (!this.operationsMap.has(operation.operationId))
             return false;
         this.operationsMap.set(operation.operationId, operation);
-        emitEvents(this.modelClass, EventData.fromOperation(operation));
+        emitEvents(this, EventData.fromOperation(operation));
         return true;
     }
     confirm(operation) {
         if (!this.operationsMap.has(operation.operationId))
             return;
         this.operationsMap.set(operation.operationId, operation);
-        emitEvents(this.modelClass, EventData.fromOperation(operation));
+        emitEvents(this, EventData.fromOperation(operation));
     }
     reject(operation) {
         if (!this.operationsMap.has(operation.operationId))
             return;
         this.operationsMap.set(operation.operationId, operation);
-        emitEvents(this.modelClass, EventData.fromOperation(operation));
+        emitEvents(this, EventData.fromOperation(operation));
     }
     setOperations(operations = []) {
         const prevOps = this.operations;
@@ -192,7 +203,7 @@ export class ModelStore {
             this.operationsMap.set(op.operationId, op);
         });
         const allOps = [...prevOps, ...this.operations];
-        emitEvents(this.modelClass, EventData.fromOperations(allOps));
+        emitEvents(this, EventData.fromOperations(allOps));
     }
     // Ground truth data methods
     setGroundTruth(groundTruth) {
@@ -200,7 +211,7 @@ export class ModelStore {
         this.groundTruthArray = Array.isArray(groundTruth) ? groundTruth : [];
         // reactivity - gather all ops
         const allOps = [...prevGroundTruth, ...this.groundTruthArray];
-        emitEvents(this.modelClass, EventData.fromInstances(allOps, this.modelClass));
+        emitEvents(this, EventData.fromInstances(allOps, this.modelClass));
     }
     getGroundTruth() {
         return this.groundTruthArray;
@@ -263,7 +274,7 @@ export class ModelStore {
             console.log(`[ModelStore ${this.modelClass.modelName}] Created CHECKPOINT operation for ${checkpointInstances.length} existing instances`);
         }
         // reactivity - use all the newly added instances (both new and updated)
-        emitEvents(this.modelClass, EventData.fromInstances([...checkpointInstances, ...Array.from(pkMap.values())], this.modelClass));
+        emitEvents(this, EventData.fromInstances([...checkpointInstances, ...Array.from(pkMap.values())], this.modelClass));
     }
     _filteredOperations(pks, operations) {
         if (!pks)

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

@@ -12,6 +12,10 @@ export class QuerysetStore {
     pruneThreshold: any;
     getRootStore: any;
     qsCache: Cache;
+    _lastRenderedPks: any[] | null;
+    renderCallbacks: Set<any>;
+    _rootUnregister: any;
+    _currentRootStore: any;
     get cacheKey(): any;
     onHydrated(hydratedData: any): void;
     setCache(result: any): void;
@@ -29,6 +33,8 @@ export class QuerysetStore {
     getTrimmedOperations(): any[];
     getInflightOperations(): any[];
     prune(): void;
+    registerRenderCallback(callback: any): () => boolean;
+    _ensureRootRegistration(): void;
     render(optimistic?: boolean, fromCache?: boolean): any[];
     renderFromRoot(optimistic: boolean | undefined, rootStore: any): any[];
     renderFromData(optimistic?: boolean): any[];

package/dist/syncEngine/stores/querysetStore.js

@@ -1,6 +1,6 @@
 import { Operation, Status, Type, operationRegistry } from './operation.js';
 import { querysetEventEmitter } from './reactivity.js';
-import { isNil, isEmpty, trim } from 'lodash-es';
+import { isNil, isEmpty, trim, isEqual } from 'lodash-es';
 import { replaceTempPks, containsTempPk } from '../../flavours/django/tempPk.js';
 import { modelStoreRegistry } from '../registries/modelStoreRegistry.js';
 import { processIncludedEntities } from '../../flavours/django/makeApiCall.js';
@@ -29,6 +29,11 @@ export class QuerysetStore {
             }
         }
         this.qsCache = new Cache("queryset-cache", {}, this.onHydrated.bind(this));
+        this._lastRenderedPks = null;
+        this.renderCallbacks = new Set();
+        this._rootUnregister = null;
+        this._currentRootStore = null;
+        this._ensureRootRegistration();
     }
     // Caching
     get cacheKey() {
@@ -70,7 +75,20 @@ export class QuerysetStore {
         return new Set(this.groundTruthPks);
     }
     _emitRenderEvent() {
-        querysetEventEmitter.emit(`${this.modelClass.configKey}::${this.modelClass.modelName}::queryset::render`, { ast: this.queryset.build(), ModelClass: this.modelClass });
+        const newPks = this.render(true, false); // Get current state without using cache
+        // Directly compare PK lists. isEqual performs a deep, order-sensitive comparison.
+        if (!isEqual(newPks, this._lastRenderedPks)) {
+            this._lastRenderedPks = newPks; // Update the cache with the new state
+            querysetEventEmitter.emit(`${this.modelClass.configKey}::${this.modelClass.modelName}::queryset::render`, { ast: this.queryset.build(), ModelClass: this.modelClass });
+            this.renderCallbacks.forEach((callback) => {
+                try {
+                    callback();
+                }
+                catch (error) {
+                    console.warn("Error in render callback:", error);
+                }
+            });
+        }
     }
     async addOperation(operation) {
         this.operationsMap.set(operation.operationId, operation);
@@ -124,7 +142,34 @@ export class QuerysetStore {
         this.setGroundTruth(renderedPks);
         this.setOperations(this.getInflightOperations());
     }
+    registerRenderCallback(callback) {
+        this.renderCallbacks.add(callback);
+        return () => this.renderCallbacks.delete(callback);
+    }
+    _ensureRootRegistration() {
+        if (this.isTemp)
+            return;
+        const { isRoot, rootStore } = this.getRootStore(this.queryset);
+        // If the root store hasn't changed, nothing to do
+        if (this._currentRootStore === rootStore) {
+            return;
+        }
+        // Root store changed - clean up old registration if it exists
+        if (this._rootUnregister) {
+            this._rootUnregister();
+            this._rootUnregister = null;
+        }
+        // Set up new registration if we're derived and have a root store
+        if (!isRoot && rootStore) {
+            this._rootUnregister = rootStore.registerRenderCallback(() => {
+                this._emitRenderEvent();
+            });
+        }
+        // Update current root store reference (could be null now)
+        this._currentRootStore = rootStore;
+    }
     render(optimistic = true, fromCache = false) {
+        this._ensureRootRegistration();
         if (fromCache) {
             const cachedResult = this.qsCache.get(this.cacheKey);
             if (Array.isArray(cachedResult)) {
@@ -132,7 +177,9 @@ export class QuerysetStore {
             }
         }
         let result;
-        if (this.getRootStore && typeof this.getRootStore === "function" && !this.isTemp) {
+        if (this.getRootStore &&
+            typeof this.getRootStore === "function" &&
+            !this.isTemp) {
             const { isRoot, rootStore } = this.getRootStore(this.queryset);
             if (!isRoot && rootStore && rootStore.lastSync) {
                 result = this.renderFromRoot(optimistic, rootStore);
@@ -201,7 +248,9 @@ export class QuerysetStore {
             return;
         }
         // Check if we're delegating to a root store
-        if (this.getRootStore && typeof this.getRootStore === "function" && !this.isTemp) {
+        if (this.getRootStore &&
+            typeof this.getRootStore === "function" &&
+            !this.isTemp) {
             const { isRoot, rootStore } = this.getRootStore(this.queryset);
             if (!isRoot && rootStore && rootStore.lastSync) {
                 // We're delegating to a root store - don't sync, just mark as needing sync

package/package.json

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