@objectql/driver-memory 4.0.0 → 4.0.2

package/src/index.ts

@@ -1,3 +1,7 @@
+import { Data, Driver as DriverSpec } from '@objectstack/spec';
+type QueryAST = Data.QueryAST;
+type SortNode = Data.SortNode;
+type DriverInterface = DriverSpec.DriverInterface;
 /**
  * ObjectQL
  * Copyright (c) 2026-present ObjectStack Inc.
@@ -9,17 +13,17 @@
 /**
  * Memory Driver for ObjectQL (Production-Ready)
  * 
- * A high-performance in-memory driver for ObjectQL that stores data in JavaScript Maps.
+ * A high-performance in-memory driver for ObjectQL powered by Mingo.
  * Perfect for testing, development, and environments where persistence is not required.
  * 
- * Implements both the legacy Driver interface from @objectql/types and
- * the standard DriverInterface from @objectstack/spec for full compatibility
+ * Implements the Driver interface from @objectql/types which includes all methods
+ * from the standard DriverInterface from @objectstack/spec for full compatibility
  * with the new kernel-based plugin system.
  * 
  * ✅ Production-ready features:
- * - Zero external dependencies
+ * - MongoDB-like query engine powered by Mingo
  * - Thread-safe operations
- * - Full query support (filters, sorting, pagination)
+ * - Full query support (filters, sorting, pagination, aggregation)
  * - Atomic transactions
  * - High performance (no I/O overhead)
  * 
@@ -30,11 +34,11 @@
  * - Client-side state management
  * - Temporary data caching
  * 
- * @version 4.0.0 - DriverInterface compliant
+ * @version 4.0.0 - DriverInterface compliant with Mingo integration
  */
 
 import { Driver, ObjectQLError } from '@objectql/types';
-import { DriverInterface, QueryAST, FilterNode, SortNode } from '@objectstack/spec';
+import { Query } from 'mingo';
 
 /**
  * Command interface for executeCommand method
@@ -78,7 +82,7 @@ export interface MemoryDriverConfig {
  * 
  * Example: `users:user-123` → `{id: "user-123", name: "Alice", ...}`
  */
