@statezero/core 0.2.23 → 0.2.26

package/dist/filtering/localFiltering.d.ts

@@ -7,14 +7,7 @@
  * @returns {string[]} Array of dot-notation paths, e.g. ['author.id','createdAt.year']
  */
 export function getRequiredFields(queryBuild: Object, ModelClass: Class): string[];
-/**
- * Pick out only the required fields from a (possibly nested) model object.
- *
- * @param {string[]} requiredPaths  – e.g. ['id','related.name','related.age']
- * @param {Object}   instance       – e.g. { id: 3, related: { name: 'bob', age: 12, foo: 'bar' } }
- * @returns {Object}                – e.g. { id: 3, related: { name: 'bob', age: 12 } }
- */
-export function pickRequiredFields(requiredPaths: string[], instance: Object): Object;
+export function pickRequiredFields(requiredPaths: any, instance: any): {};
 /**
  * Filter and order a collection of data objects according to a QuerySet's AST.
  * This combines getRequiredFields, pickRequiredFields, and processQuery in one function.

package/dist/filtering/localFiltering.js

@@ -99,6 +99,36 @@ function processFieldPath(fieldPath, value, ModelClass, options = {}) {
             const relationship = currentModel.relationshipFields.get(part);
             const relatedModel = relationship.ModelClass();
             const relationshipType = relationship.relationshipType;
+            // If this is not the last part and it's M2M, recursively process the remaining path
+            if (!isLastPart && relationshipType === 'many-to-many') {
+                // Build the remaining path including any lookup operators
+                const remainingFieldParts = fieldParts.slice(i + 1);
+                let fullRemainingPath = remainingFieldParts.join('__');
+                if (lookupChain.length > 0) {
+                    fullRemainingPath += '__' + lookupChain.join('__');
+                }
+                else if (lookup) {
+                    fullRemainingPath += '__' + lookup;
+                }
+                // Recursively process the remaining path with the related model
+                const innerResult = processFieldPath(fullRemainingPath, value, relatedModel, options);
+                // Build the full field path including any FK traversal before this M2M field
+                // e.g., for owner__roles__name, processedPath=['owner'], part='roles'
+                // so fullFieldPath becomes 'owner.roles'
+                const fullFieldPath = processedPath.length > 0
+                    ? processedPath.join('.') + '.' + part
+                    : part;
+                // Build the required path for data picking (full dot-notation path)
+                const innerRequiredPath = innerResult.requiredPath || innerResult.field;
+                const requiredPath = `${fullFieldPath}.${innerRequiredPath}`;
+                // Wrap the inner result in $elemMatch for this M2M field
+                return {
+                    field: fullFieldPath,
+                    operator: { $elemMatch: { [innerResult.field]: innerResult.operator } },
+                    isM2M: true,
+                    requiredPath // Full path for data picking
+                };
+            }
             // Add this relationship field to the path
             processedPath.push(part);
             // If this is not the last part, update the current model to the related model
@@ -168,6 +198,10 @@ function processFieldPath(fieldPath, value, ModelClass, options = {}) {
         if (normalizedValue && typeof normalizedValue === 'object' && 'pk' in normalizedValue) {
             raw = normalizedValue.pk;
         }
+        // For M2M fields, use $elemMatch to check if any element's pk matches
+        if (isM2M) {
+            return { field: finalPath, operator: { $elemMatch: { pk: { $eq: raw } } }, isM2M: true };
+        }
         return { field: finalPath, operator: { $eq: raw } };
     }
     // Default to direct equality
@@ -217,18 +251,19 @@ function createOperatorFromLookup(field, lookup, value, isRelationship, ModelCla
         // For relationship fields with lookups, we need special handling
         if (lookup === 'isnull') {
             if (isM2M) {
-                // For M2M fields, isnull=True means null OR empty array, but not undefined because
-                // that can mean the field was not fetched so we can't be sure
+                // For M2M fields, isnull=True means null OR empty array
                 // isnull=False means has at least one item
-                // Use a custom function since sift doesn't support $or inside field operators
+                // Use document-level $where to check the array itself (not iterate elements)
+                const m2mField = field;
+                const checkEmpty = value;
                 return {
-                    field,
-                    operator: {
-                        $where: function (fieldValue) {
-                            const isEmpty = fieldValue === null ||
-                                (Array.isArray(fieldValue) && fieldValue.length === 0);
-                            return value ? isEmpty : !isEmpty;
-                        }
+                    field: '$where', // document-level operator
+                    requiredPath: field, // need the M2M field itself for data picking
+                    operator: function (doc) {
+                        const fieldValue = doc[m2mField];
+                        const isEmpty = fieldValue === null ||
+                            (Array.isArray(fieldValue) && fieldValue.length === 0);
+                        return checkEmpty ? isEmpty : !isEmpty;
                     }
                 };
             }
@@ -239,10 +274,17 @@ function createOperatorFromLookup(field, lookup, value, isRelationship, ModelCla
             };
         }
         else if (lookup === 'in') {
+            // For M2M, check if any element's pk is in the provided array
+            if (isM2M) {
+                return { field, operator: { $elemMatch: { pk: { $in: value } } }, isM2M: true };
+            }
             return { field, operator: { $in: value } };
         }
         else {
             // Default handling for relationship fields
+            if (isM2M) {
+                return { field, operator: { $elemMatch: { pk: { $eq: value } } }, isM2M: true };
+            }
             return { field, operator: { $eq: value } };
         }
     }
@@ -545,10 +587,11 @@ function createFilterWithDateOperations(criteria, ModelClass) {
 function convertToSiftCriteria(conditions, ModelClass) {
     const result = {};
     const datePartFilters = new Map(); // Map to collect date part filters by field
+    const m2mConditions = new Map(); // Map to collect M2M $elemMatch conditions by field
     for (const [key, value] of Object.entries(conditions)) {
         try {
             const processedResult = processFieldPath(key, value, ModelClass);
-            const { field, operator, isDatePart } = processedResult;
+            const { field, operator, isDatePart, isM2M } = processedResult;
             if (isDatePart) {
                 // Handle date part operators separately
                 if (!datePartFilters.has(field)) {
@@ -556,6 +599,13 @@ function convertToSiftCriteria(conditions, ModelClass) {
                 }
                 datePartFilters.get(field).push({ [field]: operator });
             }
+            else if (isM2M && operator.$elemMatch) {
+                // Collect M2M conditions to merge into single $elemMatch
+                if (!m2mConditions.has(field)) {
+                    m2mConditions.set(field, []);
+                }
+                m2mConditions.get(field).push(operator.$elemMatch);
+            }
             else {
                 // For regular operators, merge if we already have criteria for this field
                 if (result[field]) {
@@ -570,6 +620,17 @@ function convertToSiftCriteria(conditions, ModelClass) {
             throw new Error(`Failed to process field '${key}': ${error.message}`);
         }
     }
+    // Merge M2M conditions: all conditions on same M2M field go into single $elemMatch
+    // so the SAME related object must match ALL conditions
+    for (const [field, elemMatchConditions] of m2mConditions.entries()) {
+        if (elemMatchConditions.length === 1) {
+            result[field] = { $elemMatch: elemMatchConditions[0] };
+        }
+        else {
+            // Multiple conditions - wrap in $and so same element must match all
+            result[field] = { $elemMatch: { $and: elemMatchConditions } };
+        }
+    }
     // If we have date part filters, combine them with the result
     if (datePartFilters.size > 0) {
         const andConditions = [];
@@ -663,6 +724,9 @@ function convertFilterNodeToSiftCriteria(filterNode, ModelClass) {
             return null;
         if (childCriteria.length === 1)
             return childCriteria[0];
+        // Chained filters use $and at top level - this gives ANY/ANY semantics for M2M
+        // (each $elemMatch can be satisfied by different elements)
+        // This matches Django's chained .filter() behavior
         return { $and: childCriteria };
     }
     // For compound OR nodes
@@ -863,12 +927,24 @@ export function getRequiredFields(queryBuild, ModelClass) {
     function addPath(rawKey) {
         try {
             // We pass `null` as the value, since we only care about .field
-            const { field } = processFieldPath(rawKey, null, ModelClass);
-            paths.add(field);
+            const { field, isM2M, requiredPath } = processFieldPath(rawKey, null, ModelClass);
+            // Use requiredPath if available (for M2M traversal), otherwise use field
+            // For M2M fields at the end of a path (no requiredPath), we need the pk field
+            let finalPath;
+            if (requiredPath) {
+                finalPath = requiredPath;
+            }
+            else if (isM2M) {
+                finalPath = `${field}.pk`;
+            }
+            else {
+                finalPath = field;
+            }
+            paths.add(finalPath);
         }
         catch (err) {
-            // if a key doesn’t map, warn and skip it
-            console.warn(`getRequiredFields: couldn’t process "${rawKey}": ${err.message}`);
+            // if a key doesn't map, warn and skip it
+            console.warn(`getRequiredFields: couldn't process "${rawKey}": ${err.message}`);
         }
     }
     // Recursively walk your filter AST
@@ -917,42 +993,48 @@ export function getRequiredFields(queryBuild, ModelClass) {
  * @param {Object}   instance       – e.g. { id: 3, related: { name: 'bob', age: 12, foo: 'bar' } }
  * @returns {Object}                – e.g. { id: 3, related: { name: 'bob', age: 12 } }
  */
