@objectql/driver-mongo 4.0.1 → 4.0.2

package/src/index.ts

@@ -1,8 +1,7 @@
-import { Data, System } from '@objectstack/spec';
+import { Data, Driver as DriverSpec } from '@objectstack/spec';
 type QueryAST = Data.QueryAST;
-type FilterNode = Data.FilterNode;
 type SortNode = Data.SortNode;
-type DriverInterface = System.DriverInterface;
+type DriverInterface = DriverSpec.DriverInterface;
 /**
  * ObjectQL
  * Copyright (c) 2026-present ObjectStack Inc.
@@ -150,12 +149,72 @@ export class MongoDriver implements Driver {
     }
 
     private mapFilters(filters: any): Filter<any> {
-        if (!filters || filters.length === 0) return {};
+        if (!filters) return {};
+        
+        // If filters is an object (FilterCondition format), map id fields to _id
+        if (typeof filters === 'object' && !Array.isArray(filters)) {
+            return this.mapIdFieldsInFilter(filters);
+        }
+        
+        // If filters is an array (legacy format), convert it
+        if (Array.isArray(filters) && filters.length === 0) return {};
         
         const result = this.buildFilterConditions(filters);
         return result;
     }
 
+    /**
+     * Recursively map 'id' fields to '_id' in FilterCondition objects
+     * and normalize primitive values to use $eq operator when inside logical operators
+     */
+    private mapIdFieldsInFilter(filter: any, insideLogicalOp: boolean = false): any {
+        if (!filter || typeof filter !== 'object') {
+            return filter;
+        }
+
+        const result: any = {};
+        
+        for (const [key, value] of Object.entries(filter)) {
+            // Handle logical operators
+            if (key === '$and' || key === '$or') {
+                if (Array.isArray(value)) {
+                    // Pass true to indicate we're inside a logical operator
+                    result[key] = value.map(v => this.mapIdFieldsInFilter(v, true));
+                }
+            } 
+            // Map 'id' to '_id'
+            else if (key === 'id') {
+                // If value is already an object with operators, recurse
+                if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+                    result['_id'] = this.mapIdFieldsInFilter(value, insideLogicalOp);
+                } else {
+                    // Primitive value - wrap with $eq only if inside logical operator
+                    result['_id'] = insideLogicalOp ? { $eq: value } : value;
+                }
+            }
+            // Skip MongoDB operator keys (starting with $) - but still recurse for nested mappings
+            else if (key.startsWith('$')) {
+                // Recursively process to handle nested objects that might contain 'id' fields
+                if (typeof value === 'object' && value !== null) {
+                    result[key] = this.mapIdFieldsInFilter(value, insideLogicalOp);
+                } else {
+                    result[key] = value;
+                }
+            }
+            // Recursively handle nested objects (already operator-wrapped values)
+            else if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+                result[key] = this.mapIdFieldsInFilter(value, insideLogicalOp);
+            }
+            // Primitive field values
+            else {
+                // Wrap with $eq only if inside a logical operator
+                result[key] = insideLogicalOp ? { $eq: value } : value;
+            }
+        }
+        
+        return result;
+    }
+
     /**
      * Build MongoDB filter conditions from ObjectQL filter array.
      * Supports nested filter groups and logical operators (AND/OR).
@@ -258,68 +317,45 @@ export class MongoDriver implements Driver {
      * QueryAST sort is array of {field, order}, while UnifiedQuery is array of [field, order].
      * QueryAST uses 'aggregations', while legacy uses 'aggregate'.
      */
