@statezero/core 0.1.53 → 0.1.55

package/dist/flavours/django/model.d.ts

@@ -44,7 +44,7 @@ export class Model {
      */
     static validate(data: Object, validateType?: string, partial?: boolean): Promise<boolean>;
     constructor(data?: {});
-    _data: {};
+    _data: any;
     _pk: any;
     __version: number;
     touch(): void;
@@ -60,6 +60,11 @@ export class Model {
      * @returns {number|undefined} The primary key.
      */
     get pk(): number | undefined;
+    /**
+     * STANDARDIZATION: Convert rich objects to plain JS data for internal storage
+     */
+    _standardizeIncomingData(data: any): any;
+    _standardizeFieldValue(field: any, value: any): any;
     /**
      * Gets a field value from the internal data store
      *
@@ -67,6 +72,14 @@ export class Model {
      * @returns {any} The field value
      */
     getField(field: string): any;
+    /**
+     * HYDRATION: Convert plain stored data back to rich objects
+     *
+     * @param {string} field - The field name
+     * @param {any} value - The plain stored value
+     * @returns {any} The hydrated rich object
+     */
+    _hydrateFieldValue(field: string, value: any): any;
     /**
      * Sets a field value in the internal data store
      *

package/dist/flavours/django/model.js

@@ -9,7 +9,7 @@ import { isNil } from "lodash-es";
 import { QueryExecutor } from "./queryExecutor";
 import { wrapReactiveModel } from "../../reactiveAdaptor.js";
 import { DateParsingHelpers } from "./dates.js";
-import { FileObject } from './files.js';
+import { FileObject } from "./files.js";
 import { configInstance } from "../../config.js";
 import { parseStateZeroError, MultipleObjectsReturned, DoesNotExist, } from "./errors.js";
 import axios from "axios";
@@ -32,8 +32,8 @@ import axios from "axios";
  */
 export class Model {
     constructor(data = {}) {
-        // Initialize internal data store
-        this._data = data;
+        // Initialize internal data store with standardized data
+        this._data = this._standardizeIncomingData(data);
         this._pk = data[this.constructor.primaryKeyField] || undefined;
         this.__version = 0;
         return wrapReactiveModel(this);
@@ -71,6 +71,48 @@ export class Model {
         }
         return this.instanceCache.get(key);
     }
+    /**
+     * STANDARDIZATION: Convert rich objects to plain JS data for internal storage
+     */
+    _standardizeIncomingData(data) {
+        if (!data || typeof data !== "object")
+            return data;
+        const standardized = {};
+        for (const [field, value] of Object.entries(data)) {
+            standardized[field] = this._standardizeFieldValue(field, value);
+        }
+        return standardized;
+    }
+    _standardizeFieldValue(field, value) {
+        if (isNil(value))
+            return value;
+        const ModelClass = this.constructor;
+        // Handle Date objects -> formatted strings
+        if (value instanceof Date) {
+            return DateParsingHelpers.serializeDate(value, field, ModelClass.schema);
+        }
+        // Handle FileObject -> simple file path/data
+        const fileFormats = ["file-path", "image-path"];
+        if (ModelClass.schema?.properties[field]?.format &&
+            fileFormats.includes(ModelClass.schema.properties[field].format) &&
+            value &&
+            typeof value.toJSON === "function") {
+            // Return a serializable JSON representation of the FileObject.
+            return value.toJSON();
+        }
+        // Handle Model instances -> primary keys
+        if (value &&
+            typeof value === "object" &&
+            value.constructor &&
+            value.constructor.primaryKeyField) {
+            return value.pk;
+        }
+        // Handle arrays (for many-to-many relationships)
+        if (Array.isArray(value)) {
+            return value.map((item) => this._standardizeFieldValue(field, item));
+        }
+        return value;
+    }
     /**
      * Gets a field value from the internal data store
      *
@@ -78,7 +120,6 @@ export class Model {
      * @returns {any} The field value
      */
     getField(field) {
-        var _a;
         // Access the reactive __version property to establish dependency for vue integration
         const trackVersion = this.__version;
         const ModelClass = this.constructor;
@@ -92,6 +133,21 @@ export class Model {
             if (storedValue)
                 value = storedValue[field]; // if stops null -> undefined
         }
+        // Convert plain stored data back to rich objects
+        return this._hydrateFieldValue(field, value);
+    }
+    /**
+     * HYDRATION: Convert plain stored data back to rich objects
+     *
+     * @param {string} field - The field name
+     * @param {any} value - The plain stored value
+     * @returns {any} The hydrated rich object
+     */
+    _hydrateFieldValue(field, value) {
+        var _a;
+        if (isNil(value))
+            return value;
+        const ModelClass = this.constructor;
         // Date/DateTime fields need special handling - convert to Date objects
         const dateFormats = ["date", "datetime", "date-time"];
         if (ModelClass.schema &&
@@ -105,10 +161,6 @@ export class Model {
         if (ModelClass.schema &&
             fileFormats.includes(ModelClass.schema.properties[field]?.format) &&
             value) {
-            // Check if it's already a FileObject
-            if (value instanceof FileObject) {
-                return value;
-            }
             // If it's stored file data from API, wrap it as FileObject
             if (typeof value === "object" && value.file_path) {
                 // Create anonymous subclass with correct configKey
@@ -152,11 +204,13 @@ export class Model {
      */
     setField(field, value) {
         const ModelClass = this.constructor;
+        // Standardize the value before storing
+        const standardizedValue = this._standardizeFieldValue(field, value);
         if (ModelClass.primaryKeyField === field) {
-            this._pk = value;
+            this._pk = standardizedValue;
         }
         else {
-            this._data[field] = value;
+            this._data[field] = standardizedValue;
         }
     }
     /**
@@ -202,20 +256,7 @@ 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);
-        }
-        const fileFormats = ["file-path", "image-path"];
-        if (ModelClass.schema &&
-            fileFormats.includes(ModelClass.schema.properties[field]?.format) &&
-            value) {
-            return value.filePath || value.file_path || value;
-        }
+        // Since internal data is already standardized, just return it
         return value;
     }
     /**

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

@@ -17,6 +17,11 @@ export class ModelStore {
     _loadOperations(operationsData: any): void;
     get cacheKey(): string;
     onHydrated(): void;
+    /**
+     * Convert raw data objects to standardized format for caching
+     * Creates temporary model instances to leverage the standardization logic
+     */
+    _standardizeForCache(items: any): any;
     setCache(result: any): void;
     clearCache(): void;
     updateCache(items: any, requestedPks: any): void;

package/dist/syncEngine/stores/modelStore.js

@@ -117,6 +117,18 @@ export class ModelStore {
             }
         }
     }
+    /**
+     * Convert raw data objects to standardized format for caching
+     * Creates temporary model instances to leverage the standardization logic
+     */
+    _standardizeForCache(items) {
+        return items.map((item) => {
+            // Create a temporary model instance with the raw data
+            const tempInstance = new this.modelClass(item);
+            // Use the serialize method to get standardized data
+            return tempInstance.serialize();
+        });
+    }
     setCache(result) {
         const pkField = this.pkField;
         let nonTempPkItems = [];
@@ -131,7 +143,8 @@ export class ModelStore {
             item[pkField] = pk;
             nonTempPkItems.push(item);
         });
-        this.modelCache.set(this.cacheKey, nonTempPkItems);
+        const standardizedItems = this._standardizeForCache(nonTempPkItems);
+        this.modelCache.set(this.cacheKey, standardizedItems);
     }
     clearCache() {
         this.modelCache.delete(this.cacheKey);

package/package.json

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