@statezero/core 0.1.25 → 0.1.27

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/registries/querysetStoreGraph.js

@@ -29,7 +29,9 @@ export class QuerysetStoreGraph {
             if (current.__parent) {
                 const parentKey = current.__parent.semanticKey;
                 this.graph.setNode(parentKey);
-                this.graph.setEdge(currentKey, parentKey); // child -> parent
+                if (currentKey !== parentKey) {
+                    this.graph.setEdge(currentKey, parentKey);
+                }
                 current = current.__parent;
             }
             else {

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

@@ -13,6 +13,9 @@ export class QuerysetStore {
     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;
@@ -30,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

@@ -30,6 +30,10 @@ 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() {
@@ -76,6 +80,14 @@ export class QuerysetStore {
         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) {
@@ -130,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)) {

package/package.json

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