@statezero/core 0.1.37 → 0.1.39

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/flavours/django/model.d.ts

@@ -35,6 +35,14 @@ export class Model {
      * @throws {ValidationError} If an unknown key is found.
      */
     static validateFields(data: Object): void;
+    /**
+     * Static method to validate data without creating an instance
+     * @param {Object} data - Data to validate
+     * @param {string} validateType - 'create' or 'update'
+     * @param {boolean} partial - Whether to allow partial validation
+     * @returns {Promise<boolean>} Promise that resolves to true if valid, throws error if invalid
+     */
+    static validate(data: Object, validateType?: string, partial?: boolean): Promise<boolean>;
     constructor(data?: {});
     _data: {};
     _pk: any;
@@ -105,6 +113,13 @@ export class Model {
      * @throws {Error} If the instance has not been saved (no primary key).
      */
     refreshFromDb(): Promise<void>;
+    /**
+     * Validates the model instance using the same serialize behavior as save()
+     * @param {string} validateType - 'create' or 'update' (defaults to auto-detect)
+     * @param {boolean} partial - Whether to allow partial validation
+     * @returns {Promise<boolean>} Promise that resolves to true if valid, throws error if invalid
+     */
+    validate(validateType?: string, partial?: boolean): Promise<boolean>;
 }
 /**
  * A constructor for a Model.

package/dist/flavours/django/model.js

@@ -10,6 +10,9 @@ import { QueryExecutor } from "./queryExecutor";
 import { wrapReactiveModel } from "../../reactiveAdaptor.js";
 import { DateParsingHelpers } from "./dates.js";
 import { FileObject } from './files.js';
+import { configInstance } from "../../config.js";
+import { parseStateZeroError, MultipleObjectsReturned, DoesNotExist, } from "./errors.js";
+import axios from "axios";
 /**
  * A constructor for a Model.
  *
@@ -292,6 +295,74 @@ export class Model {
         // clear the current data and fresh data will flow
         this._data = {};
     }
+    /**
+     * Validates the model instance using the same serialize behavior as save()
+     * @param {string} validateType - 'create' or 'update' (defaults to auto-detect)
+     * @param {boolean} partial - Whether to allow partial validation
+     * @returns {Promise<boolean>} Promise that resolves to true if valid, throws error if invalid
+     */
+    async validate(validateType = null, partial = false) {
+        const ModelClass = this.constructor;
+        if (!validateType) {
+            validateType = this.pk ? "update" : "create";
+        }
+        // Validate the validateType parameter
+        if (!["update", "create"].includes(validateType)) {
+            throw new Error(`Validation type must be 'update' or 'create', not '${validateType}'`);
+        }
+        // Use the same serialize logic as save()
+        const data = this.serialize();
+        // Delegate to static method
+        return ModelClass.validate(data, validateType, partial);
+    }
+    /**
+     * Static method to validate data without creating an instance
+     * @param {Object} data - Data to validate
+     * @param {string} validateType - 'create' or 'update'
+     * @param {boolean} partial - Whether to allow partial validation
+     * @returns {Promise<boolean>} Promise that resolves to true if valid, throws error if invalid
+     */
+    static async validate(data, validateType = "create", partial = false) {
+        const ModelClass = this;
+        // Validate the validateType parameter
+        if (!["update", "create"].includes(validateType)) {
+            throw new Error(`Validation type must be 'update' or 'create', not '${validateType}'`);
+        }
+        // Get backend config and check if it exists
+        const config = configInstance.getConfig();
+        const backend = config.backendConfigs[ModelClass.configKey];
+        if (!backend) {
+            throw new Error(`No backend configuration found for key: ${ModelClass.configKey}`);
+        }
+        // Build URL for validate endpoint
+        const baseUrl = backend.API_URL.replace(/\/+$/, "");
+        const url = `${baseUrl}/${ModelClass.modelName}/validate/`;
+        // Prepare headers
+        const headers = {
+            "Content-Type": "application/json",
+            ...(backend.getAuthHeaders ? backend.getAuthHeaders() : {}),
+        };
+        // Make direct API call to validate endpoint
+        try {
+            const response = await axios.post(url, {
+                data: data,
+                validate_type: validateType,
+                partial: partial,
+            }, { headers });
+            // Backend returns {"valid": true} on success
+            return response.data.valid === true;
+        }
+        catch (error) {
+            if (error.response && error.response.data) {
+                const parsedError = parseStateZeroError(error.response.data);
+                if (Error.captureStackTrace) {
+                    Error.captureStackTrace(parsedError, ModelClass.validate);
+                }
+                throw parsedError;
+            }
+            throw new Error(`Validation failed: ${error.message}`);
+        }
+    }
 }
 /**
  * Creates a new Model instance.

package/package.json

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