-export class MemoryDriver implements Driver, DriverInterface {
+export class MemoryDriver implements Driver {
     // Driver metadata (ObjectStack-compatible)
     public readonly name = 'MemoryDriver';
     public readonly version = '4.0.0';
@@ -87,7 +91,13 @@ export class MemoryDriver implements Driver, DriverInterface {
         joins: false,
         fullTextSearch: false,
         jsonFields: true,
-        arrayFields: true
+        arrayFields: true,
+        queryFilters: true,
+        queryAggregations: false,
+        querySorting: true,
+        queryPagination: true,
+        queryWindowFunctions: false,
+        querySubqueries: false
     };
 
     private store: Map<string, any>;
@@ -136,46 +146,47 @@ export class MemoryDriver implements Driver, DriverInterface {
 
     /**
      * Find multiple records matching the query criteria.
-     * Supports filtering, sorting, pagination, and field projection.
+     * Supports filtering, sorting, pagination, and field projection using Mingo.
      */
     async find(objectName: string, query: any = {}, options?: any): Promise<any[]> {
-        // Normalize query to support both legacy and QueryAST formats
-        const normalizedQuery = this.normalizeQuery(query);
-        
         // Get all records for this object type
         const pattern = `${objectName}:`;
-        let results: any[] = [];
+        let records: any[] = [];
         
         for (const [key, value] of this.store.entries()) {
             if (key.startsWith(pattern)) {
-                results.push({ ...value });
+                records.push({ ...value });
             }
         }
         
-        // Apply filters
-        if (normalizedQuery.filters) {
-            results = this.applyFilters(results, normalizedQuery.filters);
+        // Convert ObjectQL filters to MongoDB query format
+        const mongoQuery = this.convertToMongoQuery(query.where);
+        
+        // Apply filters using Mingo
+        if (mongoQuery && Object.keys(mongoQuery).length > 0) {
+            const mingoQuery = new Query(mongoQuery);
+            records = mingoQuery.find(records).all();
         }
         
-        // Apply sorting
-        if (normalizedQuery.sort && Array.isArray(normalizedQuery.sort)) {
-            results = this.applySort(results, normalizedQuery.sort);
+        // Apply sorting manually (Mingo's sort has issues with CJS builds)
+        if (query.orderBy && Array.isArray(query.orderBy) && query.orderBy.length > 0) {
+            records = this.applyManualSort(records, query.orderBy);
         }
         
         // Apply pagination
-        if (normalizedQuery.skip) {
-            results = results.slice(normalizedQuery.skip);
+        if (query.offset) {
+            records = records.slice(query.offset);
         }
-        if (normalizedQuery.limit) {
-            results = results.slice(0, normalizedQuery.limit);
+        if (query.limit) {
+            records = records.slice(0, query.limit);
         }
         
         // Apply field projection
-        if (normalizedQuery.fields && Array.isArray(normalizedQuery.fields)) {
-            results = results.map(doc => this.projectFields(doc, normalizedQuery.fields));
+        if (query.fields && Array.isArray(query.fields)) {
+            records = records.map(doc => this.projectFields(doc, query.fields));
         }
         
-        return results;
+        return records;
     }
 
     /**
@@ -276,55 +287,70 @@ export class MemoryDriver implements Driver, DriverInterface {
     }
 
     /**
-     * Count records matching filters.
+     * Count records matching filters using Mingo.
      */
     async count(objectName: string, filters: any, options?: any): Promise<number> {
         const pattern = `${objectName}:`;
-        let count = 0;
         
-        // Extract actual filters from query object if needed
-        let actualFilters = filters;
-        if (filters && !Array.isArray(filters) && filters.filters) {
-            actualFilters = filters.filters;
-        }
-        
-        // If no filters, return total count
-        if (!actualFilters || (Array.isArray(actualFilters) && actualFilters.length === 0)) {
-            for (const key of this.store.keys()) {
-                if (key.startsWith(pattern)) {
-                    count++;
-                }
-            }
-            return count;
+        // Extract where condition from query object if needed
+        let whereCondition = filters;
+        if (filters && !Array.isArray(filters) && filters.where) {
+            whereCondition = filters.where;
         }
         
-        // Count only records matching filters
+        // Get all records for this object type
+        let records: any[] = [];
         for (const [key, value] of this.store.entries()) {
             if (key.startsWith(pattern)) {
-                if (this.matchesFilters(value, actualFilters)) {
-                    count++;
-                }
+                records.push(value);
             }
         }
         
-        return count;
+        // If no filters, return total count
+        if (!whereCondition || (Array.isArray(whereCondition) && whereCondition.length === 0)) {
+            return records.length;
+        }
+        
+        // Convert to MongoDB query and use Mingo to count
+        const mongoQuery = this.convertToMongoQuery(whereCondition);
+        if (mongoQuery && Object.keys(mongoQuery).length > 0) {
+            const mingoQuery = new Query(mongoQuery);
+            const matchedRecords = mingoQuery.find(records).all();
+            return matchedRecords.length;
+        }
+        
+        return records.length;
     }
 
     /**
-     * Get distinct values for a field.
+     * Get distinct values for a field using Mingo.
      */
     async distinct(objectName: string, field: string, filters?: any, options?: any): Promise<any[]> {
         const pattern = `${objectName}:`;
-        const values = new Set<any>();
         
-        for (const [key, record] of this.store.entries()) {
+        // Get all records for this object type
+        let records: any[] = [];
+        for (const [key, value] of this.store.entries()) {
             if (key.startsWith(pattern)) {
-                if (!filters || this.matchesFilters(record, filters)) {
-                    const value = record[field];
-                    if (value !== undefined && value !== null) {
-                        values.add(value);
-                    }
-                }
+                records.push(value);
+            }
+        }
+        
+        // Apply filters using Mingo if provided
+        if (filters) {
+            const mongoQuery = this.convertToMongoQuery(filters);
+            if (mongoQuery && Object.keys(mongoQuery).length > 0) {
+                const mingoQuery = new Query(mongoQuery);
+                records = mingoQuery.find(records).all();
+            }
+        }
+        
+        // Extract distinct values
+        const values = new Set<any>();
+        for (const record of records) {
+            const value = record[field];
+            if (value !== undefined && value !== null) {
+                values.add(value);
             }
         }
         
@@ -344,25 +370,45 @@ export class MemoryDriver implements Driver, DriverInterface {
     }
 
     /**
-     * Update multiple records matching filters.
+     * Update multiple records matching filters using Mingo.
      */
     async updateMany(objectName: string, filters: any, data: any, options?: any): Promise<any> {
         const pattern = `${objectName}:`;
-        let count = 0;
+        
+        // Get all records for this object type
+        let records: any[] = [];
+        const recordKeys = new Map<string, string>();
         
         for (const [key, record] of this.store.entries()) {
             if (key.startsWith(pattern)) {
-                if (this.matchesFilters(record, filters)) {
-                    const updated = {
-                        ...record,
-                        ...data,
-                        id: record.id, // Preserve ID
-                        created_at: record.created_at, // Preserve created_at
-                        updated_at: new Date().toISOString()
-                    };
-                    this.store.set(key, updated);
-                    count++;
-                }
+                records.push(record);
+                recordKeys.set(record.id, key);
+            }
+        }
+        
+        // Apply filters using Mingo
+        const mongoQuery = this.convertToMongoQuery(filters);
+        let matchedRecords = records;
+        
+        if (mongoQuery && Object.keys(mongoQuery).length > 0) {
+            const mingoQuery = new Query(mongoQuery);
+            matchedRecords = mingoQuery.find(records).all();
+        }
+        
+        // Update matched records
+        let count = 0;
+        for (const record of matchedRecords) {
+            const key = recordKeys.get(record.id);
+            if (key) {
+                const updated = {
+                    ...record,
+                    ...data,
+                    id: record.id, // Preserve ID
+                    created_at: record.created_at, // Preserve created_at
+                    updated_at: new Date().toISOString()
+                };
+                this.store.set(key, updated);
+                count++;
             }
         }
         
@@ -370,25 +416,40 @@ export class MemoryDriver implements Driver, DriverInterface {
     }
 
     /**
-     * Delete multiple records matching filters.
+     * Delete multiple records matching filters using Mingo.
      */
     async deleteMany(objectName: string, filters: any, options?: any): Promise<any> {
         const pattern = `${objectName}:`;
-        const keysToDelete: string[] = [];
+        
+        // Get all records for this object type
+        let records: any[] = [];
+        const recordKeys = new Map<string, string>();
         
         for (const [key, record] of this.store.entries()) {
             if (key.startsWith(pattern)) {
-                if (this.matchesFilters(record, filters)) {
-                    keysToDelete.push(key);
-                }
+                records.push(record);
+                recordKeys.set(record.id, key);
             }
         }
         
-        for (const key of keysToDelete) {
-            this.store.delete(key);
+        // Apply filters using Mingo
+        const mongoQuery = this.convertToMongoQuery(filters);
+        let matchedRecords = records;
+        
+        if (mongoQuery && Object.keys(mongoQuery).length > 0) {
+            const mingoQuery = new Query(mongoQuery);
+            matchedRecords = mingoQuery.find(records).all();
+        }
+        
+        // Delete matched records
+        for (const record of matchedRecords) {
+            const key = recordKeys.get(record.id);
+            if (key) {
+                this.store.delete(key);
+            }
         }
         
-        return { deletedCount: keysToDelete.length };
+        return { deletedCount: matchedRecords.length };
     }
 
     /**
@@ -422,137 +483,157 @@ export class MemoryDriver implements Driver, DriverInterface {
      * QueryAST format uses 'top' for limit, while UnifiedQuery uses 'limit'.
      * QueryAST sort is array of {field, order}, while UnifiedQuery is array of [field, order].
      */
-    private normalizeQuery(query: any): any {
-        if (!query) return {};
-        
-        const normalized: any = { ...query };
-        
-        // Normalize limit/top
-        if (normalized.top !== undefined && normalized.limit === undefined) {
-            normalized.limit = normalized.top;
-        }
-        
-        // 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'
-                ]);
-            }
-        }
-        
-        return normalized;
-    }
-
     /**
-     * Apply filters to an array of records (in-memory filtering).
+     * Convert ObjectQL filters to MongoDB query format for Mingo.
+     * 
+     * Supports both:
+     * 1. Legacy ObjectQL filter format (array):
+     *    [['field', 'operator', value], 'or', ['field2', 'operator', value2']]
+     * 2. New FilterCondition format (object - already MongoDB-like):
+     *    { $and: [{ field: { $eq: value }}, { field2: { $gt: value2 }}] }
      * 
-     * Supports ObjectQL filter format:
-     * [
-     *   ['field', 'operator', value],
-     *   'or',
-     *   ['field2', 'operator', value2]
-     * ]
+     * Converts to MongoDB query format:
+     * { $or: [{ field: { $operator: value }}, { field2: { $operator: value2 }}] }
      */
-    private applyFilters(records: any[], filters: any[]): any[] {
-        if (!filters || filters.length === 0) {
-            return records;
+    private convertToMongoQuery(filters?: any[] | Record<string, any>): Record<string, any> {
+        if (!filters) {
+            return {};
         }
         
-        return records.filter(record => this.matchesFilters(record, filters));
-    }
-
-    /**
-     * Check if a single record matches the filter conditions.
-     */
-    private matchesFilters(record: any, filters: any[]): boolean {
-        if (!filters || filters.length === 0) {
-            return true;
+        // If filters is already an object (FilterCondition format), return it directly
+        if (!Array.isArray(filters)) {
+            return filters;
         }
         
-        let conditions: boolean[] = [];
-        let operators: string[] = [];
+        // Handle legacy array format
+        if (filters.length === 0) {
+            return {};
+        }
+        
+        // Process the filter array to build MongoDB query
+        const conditions: Record<string, any>[] = [];
+        let currentLogic: 'and' | 'or' = 'and';
+        const logicGroups: { logic: 'and' | 'or', conditions: Record<string, any>[] }[] = [
+            { logic: 'and', conditions: [] }
+        ];
         
         for (const item of filters) {
             if (typeof item === 'string') {
                 // Logical operator (and/or)
-                operators.push(item.toLowerCase());
+                const newLogic = item.toLowerCase() as 'and' | 'or';
+                if (newLogic !== currentLogic) {
+                    currentLogic = newLogic;
+                    logicGroups.push({ logic: currentLogic, conditions: [] });
+                }
             } else if (Array.isArray(item)) {
                 const [field, operator, value] = item;
                 
-                // Handle nested filter groups
-                if (typeof field !== 'string') {
-                    // Nested group - recursively evaluate
-                    conditions.push(this.matchesFilters(record, item));
-                } else {
-                    // Single condition
-                    const matches = this.evaluateCondition(record[field], operator, value);
-                    conditions.push(matches);
+                // Convert single condition to MongoDB operator
+                const mongoCondition = this.convertConditionToMongo(field, operator, value);
+                if (mongoCondition) {
+                    logicGroups[logicGroups.length - 1].conditions.push(mongoCondition);
                 }
             }
         }
         
-        // Combine conditions with operators
-        if (conditions.length === 0) {
-            return true;
+        // Build final query from logic groups
+        if (logicGroups.length === 1 && logicGroups[0].conditions.length === 1) {
+            return logicGroups[0].conditions[0];
         }
         
-        let result = conditions[0];
-        for (let i = 0; i < operators.length; i++) {
-            const op = operators[i];
-            const nextCondition = conditions[i + 1];
+        // If there's only one group with multiple conditions, use its logic operator
+        if (logicGroups.length === 1) {
+            const group = logicGroups[0];
+            if (group.logic === 'or') {
+                return { $or: group.conditions };
+            } else {
+                return { $and: group.conditions };
+            }
+        }
+        
+        // Multiple groups - flatten all conditions and determine the top-level operator
+        const allConditions: Record<string, any>[] = [];
+        for (const group of logicGroups) {
+            if (group.conditions.length === 0) continue;
             
-            if (op === 'or') {
-                result = result || nextCondition;
-            } else { // 'and' or default
-                result = result && nextCondition;
+            if (group.conditions.length === 1) {
+                allConditions.push(group.conditions[0]);
+            } else {
+                if (group.logic === 'or') {
+                    allConditions.push({ $or: group.conditions });
+                } else {
+                    allConditions.push({ $and: group.conditions });
+                }
             }
         }
         
-        return result;
+        if (allConditions.length === 0) {
+            return {};
+        } else if (allConditions.length === 1) {
+            return allConditions[0];
+        } else {
+            // Determine top-level operator: use OR if any non-empty group has OR logic
+            const hasOrLogic = logicGroups.some(g => g.logic === 'or' && g.conditions.length > 0);
+            if (hasOrLogic) {
+                return { $or: allConditions };
+            } else {
+                return { $and: allConditions };
+            }
+        }
     }
 
     /**
-     * Evaluate a single filter condition.
+     * Convert a single ObjectQL condition to MongoDB operator format.
      */
-    private evaluateCondition(fieldValue: any, operator: string, compareValue: any): boolean {
+    private convertConditionToMongo(field: string, operator: string, value: any): Record<string, any> | null {
         switch (operator) {
             case '=':
             case '==':
-                return fieldValue === compareValue;
+                return { [field]: value };
+            
             case '!=':
             case '<>':
-                return fieldValue !== compareValue;
+                return { [field]: { $ne: value } };
+            
             case '>':
-                return fieldValue > compareValue;
+                return { [field]: { $gt: value } };
+            
             case '>=':
-                return fieldValue >= compareValue;
+                return { [field]: { $gte: value } };
+            
             case '<':
-                return fieldValue < compareValue;
+                return { [field]: { $lt: value } };
+            
             case '<=':
-                return fieldValue <= compareValue;
+                return { [field]: { $lte: value } };
+            
             case 'in':
-                return Array.isArray(compareValue) && compareValue.includes(fieldValue);
+                return { [field]: { $in: value } };
+            
             case 'nin':
             case 'not in':
-                return Array.isArray(compareValue) && !compareValue.includes(fieldValue);
+                return { [field]: { $nin: value } };
+            
             case 'contains':
             case 'like':
-                return String(fieldValue).toLowerCase().includes(String(compareValue).toLowerCase());
+                // MongoDB regex for case-insensitive contains
+                // Escape special regex characters to prevent ReDoS and ensure literal matching
+                return { [field]: { $regex: new RegExp(this.escapeRegex(value), 'i') } };
+            
             case 'startswith':
             case 'starts_with':
-                return String(fieldValue).toLowerCase().startsWith(String(compareValue).toLowerCase());
+                return { [field]: { $regex: new RegExp(`^${this.escapeRegex(value)}`, 'i') } };
+            
             case 'endswith':
             case 'ends_with':
-                return String(fieldValue).toLowerCase().endsWith(String(compareValue).toLowerCase());
+                return { [field]: { $regex: new RegExp(`${this.escapeRegex(value)}$`, 'i') } };
+            
             case 'between':
-                return Array.isArray(compareValue) && 
-                       fieldValue >= compareValue[0] && 
-                       fieldValue <= compareValue[1];
+                if (Array.isArray(value) && value.length === 2) {
+                    return { [field]: { $gte: value[0], $lte: value[1] } };
+                }
+                return null;
+            
             default:
                 throw new ObjectQLError({
                     code: 'UNSUPPORTED_OPERATOR',
@@ -562,12 +643,21 @@ export class MemoryDriver implements Driver, DriverInterface {
     }
 
     /**
-     * Apply sorting to an array of records (in-memory sorting).
+     * Escape special regex characters to prevent ReDoS and ensure literal matching.
+     * This is crucial for security when using user input in regex patterns.
+     */
+    private escapeRegex(str: string): string {
+        return String(str).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    }
+
+    /**
+     * Apply manual sorting to an array of records.
+     * This is used instead of Mingo's sort to avoid CJS build issues.
      */
-    private applySort(records: any[], sort: any[]): any[] {
+    private applyManualSort(records: any[], sort: any[]): any[] {
         const sorted = [...records];
         
-        // Apply sorts in reverse order for correct precedence
+        // Apply sorts in reverse order for correct multi-field precedence
         for (let i = sort.length - 1; i >= 0; i--) {
             const sortItem = sort[i];
             
@@ -593,8 +683,8 @@ export class MemoryDriver implements Driver, DriverInterface {
                 if (bVal == null) return -1;
                 
                 // Compare values
-                if (aVal < bVal) return direction === 'asc' ? -1 : 1;
-                if (aVal > bVal) return direction === 'asc' ? 1 : -1;
+                if (aVal < bVal) return direction.toLowerCase() === 'desc' ? 1 : -1;
+                if (aVal > bVal) return direction.toLowerCase() === 'desc' ? -1 : 1;
                 return 0;
             });
         }
@@ -640,17 +730,8 @@ export class MemoryDriver implements Driver, DriverInterface {
     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,
-            offset: ast.skip,
-        };
-        
-        // Use existing find method
-        const results = await this.find(objectName, legacyQuery, options);
+        // Use existing find method with QueryAST directly
+        const results = await this.find(objectName, ast, options);
         
         return {
             value: results,
@@ -762,63 +843,6 @@ export class MemoryDriver implements Driver, DriverInterface {
         }
     }
 
-    /**
-     * Convert FilterNode (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':
-                // Convert AND node to array with 'and' separator
-                if (!node.children || node.children.length === 0) return undefined;
-                const andResults: any[] = [];
-                for (const child of node.children) {
-                    const converted = this.convertFilterNodeToLegacy(child);
-                    if (converted) {
-                        if (andResults.length > 0) {
-                            andResults.push('and');
-                        }
-                        andResults.push(...(Array.isArray(converted) ? converted : [converted]));
-                    }
-                }
-                return andResults.length > 0 ? andResults : undefined;
-            
-            case 'or':
-                // Convert OR node to array with 'or' separator
-                if (!node.children || node.children.length === 0) return undefined;
-                const orResults: any[] = [];
-                for (const child of node.children) {
-                    const converted = this.convertFilterNodeToLegacy(child);
-                    if (converted) {
-                        if (orResults.length > 0) {
-                            orResults.push('or');
-                        }
-                        orResults.push(...(Array.isArray(converted) ? converted : [converted]));
-                    }
-                }
-                return orResults.length > 0 ? orResults : undefined;
-            
-            case 'not':
-                // NOT is complex - we'll just process the first child for now
-                if (node.children && node.children.length > 0) {
-                    return this.convertFilterNodeToLegacy(node.children[0]);
-                }
-                return undefined;
-            
-            default:
-                return undefined;
-        }
-    }
-
     /**
      * Execute command (alternative signature for compatibility)
      *