@statezero/core 0.1.90 → 0.1.92

package/dist/filtering/localFiltering.d.ts

@@ -88,9 +88,10 @@ export function processQuery(data: Array<Object>, queryBuild: Object, ModelClass
 /**
  * Creates custom operations for date parts to be used with Sift
  * @param {string} timezone - The timezone to use for date operations
+ * @param {Class} ModelClass - The model class for serialization
  * @returns {Object} Object containing custom operations
  */
-export function createDateOperations(timezone?: string): Object;
+export function createDateOperations(timezone?: string, ModelClass?: Class): Object;
 /**
  * Process a Django-style filter query to use with sift, including date part operations
  * @param {Object} criteria - Sift criteria with possible date operations

package/dist/filtering/localFiltering.js

@@ -1,6 +1,7 @@
 import sift, { createEqualsOperation } from 'sift';
 import { configInstance } from '../config.js';
 import { DateTime } from 'luxon';
+import { ModelSerializer } from '../flavours/django/serializers.js';
 /**
  * Gets the backend timezone for a model class
  * @param {Class} ModelClass - The model class
@@ -15,43 +16,25 @@ function getBackendTimezone(ModelClass) {
     return backendConfig.BACKEND_TZ || 'UTC';
 }
 /**
- * Normalizes a filter value based on the field's schema type.
- * This ensures Django-like behavior where date strings are automatically
- * converted to Date objects for comparison.
+ * Normalizes a filter value to match the live representation used in fetched data.
+ * This ensures filter values match the format of data returned by .fetch().
  *
  * @param {string} fieldName - The field name to check in the schema
  * @param {any} value - The filter value to normalize
  * @param {Class} ModelClass - The model class containing the field
- * @returns {any} The normalized value
+ * @returns {any} The normalized value in live format
  */
 function normalizeFilterValue(fieldName, value, ModelClass) {
     // If no schema or field name, return value as-is
     if (!ModelClass?.schema || !fieldName)
         return value;
-    // Get the field schema
-    const fieldSchema = ModelClass.schema.properties?.[fieldName];
-    if (!fieldSchema)
-        return value;
-    const { type, format } = fieldSchema;
-    // Handle date/datetime fields - convert strings to Date objects
-    if (type === 'string' && (format === 'date' || format === 'date-time')) {
-        if (typeof value === 'string') {
-            const parsed = new Date(value);
-            // Only return the parsed date if it's valid
-            return isNaN(parsed.getTime()) ? value : parsed;
-        }
-    }
-    // Handle 'in' lookups - normalize array values
-    if (Array.isArray(value) && type === 'string' && (format === 'date' || format === 'date-time')) {
-        return value.map(v => {
-            if (typeof v === 'string') {
-                const parsed = new Date(v);
-                return isNaN(parsed.getTime()) ? v : parsed;
-            }
-            return v;
-        });
+    // Use the model's serializer to convert to live format (what .fetch() returns)
+    const serializer = new ModelSerializer(ModelClass);
+    // Handle array values (for 'in' lookups)
+    if (Array.isArray(value)) {
+        return value.map(v => serializer.toLiveField(fieldName, v));
     }
-    return value;
+    return serializer.toLiveField(fieldName, value);
 }
 /**
  * Process a Django-style field path with relationships to match Django ORM behavior.
@@ -319,16 +302,32 @@ function createOperatorFromLookup(field, lookup, value, isRelationship, ModelCla
 /**
  * Creates custom operations for date parts to be used with Sift
  * @param {string} timezone - The timezone to use for date operations
+ * @param {Class} ModelClass - The model class for serialization
  * @returns {Object} Object containing custom operations
  */
-function createDateOperations(timezone = 'UTC') {
-    // Helper function to extract date parts with Django-compatible behavior
-    const getDatePart = (value, partExtractor) => {
+function createDateOperations(timezone = 'UTC', ModelClass = null) {
+    const serializer = ModelClass ? new ModelSerializer(ModelClass) : null;
+    // Helper function to convert value to Date object using serializer
+    const toDateObject = (value, fieldName = null) => {
         if (!value)
             return null;
-        const dateValue = value instanceof Date ? value : new Date(value);
-        if (isNaN(dateValue.getTime()))
+        // If already a Date, return it
+        if (value instanceof Date)
+            return value;
+        // Use serializer to convert internal format to Date object
+        if (serializer && fieldName && typeof value === 'string') {
+            return serializer.toLiveField(fieldName, value);
+        }
+        // Fallback - should not happen in normal operation
+        console.warn('Date conversion without serializer context:', value);
+        return null;
+    };
+    // Helper function to extract date parts with Django-compatible behavior
+    const getDatePart = (value, partExtractor, fieldName = null) => {
+        const dateValue = toDateObject(value, fieldName);
+        if (!dateValue || !(dateValue instanceof Date) || isNaN(dateValue.getTime())) {
             return null;
+        }
         // Convert to timezone using Luxon
         const luxonDate = DateTime.fromJSDate(dateValue).setZone(timezone);
         // Extract the part using the provided function
@@ -395,29 +394,31 @@ function createDateOperations(timezone = 'UTC') {
         },
         // Date - extract date portion (ignore time)
         $date(params, ownerQuery, options) {
-            return createEqualsOperation((value) => {
-                if (!value)
+            return createEqualsOperation((value, fieldName) => {
+                const dateValue = toDateObject(value, fieldName);
+                if (!dateValue || !(dateValue instanceof Date) || isNaN(dateValue.getTime())) {
                     return false;
-                const dateValue = value instanceof Date ? value : new Date(value);
-                if (isNaN(dateValue.getTime()))
+                }
+                // Convert params to Date using serializer
+                const paramDate = toDateObject(params, fieldName);
+                if (!paramDate || isNaN(paramDate.getTime()))
                     return false;
                 // Convert both to timezone and get date portions
                 const luxonDate = DateTime.fromJSDate(dateValue).setZone(timezone);
-                const paramDate = DateTime.fromJSDate(new Date(params)).setZone(timezone);
+                const luxonParam = DateTime.fromJSDate(paramDate).setZone(timezone);
                 // Compare year, month, and day
-                return luxonDate.year === paramDate.year &&
-                    luxonDate.month === paramDate.month &&
-                    luxonDate.day === paramDate.day;
+                return luxonDate.year === luxonParam.year &&
+                    luxonDate.month === luxonParam.month &&
+                    luxonDate.day === luxonParam.day;
             }, ownerQuery, options);
         },
         // Time - extract time portion (ignore date)
         $time(params, ownerQuery, options) {
-            return createEqualsOperation((value) => {
-                if (!value)
-                    return false;
-                const dateValue = value instanceof Date ? value : new Date(value);
-                if (isNaN(dateValue.getTime()))
+            return createEqualsOperation((value, fieldName) => {
+                const dateValue = toDateObject(value, fieldName);
+                if (!dateValue || !(dateValue instanceof Date) || isNaN(dateValue.getTime())) {
                     return false;
+                }
                 // Convert to timezone
                 const luxonDate = DateTime.fromJSDate(dateValue).setZone(timezone);
                 // Parse the time string (format: "HH:MM:SS" or a Date object)
@@ -430,11 +431,14 @@ function createDateOperations(timezone = 'UTC') {
                     paramSecond = parseInt(timeParts[2], 10);
                 }
                 else {
-                    // If it's a Date object, extract time parts
-                    const paramDate = DateTime.fromJSDate(new Date(params)).setZone(timezone);
-                    paramHour = paramDate.hour;
-                    paramMinute = paramDate.minute;
-                    paramSecond = paramDate.second;
+                    // Convert params to Date using serializer
+                    const paramDate = toDateObject(params, fieldName);
+                    if (!paramDate)
+                        return false;
+                    const luxonParam = DateTime.fromJSDate(paramDate).setZone(timezone);
+                    paramHour = luxonParam.hour;
+                    paramMinute = luxonParam.minute;
+                    paramSecond = luxonParam.second;
                 }
                 // Compare hour, minute, and second
                 return luxonDate.hour === paramHour &&
@@ -463,12 +467,11 @@ function createDateOperations(timezone = 'UTC') {
         datePartComparisons.forEach(op => {
             // Create a custom operation for each combination (e.g., $year_gt, $month_lte)
             operations[`$${part}_${op}`] = (params, ownerQuery, options) => {
-                return createEqualsOperation((value) => {
-                    if (!value)
-                        return false;
-                    const dateValue = value instanceof Date ? value : new Date(value);
-                    if (isNaN(dateValue.getTime()))
+                return createEqualsOperation((value, fieldName) => {
+                    const dateValue = toDateObject(value, fieldName);
+                    if (!dateValue || !(dateValue instanceof Date) || isNaN(dateValue.getTime())) {
                         return false;
+                    }
                     // Convert to timezone and extract part
                     const luxonDate = DateTime.fromJSDate(dateValue).setZone(timezone);
                     const partValue = extractor(luxonDate);
@@ -499,7 +502,7 @@ function createDateOperations(timezone = 'UTC') {
 function createFilterWithDateOperations(criteria, ModelClass) {
     const timezone = getBackendTimezone(ModelClass);
     return sift(criteria, {
-        operations: createDateOperations(timezone)
+        operations: createDateOperations(timezone, ModelClass)
     });
 }
 /**

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

@@ -43,6 +43,16 @@ export class Model {
      * @returns {Promise<boolean>} Promise that resolves to true if valid, throws error if invalid
      */
     static validate(data: Object, validateType?: string, partial?: boolean): Promise<boolean>;
+    /**
+     * Get field permissions for the current user (cached on the class)
+     * @param {boolean} refresh - Force refresh the cached permissions
+     * @returns {Promise<{visible_fields: string[], creatable_fields: string[], editable_fields: string[]}>}
+     */
+    static getFieldPermissions(refresh?: boolean): Promise<{
+        visible_fields: string[];
+        creatable_fields: string[];
+        editable_fields: string[];
+    }>;
     constructor(data?: {});
     serializer: ModelSerializer;
     _data: {};

package/dist/flavours/django/model.js

@@ -299,6 +299,50 @@ export class Model {
             throw new Error(`Validation failed: ${error.message}`);
         }
     }
+    /**
+     * Get field permissions for the current user (cached on the class)
+     * @param {boolean} refresh - Force refresh the cached permissions
+     * @returns {Promise<{visible_fields: string[], creatable_fields: string[], editable_fields: string[]}>}
+     */
+    static async getFieldPermissions(refresh = false) {
+        const ModelClass = this;
+        // Return cached permissions if available and not forcing refresh
+        if (!refresh && ModelClass._fieldPermissionsCache) {
+            return ModelClass._fieldPermissionsCache;
+        }
+        // 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 field permissions endpoint
+        const baseUrl = backend.API_URL.replace(/\/+$/, "");
+        const url = `${baseUrl}/${ModelClass.modelName}/field-permissions/`;
+        // Prepare headers
+        const headers = {
+            "Content-Type": "application/json",
+            ...(backend.getAuthHeaders ? backend.getAuthHeaders() : {}),
+        };
+        // Make direct API call to field permissions endpoint
+        try {
+            const response = await axios.get(url, { headers });
+            // Cache the permissions on the class
+            ModelClass._fieldPermissionsCache = response.data;
+            // Backend returns {visible_fields: [], creatable_fields: [], editable_fields: []}
+            return response.data;
+        }
+        catch (error) {
+            if (error.response && error.response.data) {
+                const parsedError = parseStateZeroError(error.response.data);
+                if (Error.captureStackTrace) {
+                    Error.captureStackTrace(parsedError, ModelClass.getFieldPermissions);
+                }
+                throw parsedError;
+            }
+            throw new Error(`Failed to get field permissions: ${error.message}`);
+        }
+    }
 }
 /**
  * Creates a new Model instance.

package/package.json

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