-    private normalizeQuery(query: any): any {
-        if (!query) return {};
-        
-        const normalized: any = { ...query };
+    async find(objectName: string, query: any, options?: any): Promise<any[]> {
+        const collection = await this.getCollection(objectName);
         
-        // Normalize limit/top
-        if (normalized.top !== undefined && normalized.limit === undefined) {
-            normalized.limit = normalized.top;
-        }
+        // Handle both new format (where) and legacy format (filters)
+        const filterCondition = query.where || query.filters;
+        const filter = this.mapFilters(filterCondition);
         
-        // Normalize aggregations/aggregate
-        if (normalized.aggregations !== undefined && normalized.aggregate === undefined) {
-            // Convert QueryAST aggregations format to legacy aggregate format
-            normalized.aggregate = normalized.aggregations.map((agg: any) => ({
-                func: agg.function || agg.func,
-                field: agg.field,
-                alias: agg.alias
-            }));
-        }
+        const findOptions: FindOptions = {};
         
-        // Normalize sort format
-        if (normalized.sort && Array.isArray(normalized.sort)) {
-            // Check if it's already in the array format [field, order]
-            const firstSort = normalized.sort[0];
-            if (firstSort && typeof firstSort === 'object' && !Array.isArray(firstSort)) {
-                // Convert from QueryAST format {field, order} to internal format [field, order]
-                normalized.sort = normalized.sort.map((item: any) => [
-                    item.field,
-                    item.order || item.direction || item.dir || 'asc'
-                ]);
-            }
-        }
+        // Handle pagination - support both new format (offset/limit) and legacy format (skip/top)
+        const offsetValue = query.offset ?? query.skip;
+        const limitValue = query.limit ?? query.top;
         
-        return normalized;
-    }
-
-    async find(objectName: string, query: any, options?: any): Promise<any[]> {
-        const normalizedQuery = this.normalizeQuery(query);
-        const collection = await this.getCollection(objectName);
-        const filter = this.mapFilters(normalizedQuery.filters);
+        if (offsetValue !== undefined) findOptions.skip = offsetValue;
+        if (limitValue !== undefined) findOptions.limit = limitValue;
         
-        const findOptions: FindOptions = {};
-        if (normalizedQuery.skip) findOptions.skip = normalizedQuery.skip;
-        if (normalizedQuery.limit) findOptions.limit = normalizedQuery.limit;
-        if (normalizedQuery.sort) {
-            // map [['field', 'desc']] to { field: -1 }
+        // Handle sort - support both new format (orderBy) and legacy format (sort)
+        const sortArray = query.orderBy || query.sort;
+        if (sortArray && Array.isArray(sortArray)) {
             findOptions.sort = {};
-            for (const [field, order] of normalizedQuery.sort) {
+            for (const item of sortArray) {
+                // Support both {field, order} object format and [field, order] array format
+                const field = item.field || item[0];
+                const order = item.order || item[1] || 'asc';
                 // Map both 'id' and '_id' to '_id' for backward compatibility
                 const dbField = (field === 'id' || field === '_id') ? '_id' : field;
                 (findOptions.sort as any)[dbField] = order === 'desc' ? -1 : 1;
             }
         }
-        if (normalizedQuery.fields && normalizedQuery.fields.length > 0) {
+        
+        if (query.fields && query.fields.length > 0) {
             findOptions.projection = {};
-            for (const field of normalizedQuery.fields) {
+            for (const field of query.fields) {
                 // Map both 'id' and '_id' to '_id' for backward compatibility
                 const dbField = (field === 'id' || field === '_id') ? '_id' : field;
                 (findOptions.projection as any)[dbField] = 1;
             }
             // Explicitly exclude _id if 'id' is not in the requested fields
-            const hasIdField = normalizedQuery.fields.some((f: string) => f === 'id' || f === '_id');
+            const hasIdField = query.fields.some((f: string) => f === 'id' || f === '_id');
             if (!hasIdField) {
                 (findOptions.projection as any)._id = 0;
             }
@@ -383,9 +419,12 @@ export class MongoDriver implements Driver {
 
     async count(objectName: string, filters: any, options?: any): Promise<number> {
         const collection = await this.getCollection(objectName);
-        // Normalize to support both filter arrays and full query objects
-        const normalizedQuery = this.normalizeQuery(filters);
-        const actualFilters = normalizedQuery.filters || filters;
+        // Handle both filter objects and query objects
+        let actualFilters = filters;
+        if (filters && (filters.where || filters.filters)) {
+            // It's a query object with 'where' or 'filters' property
+            actualFilters = filters.where || filters.filters;
+        }
         const filter = this.mapFilters(actualFilters);
         return await collection.countDocuments(filter);
     }
@@ -452,19 +491,9 @@ export class MongoDriver implements Driver {
      * @returns Query results with value and count
      */
     async executeQuery(ast: QueryAST, options?: any): Promise<{ value: any[]; count?: number }> {
-        const objectName = ast.object || '';
-        
-        // Convert QueryAST to legacy query format
-        const legacyQuery: any = {
-            fields: ast.fields,
-            filters: this.convertFilterNodeToLegacy(ast.filters),
-            sort: ast.sort?.map((s: SortNode) => [s.field, s.order]),
-            limit: ast.top,
-            skip: ast.skip,
-        };
-        
-        // Use existing find method
-        const results = await this.find(objectName, legacyQuery, options);
+        // QueryAST is now the same format as our internal query
+        // Just pass it directly to find
+        const results = await this.find(ast.object || '', ast, options);
         
         return {
             value: results,
@@ -575,54 +604,9 @@ export class MongoDriver implements Driver {
     }
 
     /**
-     * Convert FilterNode (QueryAST format) to legacy filter array format
+     * Convert FilterCondition (QueryAST format) to legacy filter array format
      * This allows reuse of existing filter logic while supporting new QueryAST
      * 
-     * @private
-     */
-    private convertFilterNodeToLegacy(node?: FilterNode): any {
-        if (!node) return undefined;
-        
-        switch (node.type) {
-            case 'comparison':
-                // Convert comparison node to [field, operator, value] format
-                const operator = node.operator || '=';
-                return [[node.field, operator, node.value]];
-            
-            case 'and':
-            case 'or':
-                // Convert AND/OR node to array with separator
-                if (!node.children || node.children.length === 0) return undefined;
-                const results: any[] = [];
-                const separator = node.type; // 'and' or 'or'
-                
-                for (const child of node.children) {
-                    const converted = this.convertFilterNodeToLegacy(child);
-                    if (converted) {
-                        if (results.length > 0) {
-                            results.push(separator);
-                        }
-                        results.push(...(Array.isArray(converted) ? converted : [converted]));
-                    }
-                }
-                return results.length > 0 ? results : undefined;
-            
-            case 'not':
-                // NOT is not directly supported in the legacy filter format
-                // MongoDB supports $not, but legacy array format doesn't have a NOT operator
-                // Use native MongoDB queries with $not instead:
-                // Example: { field: { $not: { $eq: value } } }
-                throw new Error(
-                    'NOT filters are not supported in legacy filter format. ' +
-                    'Use native MongoDB queries with $not operator instead. ' +
-                    'Example: { field: { $not: { $eq: value } } }'
-                );
-            
-            default:
-                return undefined;
-        }
-    }
-
     /**
      * Execute command (alternative signature for compatibility)
      * 

package/test/index.test.ts

@@ -62,23 +62,16 @@ describe('MongoDriver', () => {
 
     it('should find objects with query', async () => {
         const query = {
-            filters: [['age', '>', 18]],
-            sort: [['name', 'asc']],
-            skip: 10,
+            where: { age: { $gt: 18 } },
+            orderBy: [{ field: 'name', order: 'asc' as const }],
+            offset: 10,
             limit: 5
         };
         
         await driver.find('users', query);
         
-        // Debugging what was actually called
-        // console.log('Find calls:', mockCollection.find.mock.calls);
-
         expect(mockDb.collection).toHaveBeenCalledWith('users');
         
-        // We expect: find(filter, options)
-        // filter = { $and: [{ age: { $gt: 18 } }] }
-        // options = { limit: 5, skip: 10, sort: { name: 1 } }
-        
         expect(mockCollection.find).toHaveBeenCalledWith(
             { age: { $gt: 18 } },
             expect.objectContaining({ 
@@ -92,7 +85,12 @@ describe('MongoDriver', () => {
 
     it('should handle OR filters', async () => {
         const query = {
-            filters: [['age', '>', 18], 'or', ['role', '=', 'admin']]
+            where: {
+                $or: [
+                    { age: { $gt: 18 } },
+                    { role: 'admin' }
+                ]
+            }
         };
         await driver.find('users', query);
         
@@ -109,7 +107,7 @@ describe('MongoDriver', () => {
 
     it('should map "id" field to "_id" in filters', async () => {
         const query = {
-            filters: [['id', '=', '12345']]
+            where: { id: '12345' }
         };
         await driver.find('users', query);
         
@@ -121,7 +119,7 @@ describe('MongoDriver', () => {
 
     it('should map "id" to "_id" in sorting', async () => {
         const query = {
-            sort: [['id', 'desc']]
+            orderBy: [{ field: 'id', order: 'desc' as const }]
         };
         await driver.find('users', query);
         
@@ -192,7 +190,7 @@ describe('MongoDriver', () => {
     // Backward compatibility tests for legacy '_id' usage
     it('should accept "_id" field in filters for backward compatibility', async () => {
         const query = {
-            filters: [['_id', '=', '12345']]
+            where: { _id: '12345' }
         };
         await driver.find('users', query);
         
@@ -204,7 +202,7 @@ describe('MongoDriver', () => {
 
     it('should accept "_id" in sorting for backward compatibility', async () => {
         const query = {
-            sort: [['_id', 'asc']]
+            orderBy: [{ field: '_id', order: 'asc' as const }]
         };
         await driver.find('users', query);
         
@@ -237,19 +235,22 @@ describe('MongoDriver', () => {
 
     it('should handle nested filter groups', async () => {
         const query = {
-            filters: [
-                [
-                    ['status', '=', 'completed'],
-                    'and',
-                    ['amount', '>', 100]
-                ],
-                'or',
-                [
-                    ['customer', '=', 'Alice'],
-                    'and',
-                    ['status', '=', 'pending']
+            where: {
+                $or: [
+                    {
+                        $and: [
+                            { status: 'completed' },
+                            { amount: { $gt: 100 } }
+                        ]
+                    },
+                    {
+                        $and: [
+                            { customer: 'Alice' },
+                            { status: 'pending' }
+                        ]
+                    }
                 ]
-            ]
+            }
         };
         await driver.find('orders', query);
         
@@ -271,19 +272,22 @@ describe('MongoDriver', () => {
 
     it('should handle deeply nested filter groups', async () => {
         const query = {
-            filters: [
-                [
-                    [
-                        ['age', '>', 22],
-                        'and',
-                        ['status', '=', 'active']
-                    ],
-                    'or',
-                    ['role', '=', 'admin']
-                ],
-                'and',
-                ['name', '!=', 'Bob']
-            ]
+            where: {
+                $and: [
+                    {
+                        $or: [
+                            {
+                                $and: [
+                                    { age: { $gt: 22 } },
+                                    { status: 'active' }
+                                ]
+                            },
+                            { role: 'admin' }
+                        ]
+                    },
+                    { name: { $ne: 'Bob' } }
+                ]
+            }
         };
         await driver.find('users', query);
         
@@ -313,13 +317,17 @@ describe('MongoDriver', () => {
 
     it('should handle nested groups with implicit AND', async () => {
         const query = {
-            filters: [
-                [
-                    ['status', '=', 'active'],
-                    ['role', '=', 'admin']
-                ],
-                ['age', '>', 25]
-            ]
+            where: {
+                $and: [
+                    {
+                        $and: [
+                            { status: 'active' },
+                            { role: 'admin' }
+                        ]
+                    },
+                    { age: { $gt: 25 } }
+                ]
+            }
         };
         await driver.find('users', query);
         
@@ -341,14 +349,11 @@ describe('MongoDriver', () => {
                 const ast = {
                     object: 'users',
                     fields: ['name', 'email'],
-                    filters: {
-                        type: 'comparison' as const,
-                        field: 'status',
-                        operator: '=',
-                        value: 'active'
+                    where: {
+                        status: 'active'
                     },
-                    top: 10,
-                    skip: 0
+                    limit: 10,
+                    offset: 0
                 };
 
                 mockCollection.toArray.mockResolvedValue([
@@ -366,21 +371,10 @@ describe('MongoDriver', () => {
             it('should handle complex QueryAST with AND filters', async () => {
                 const ast = {
                     object: 'users',
-                    filters: {
-                        type: 'and' as const,
-                        children: [
-                            {
-                                type: 'comparison' as const,
-                                field: 'status',
-                                operator: '=',
-                                value: 'active'
-                            },
-                            {
-                                type: 'comparison' as const,
-                                field: 'age',
-                                operator: '>',
-                                value: 18
-                            }
+                    where: {
+                        $and: [
+                            { status: 'active' },
+                            { age: { $gt: 18 } }
                         ]
                     }
                 };
@@ -396,7 +390,7 @@ describe('MongoDriver', () => {
             it('should handle QueryAST with sort', async () => {
                 const ast = {
                     object: 'users',
-                    sort: [
+                    orderBy: [
                         { field: 'name', order: 'asc' as const }
                     ]
                 };