+/**
+ * Recursively sets a value in a result object following a path.
+ * Handles arrays (M2M fields) by mapping over each element.
+ */
+function setNestedValueRecursive(result, source, pathParts) {
+    if (source == null || pathParts.length === 0) {
+        return;
+    }
+    const [current, ...rest] = pathParts;
+    const sourceValue = source[current];
+    if (sourceValue === undefined) {
+        return;
+    }
+    if (rest.length === 0) {
+        // Last part - set the value directly, keeping M2M as full objects
+        result[current] = sourceValue;
+    }
+    else if (Array.isArray(sourceValue)) {
+        // M2M array with nested path - recursively extract from each element
+        if (!(current in result)) {
+            result[current] = [];
+        }
+        sourceValue.forEach((item, idx) => {
+            if (result[current][idx] === undefined) {
+                result[current][idx] = {};
+            }
+            setNestedValueRecursive(result[current][idx], item, rest);
+        });
+    }
+    else if (typeof sourceValue === 'object') {
+        // Regular nested object (FK)
+        if (!(current in result)) {
+            result[current] = {};
+        }
+        setNestedValueRecursive(result[current], sourceValue, rest);
+    }
+}
 export function pickRequiredFields(requiredPaths, instance) {
     const result = {};
     requiredPaths.forEach(path => {
         const parts = path.split('.');
-        // Traverse the source instance to get the value
-        let value = instance;
-        for (const key of parts) {
-            if (value == null || !(key in value)) {
-                value = undefined;
-                break;
-            }
-            value = value[key];
-        }
-        if (value === undefined) {
-            // skip missing
-            return;
-        }
-        // Convert M2M arrays from Model instances to PKs for comparison
-        // This handles the case where the live representation returns [Model1, Model2]
-        // but we need [pk1, pk2] for sift filtering
-        if (Array.isArray(value) && value.length > 0 && value[0]?.pk !== undefined) {
-            value = value.map(item => item.pk);
-        }
-        // Build nested structure in the result
-        let cursor = result;
-        parts.forEach((key, idx) => {
-            if (idx === parts.length - 1) {
-                cursor[key] = value;
-            }
-            else {
-                if (!(key in cursor)) {
-                    cursor[key] = {};
-                }
-                cursor = cursor[key];
-            }
-        });
+        setNestedValueRecursive(result, instance, parts);
     });
     return result;
 }

