@statezero/core 0.1.91 → 0.1.93

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,32 @@ 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
+                // The serializer now parses date strings in the backend timezone
+                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 +432,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 +468,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 +503,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/dates.d.ts

@@ -19,9 +19,10 @@ export class DateParsingHelpers {
      * @param {string|Date} value - The date value to parse
      * @param {string} fieldName - Name of the field (for schema lookup)
      * @param {Object} schema - The model schema containing format info
+     * @param {string} timezone - The backend timezone (defaults to 'UTC')
      * @returns {Date|null} - Parsed Date object or null if invalid
      */
-    static parseDate(value: string | Date, fieldName: string, schema: Object): Date | null;
+    static parseDate(value: string | Date, fieldName: string, schema: Object, timezone?: string): Date | null;
     /**
      * Serialize a date using the field's configured format
      * @param {Date} date - The date to serialize

package/dist/flavours/django/dates.js

@@ -1,4 +1,5 @@
 import { format, parse, parseISO } from 'date-fns';
+import { DateTime } from 'luxon';
 /**
  * Date parsing utilities for handling Django style date formats
  */
@@ -8,12 +9,13 @@ export class DateParsingHelpers {
      * @param {string|Date} value - The date value to parse
      * @param {string} fieldName - Name of the field (for schema lookup)
      * @param {Object} schema - The model schema containing format info
+     * @param {string} timezone - The backend timezone (defaults to 'UTC')
      * @returns {Date|null} - Parsed Date object or null if invalid
      */
-    static parseDate(value, fieldName, schema) {
+    static parseDate(value, fieldName, schema, timezone = 'UTC') {
         if (!value)
             return null;
-        // If already a Date object, return as-is
+        // If already a Date object, return as-is (it's already a specific instant in time)
         if (value instanceof Date)
             return value;
         const fieldFormat = schema.properties[fieldName].format;
@@ -33,10 +35,19 @@ export class DateParsingHelpers {
         try {
             // Handle ISO format (Django's default)
             if (!dateFormat || dateFormat === 'iso-8601') {
-                return parseISO(value);
+                // Parse the string in the server timezone using Luxon
+                // This ensures '2022-03-15' is interpreted as midnight in the server TZ, not browser TZ
+                const luxonDate = DateTime.fromISO(value, { zone: timezone });
+                if (!luxonDate.isValid) {
+                    console.error(`Failed to parse ISO date "${value}":`, luxonDate.invalidReason);
+                    return null;
+                }
+                return luxonDate.toJSDate();
             }
             // Handle supported Django formats
             const dateFnsFormat = this.SUPPORTED_FORMATS[dateFormat];
+            // For non-ISO formats, use date-fns but we should still consider timezone
+            // For now, parse with date-fns and assume it's in the server timezone
             return parse(value, dateFnsFormat, new Date());
         }
         catch (error) {

package/dist/flavours/django/serializers.js

@@ -1,6 +1,19 @@
 import { configInstance } from "../../config.js";
 import { isNil } from "lodash-es";
 import { DateParsingHelpers } from "./dates.js";
+/**
+ * Gets the backend timezone for a model class
+ * @param {Class} ModelClass - The model class
+ * @returns {string} The backend timezone or 'UTC' as fallback
+ */
+function getBackendTimezone(ModelClass) {
+    if (!ModelClass || !ModelClass.configKey) {
+        return 'UTC'; // Default fallback
+    }
+    const config = configInstance.getConfig();
+    const backendConfig = config.backendConfigs[ModelClass.configKey] || config.backendConfigs.default;
+    return backendConfig.BACKEND_TZ || 'UTC';
+}
 /**
  * File field serializer - handles both camelCase (frontend) and snake_case (backend) formats
  */
@@ -73,8 +86,11 @@ export const dateFieldSerializer = {
             return value;
         const { model, field } = context;
         if (model?.schema) {
-            // Use DateParsingHelpers like the model does
-            return DateParsingHelpers.parseDate(value, field, model.schema);
+            // Get the backend timezone for this model
+            const timezone = getBackendTimezone(model);
+            // Use DateParsingHelpers with timezone awareness
+            // This ensures date strings are parsed in the server timezone, not browser timezone
+            return DateParsingHelpers.parseDate(value, field, model.schema, timezone);
         }
         // Fallback parsing if no schema context
         try {

package/package.json

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