@objectql/driver-memory 4.0.0 → 4.0.2

package/dist/index.js

@@ -1,4 +1,6 @@
 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryDriver = void 0;
 /**
  * ObjectQL
  * Copyright (c) 2026-present ObjectStack Inc.
@@ -6,22 +8,20 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MemoryDriver = void 0;
 /**
  * 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)
  *
@@ -32,9 +32,10 @@ exports.MemoryDriver = void 0;
  * - Client-side state management
  * - Temporary data caching
  *
- * @version 4.0.0 - DriverInterface compliant
+ * @version 4.0.0 - DriverInterface compliant with Mingo integration
  */
 const types_1 = require("@objectql/types");
+const mingo_1 = require("mingo");
 /**
  * Memory Driver Implementation
  *
@@ -53,7 +54,13 @@ class MemoryDriver {
             joins: false,
             fullTextSearch: false,
             jsonFields: true,
-            arrayFields: true
+            arrayFields: true,
+            queryFilters: true,
+            queryAggregations: false,
+            querySorting: true,
+            queryPagination: true,
+            queryWindowFunctions: false,
+            querySubqueries: false
         };
         this.config = config;
         this.store = new Map();
@@ -91,39 +98,40 @@ class MemoryDriver {
     }
     /**
      * 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, query = {}, options) {
-        // 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 = [];
+        let records = [];
         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 mingo_1.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;
     }
     /**
      * Find a single record by ID or query.
@@ -209,49 +217,61 @@ class MemoryDriver {
         return deleted;
     }
     /**
-     * Count records matching filters.
+     * Count records matching filters using Mingo.
      */
     async count(objectName, filters, options) {
         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 = [];
         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 mingo_1.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, field, filters, options) {
         const pattern = `${objectName}:`;
-        const values = new Set();
-        for (const [key, record] of this.store.entries()) {
+        // Get all records for this object type
+        let records = [];
+        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 mingo_1.Query(mongoQuery);
+                records = mingoQuery.find(records).all();
+            }
+        }
+        // Extract distinct values
+        const values = new Set();
+        for (const record of records) {
+            const value = record[field];
+            if (value !== undefined && value !== null) {
+                values.add(value);
             }
         }
         return Array.from(values);
@@ -268,45 +288,73 @@ class MemoryDriver {
         return results;
     }
     /**
-     * Update multiple records matching filters.
+     * Update multiple records matching filters using Mingo.
      */
     async updateMany(objectName, filters, data, options) {
         const pattern = `${objectName}:`;
-        let count = 0;
+        // Get all records for this object type
+        let records = [];
+        const recordKeys = new Map();
         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 mingo_1.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++;
             }
         }
         return { modifiedCount: count };
     }
     /**
-     * Delete multiple records matching filters.
+     * Delete multiple records matching filters using Mingo.
      */
     async deleteMany(objectName, filters, options) {
         const pattern = `${objectName}:`;
-        const keysToDelete = [];
+        // Get all records for this object type
+        let records = [];
+        const recordKeys = new Map();
         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 mingo_1.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 };
     }
     /**
      * Clear all data from the store.
@@ -335,126 +383,142 @@ class MemoryDriver {
      * QueryAST format uses 'top' for limit, while UnifiedQuery uses 'limit'.
      * QueryAST sort is array of {field, order}, while UnifiedQuery is array of [field, order].
      */
-    normalizeQuery(query) {
-        if (!query)
-            return {};
-        const normalized = { ...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) => [
-                    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 }}] }
      */