package/dist/models/backend1/django_app/comprehensivemodel.schema.json

@@ -9,8 +9,8 @@
         "char_field"
     ],
     "searchable_fields": [
-        "char_field",
-        "text_field"
+        "text_field",
+        "char_field"
     ],
     "ordering_fields": [
         "int_field"
@@ -105,7 +105,7 @@
             "format": "date-time",
             "max_length": null,
             "choices": null,
-            "default": "2026-01-18T14:21:49.533255+00:00",
+            "default": "2026-01-18T17:06:00.558317+00:00",
             "validators": [],
             "max_digits": null,
             "decimal_places": null,

package/dist/models/backend1/django_app/custompkmodel.schema.json

@@ -5,15 +5,15 @@
     "plural_title": "Custom Pk Models",
     "primary_key_field": "custom_pk",
     "filterable_fields": [
-        "custom_pk",
-        "name"
+        "name",
+        "custom_pk"
     ],
     "searchable_fields": [
         "name"
     ],
     "ordering_fields": [
-        "custom_pk",
-        "name"
+        "name",
+        "custom_pk"
     ],
     "properties": {
         "custom_pk": {

package/dist/models/backend1/django_app/dailyrate.schema.json

@@ -5,16 +5,16 @@
     "plural_title": "Daily Rates",
     "primary_key_field": "id",
     "filterable_fields": [
+        "id",
+        "date",
         "rate_plan",
-        "closed_to_departure",
         "min_stay_arrival",
-        "min_stay_through",
-        "stop_sell",
         "price",
-        "date",
         "max_stay",
+        "min_stay_through",
+        "stop_sell",
         "closed_to_arrival",
-        "id"
+        "closed_to_departure"
     ],
     "searchable_fields": [],
     "ordering_fields": [

package/dist/models/backend1/django_app/dummymodel.schema.json

@@ -5,8 +5,8 @@
     "plural_title": "Dummy Models",
     "primary_key_field": "id",
     "filterable_fields": [
-        "value",
-        "name"
+        "name",
+        "value"
     ],
     "searchable_fields": [
         "name"

package/dist/models/backend1/django_app/index.js

@@ -16,3 +16,6 @@ export * from './rateplan';
 export * from './dailyrate';
 export * from './restrictedfieldrelatedmodel';
 export * from './modelwithrestrictedfields';
+export * from './m2mdepthtestlevel3';
+export * from './m2mdepthtestlevel2';
+export * from './m2mdepthtestlevel1';

package/dist/models/backend1/django_app/m2mdepthtestlevel1.d.ts

@@ -0,0 +1,118 @@
+/**
+ * Model-specific QuerySet implementation
+ */
+export class M2MDepthTestLevel1QuerySet {
+}
+/**
+ * Model-specific Manager implementation
+ */
+export class M2MDepthTestLevel1Manager {
+    constructor(ModelClass: any);
+    newQuerySet(): M2MDepthTestLevel1QuerySet;
+}
+/**
+ * Implementation of the M2MDepthTestLevel1 model
+ */
+export class M2MDepthTestLevel1 {
+    static configKey: string;
+    static modelName: string;
+    static primaryKeyField: string;
+    static objects: M2MDepthTestLevel1Manager;
+    static fields: string[];
+    static schema: {
+        model_name: string;
+        title: string;
+        class_name: string;
+        plural_title: string;
+        primary_key_field: string;
+        filterable_fields: string[];
+        searchable_fields: string[];
+        ordering_fields: string[];
+        properties: {
+            id: {
+                type: string;
+                title: string;
+                required: boolean;
+                description: null;
+                nullable: boolean;
+                format: string;
+                max_length: null;
+                choices: null;
+                default: null;
+                validators: never[];
+                max_digits: null;
+                decimal_places: null;
+                read_only: boolean;
+                ref: null;
+            };
+            name: {
+                type: string;
+                title: string;
+                required: boolean;
+                description: null;
+                nullable: boolean;
+                format: null;
+                max_length: number;
+                choices: null;
+                default: null;
+                validators: never[];
+                max_digits: null;
+                decimal_places: null;
+                read_only: boolean;
+                ref: null;
+            };
+            level2s: {
+                type: string;
+                title: string;
+                required: boolean;
+                description: null;
+                nullable: boolean;
+                format: string;
+                max_length: null;
+                choices: null;
+                default: null;
+                validators: never[];
+                max_digits: null;
+                decimal_places: null;
+                read_only: boolean;
+                ref: null;
+            };
+        };
+        relationships: {
+            level2s: {
+                type: string;
+                model: string;
+                class_name: string;
+                primary_key_field: string;
+            };
+        };
+        default_ordering: null;
+        definitions: {
+            MoneyField: {
+                type: string;
+                properties: {
+                    amount: {
+                        type: string;
+                    };
+                    currency: {
+                        type: string;
+                    };
+                };
+            };
+        };
+        datetime_format: string;
+        date_format: string;
+        time_format: string;
+        display: null;
+    };
+    static relationshipFields: Map<string, {
+        ModelClass: () => any;
+        relationshipType: string;
+    }>;
+    constructor(data: any);
+    /**
+     * Define property getters and setters for all model fields
+     * @private
+     */
+    private _defineProperties;
+}

package/dist/models/backend1/django_app/m2mdepthtestlevel1.js

@@ -0,0 +1,71 @@
+/**
+ * This file was auto-generated. Do not make direct changes to the file.
+ */
+import { Model, Manager, QuerySet, getModelClass } from '../../../../src';
+import { wrapReactiveModel } from '../../../../src';
+import schemaData from './m2mdepthtestlevel1.schema.json';
+/**
+ * Model-specific QuerySet implementation
+ */
+export class M2MDepthTestLevel1QuerySet extends QuerySet {
+}
+/**
+ * Model-specific Manager implementation
+ */
+export class M2MDepthTestLevel1Manager extends Manager {
+    constructor(ModelClass) {
+        super(ModelClass, M2MDepthTestLevel1QuerySet);
+    }
+    newQuerySet() {
+        return new M2MDepthTestLevel1QuerySet(this.ModelClass);
+    }
+}
+/**
+ * Implementation of the M2MDepthTestLevel1 model
+ */
+export class M2MDepthTestLevel1 extends Model {
+    constructor(data) {
+        M2MDepthTestLevel1.validateFields(data);
+        super(data);
+        // Define getters and setters for all fields
+        this._defineProperties();
+        return wrapReactiveModel(this);
+    }
+    /**
+     * Define property getters and setters for all model fields
+     * @private
+     */
+    _defineProperties() {
+        // For each field, define a property that gets/sets from internal storage
+        M2MDepthTestLevel1.fields.forEach(field => {
+            Object.defineProperty(this, field, {
+                get: function () {
+                    return this.getField(field);
+                },
+                set: function (value) {
+                    this.setField(field, value);
+                },
+                enumerable: true, // Make sure fields are enumerable for serialization
+                configurable: true
+            });
+        });
+        // Add a special read-only getter for the repr field
+        Object.defineProperty(this, 'repr', {
+            get: function () {
+                return this.getField('repr');
+            },
+            enumerable: true, // Make sure repr is enumerable
+            configurable: true
+        });
+    }
+}
+// Bind this model to its backend
+M2MDepthTestLevel1.configKey = 'backend1';
+M2MDepthTestLevel1.modelName = 'django_app.m2mdepthtestlevel1';
+M2MDepthTestLevel1.primaryKeyField = 'id';
+M2MDepthTestLevel1.objects = new M2MDepthTestLevel1Manager(M2MDepthTestLevel1);
+M2MDepthTestLevel1.fields = ['id', 'name', 'level2s'];
+M2MDepthTestLevel1.schema = schemaData;
+M2MDepthTestLevel1.relationshipFields = new Map([
+    ['level2s', { 'ModelClass': () => getModelClass('django_app.m2mdepthtestlevel2', 'backend1'), 'relationshipType': 'many-to-many' }]
+]);

package/dist/models/backend1/django_app/m2mdepthtestlevel1.schema.json

@@ -0,0 +1,94 @@
+{
+    "model_name": "django_app.m2mdepthtestlevel1",
+    "title": "M2M Depth Test Level1",
+    "class_name": "M2MDepthTestLevel1",
+    "plural_title": "M2M Depth Test Level1S",
+    "primary_key_field": "id",
+    "filterable_fields": [
+        "name",
+        "level2s",
+        "id"
+    ],
+    "searchable_fields": [
+        "name"
+    ],
+    "ordering_fields": [
+        "name"
+    ],
+    "properties": {
+        "id": {
+            "type": "integer",
+            "title": "Id",
+            "required": true,
+            "description": null,
+            "nullable": false,
+            "format": "id",
+            "max_length": null,
+            "choices": null,
+            "default": null,
+            "validators": [],
+            "max_digits": null,
+            "decimal_places": null,
+            "read_only": true,
+            "ref": null
+        },
+        "name": {
+            "type": "string",
+            "title": "Name",
+            "required": true,
+            "description": null,
+            "nullable": false,
+            "format": null,
+            "max_length": 100,
+            "choices": null,
+            "default": null,
+            "validators": [],
+            "max_digits": null,
+            "decimal_places": null,
+            "read_only": false,
+            "ref": null
+        },
+        "level2s": {
+            "type": "array",
+            "title": "Level2s",
+            "required": true,
+            "description": null,
+            "nullable": false,
+            "format": "many-to-many",
+            "max_length": null,
+            "choices": null,
+            "default": null,
+            "validators": [],
+            "max_digits": null,
+            "decimal_places": null,
+            "read_only": false,
+            "ref": null
+        }
+    },
+    "relationships": {
+        "level2s": {
+            "type": "many-to-many",
+            "model": "django_app.m2mdepthtestlevel2",
+            "class_name": "M2MDepthTestLevel2",
+            "primary_key_field": "id"
+        }
+    },
+    "default_ordering": null,
+    "definitions": {
+        "MoneyField": {
+            "type": "object",
+            "properties": {
+                "amount": {
+                    "type": "number"
+                },
+                "currency": {
+                    "type": "string"
+                }
+            }
+        }
+    },
+    "datetime_format": "iso-8601",
+    "date_format": "iso-8601",
+    "time_format": "iso-8601",
+    "display": null
+}