@objectql/driver-memory 3.0.1 → 4.0.1

package/dist/index.js

@@ -1,14 +1,27 @@
 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryDriver = void 0;
+/**
+ * ObjectQL
+ * Copyright (c) 2026-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
 /**
  * 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 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)
  *
@@ -18,10 +31,11 @@
  * - Edge/Worker environments (Cloudflare Workers, Deno Deploy)
  * - Client-side state management
  * - Temporary data caching
+ *
+ * @version 4.0.0 - DriverInterface compliant with Mingo integration
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MemoryDriver = void 0;
 const types_1 = require("@objectql/types");
+const mingo_1 = require("mingo");
 /**
  * Memory Driver Implementation
  *
@@ -32,6 +46,22 @@ const types_1 = require("@objectql/types");
  */
 class MemoryDriver {
     constructor(config = {}) {
+        // Driver metadata (ObjectStack-compatible)
+        this.name = 'MemoryDriver';
+        this.version = '4.0.0';
+        this.supports = {
+            transactions: false,
+            joins: false,
+            fullTextSearch: false,
+            jsonFields: true,
+            arrayFields: true,
+            queryFilters: true,
+            queryAggregations: false,
+            querySorting: true,
+            queryPagination: true,
+            queryWindowFunctions: false,
+            querySubqueries: false
+        };
         this.config = config;
         this.store = new Map();
         this.idCounters = new Map();
@@ -40,6 +70,20 @@ class MemoryDriver {
             this.loadInitialData(config.initialData);
         }
     }
+    /**
+     * Connect to the database (for DriverInterface compatibility)
+     * This is a no-op for memory driver as there's no external connection.
+     */
+    async connect() {
+        // No-op: Memory driver doesn't need connection
+    }
+    /**
+     * Check database connection health
+     */
+    async checkHealth() {
+        // Memory driver is always healthy if it exists
+        return true;
+    }
     /**
      * Load initial data into the store.
      */
@@ -54,37 +98,42 @@ 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 (query.filters) {
-            results = this.applyFilters(results, query.filters);
+        // Convert ObjectQL filters to MongoDB query format
+        const mongoQuery = this.convertToMongoQuery(normalizedQuery.filters);
+        // 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 (query.sort && Array.isArray(query.sort)) {
-            results = this.applySort(results, query.sort);
+        // Apply sorting manually (Mingo's sort has issues with CJS builds)
+        if (normalizedQuery.sort && Array.isArray(normalizedQuery.sort) && normalizedQuery.sort.length > 0) {
+            records = this.applyManualSort(records, normalizedQuery.sort);
         }
         // Apply pagination
-        if (query.skip) {
-            results = results.slice(query.skip);
+        if (normalizedQuery.skip) {
+            records = records.slice(normalizedQuery.skip);
         }
-        if (query.limit) {
-            results = results.slice(0, query.limit);
+        if (normalizedQuery.limit) {
+            records = records.slice(0, normalizedQuery.limit);
         }
         // Apply field projection
-        if (query.fields && Array.isArray(query.fields)) {
-            results = results.map(doc => this.projectFields(doc, query.fields));
+        if (normalizedQuery.fields && Array.isArray(normalizedQuery.fields)) {
+            records = records.map(doc => this.projectFields(doc, normalizedQuery.fields));
         }
-        return results;
+        return records;
     }
     /**
      * Find a single record by ID or query.
@@ -170,49 +219,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;
-        }
-        // 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 (!actualFilters || (Array.isArray(actualFilters) && actualFilters.length === 0)) {
+            return records.length;
+        }
+        // Convert to MongoDB query and use Mingo to count
+        const mongoQuery = this.convertToMongoQuery(actualFilters);
+        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);
@@ -229,45 +290,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.
@@ -290,7 +379,36 @@ class MemoryDriver {
     }
     // ========== Helper Methods ==========
     /**
-     * Apply filters to an array of records (in-memory filtering).
+     * Normalizes query format to support both legacy UnifiedQuery and QueryAST formats.
+     * This ensures backward compatibility while supporting the new @objectstack/spec interface.
+     *
+     * 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;
+    }
+    /**
+     * Convert ObjectQL filters to MongoDB query format for Mingo.
      *
      * Supports ObjectQL filter format:
      * [
@@ -298,95 +416,126 @@ class MemoryDriver {
      *   '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;
-        }
-        return records.filter(record => this.matchesFilters(record, filters));
-    }
-    /**
-     * Check if a single record matches the filter conditions.
-     */
-    matchesFilters(record, filters) {
+    convertToMongoQuery(filters) {
         if (!filters || filters.length === 0) {
-            return true;
+            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 {};
         }
-        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 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 { // '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',
@@ -395,11 +544,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;
@@ -426,9 +583,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;
             });
         }
@@ -456,6 +613,198 @@ class MemoryDriver {
         const timestamp = Date.now();
         return `${objectName}-${timestamp}-${counter}`;
     }
+    /**
+     * Execute a query using QueryAST (DriverInterface v4.0 method)
+     *
+     * This is the new standard method for query execution using the
+     * ObjectStack QueryAST format.
+     *
+     * @param ast - The QueryAST representing the query
+     * @param options - Optional execution options
+     * @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);
+        return {
+            value: results,
+            count: results.length
+        };
+    }
+    /**
+     * Execute a command (DriverInterface v4.0 method)
+     *
+     * This method handles all mutation operations (create, update, delete)
+     * using a unified command interface.
+     *
+     * @param command - The command to execute
+     * @param parameters - Optional command parameters (unused in this driver)
+     * @param options - Optional execution options
+     * @returns Command execution result
+     */
+    async executeCommand(command, options) {
+        try {
+            const cmdOptions = { ...options, ...command.options };
+            switch (command.type) {
+                case 'create':
+                    if (!command.data) {
+                        throw new Error('Create command requires data');
+                    }
+                    const created = await this.create(command.object, command.data, cmdOptions);
+                    return {
+                        success: true,
+                        data: created,
+                        affected: 1
+                    };
+                case 'update':
+                    if (!command.id || !command.data) {
+                        throw new Error('Update command requires id and data');
+                    }
+                    const updated = await this.update(command.object, command.id, command.data, cmdOptions);
+                    return {
+                        success: true,
+                        data: updated,
+                        affected: 1
+                    };
+                case 'delete':
+                    if (!command.id) {
+                        throw new Error('Delete command requires id');
+                    }
+                    await this.delete(command.object, command.id, cmdOptions);
+                    return {
+                        success: true,
+                        affected: 1
+                    };
+                case 'bulkCreate':
+                    if (!command.records || !Array.isArray(command.records)) {
+                        throw new Error('BulkCreate command requires records array');
+                    }
+                    const bulkCreated = [];
+                    for (const record of command.records) {
+                        const created = await this.create(command.object, record, cmdOptions);
+                        bulkCreated.push(created);
+                    }
+                    return {
+                        success: true,
+                        data: bulkCreated,
+                        affected: command.records.length
+                    };
+                case 'bulkUpdate':
+                    if (!command.updates || !Array.isArray(command.updates)) {
+                        throw new Error('BulkUpdate command requires updates array');
+                    }
+                    const updateResults = [];
+                    for (const update of command.updates) {
+                        const result = await this.update(command.object, update.id, update.data, cmdOptions);
+                        updateResults.push(result);
+                    }
+                    return {
+                        success: true,
+                        data: updateResults,
+                        affected: command.updates.length
+                    };
+                case 'bulkDelete':
+                    if (!command.ids || !Array.isArray(command.ids)) {
+                        throw new Error('BulkDelete command requires ids array');
+                    }
+                    let deleted = 0;
+                    for (const id of command.ids) {
+                        const result = await this.delete(command.object, id, cmdOptions);
+                        if (result)
+                            deleted++;
+                    }
+                    return {
+                        success: true,
+                        affected: deleted
+                    };
+                default:
+                    throw new Error(`Unknown command type: ${command.type}`);
+            }
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error.message || 'Command execution failed',
+                affected: 0
+            };
+        }
+    }
+    /**
+     * 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)
+     *
+     * @param command - Command string or object
+     * @param parameters - Command parameters
+     * @param options - Execution options
+     */
+    async execute(command, parameters, options) {
+        // For memory driver, this is primarily for compatibility
+        // We don't support raw SQL/commands
+        throw new Error('Memory driver does not support raw command execution. Use executeCommand() instead.');
+    }
 }
 exports.MemoryDriver = MemoryDriver;
 //# sourceMappingURL=index.js.map