-    applyFilters(records, filters) {
-        if (!filters || filters.length === 0) {
-            return records;
+    convertToMongoQuery(filters) {
+        if (!filters) {
+            return {};
         }
-        return records.filter(record => this.matchesFilters(record, filters));
-    }
-    /**
-     * Check if a single record matches the filter conditions.
-     */
-    matchesFilters(record, filters) {
-        if (!filters || filters.length === 0) {
-            return true;
+        // If filters is already an object (FilterCondition format), return it directly
+        if (!Array.isArray(filters)) {
+            return filters;
+        }
+        // Handle legacy array format
+        if (filters.length === 0) {
+            return {};
         }
-        let conditions = [];
-        let operators = [];
+        // Process the filter array to build MongoDB query
+        const conditions = [];
+        let currentLogic = 'and';
+        const logicGroups = [
+            { logic: 'and', conditions: [] }
+        ];
         for (const item of filters) {
             if (typeof item === 'string') {
                 // Logical operator (and/or)
-                operators.push(item.toLowerCase());
+                const newLogic = item.toLowerCase();
+                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));
+                // Convert single condition to MongoDB operator
+                const mongoCondition = this.convertConditionToMongo(field, operator, value);
+                if (mongoCondition) {
+                    logicGroups[logicGroups.length - 1].conditions.push(mongoCondition);
+                }
+            }
+        }
+        // Build final query from logic groups
+        if (logicGroups.length === 1 && logicGroups[0].conditions.length === 1) {
+            return logicGroups[0].conditions[0];
+        }
+        // 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 = [];
+        for (const group of logicGroups) {
+            if (group.conditions.length === 0)
+                continue;
+            if (group.conditions.length === 1) {
+                allConditions.push(group.conditions[0]);
+            }
+            else {
+                if (group.logic === 'or') {
+                    allConditions.push({ $or: group.conditions });
                 }
                 else {
-                    // Single condition
-                    const matches = this.evaluateCondition(record[field], operator, value);
-                    conditions.push(matches);
+                    allConditions.push({ $and: group.conditions });
                 }
             }
         }
-        // Combine conditions with operators
-        if (conditions.length === 0) {
-            return true;
+        if (allConditions.length === 0) {
+            return {};
+        }
+        else if (allConditions.length === 1) {
+            return allConditions[0];
         }
-        let result = conditions[0];
-        for (let i = 0; i < operators.length; i++) {
-            const op = operators[i];
-            const nextCondition = conditions[i + 1];
-            if (op === 'or') {
-                result = result || nextCondition;
+        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 { // 'and' or default
-                result = result && nextCondition;
+            else {
+                return { $and: allConditions };
             }
         }
-        return result;
     }
     /**
-     * Evaluate a single filter condition.
+     * Convert a single ObjectQL condition to MongoDB operator format.
      */
-    evaluateCondition(fieldValue, operator, compareValue) {
+    convertConditionToMongo(field, operator, value) {
         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 types_1.ObjectQLError({
                     code: 'UNSUPPORTED_OPERATOR',
@@ -463,11 +527,19 @@ class MemoryDriver {
         }
     }
     /**
-     * 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.
      */
-    applySort(records, sort) {
+    escapeRegex(str) {
+        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.
+     */
+    applyManualSort(records, sort) {
         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];
             let field;
@@ -494,9 +566,9 @@ class MemoryDriver {
                     return -1;
                 // Compare values
                 if (aVal < bVal)
-                    return direction === 'asc' ? -1 : 1;
+                    return direction.toLowerCase() === 'desc' ? 1 : -1;
                 if (aVal > bVal)
-                    return direction === 'asc' ? 1 : -1;
+                    return direction.toLowerCase() === 'desc' ? -1 : 1;
                 return 0;
             });
         }
@@ -535,18 +607,9 @@ class MemoryDriver {
      * @returns Query results with value and count
      */
     async executeQuery(ast, options) {
-        var _a;
         const objectName = ast.object || '';
-        // Convert QueryAST to legacy query format
-        const legacyQuery = {
-            fields: ast.fields,
-            filters: this.convertFilterNodeToLegacy(ast.filters),
-            sort: (_a = ast.sort) === null || _a === void 0 ? void 0 : _a.map((s) => [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,
             count: results.length
@@ -650,60 +713,6 @@ class MemoryDriver {
             };
         }
     }
-    /**
-     * Convert FilterNode (QueryAST format) to legacy filter array format
-     * This allows reuse of existing filter logic while supporting new QueryAST
-     *
-     * @private
-     */
-    convertFilterNodeToLegacy(node) {
-        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 = [];
-                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 = [];
-                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)
      *