@ductape/sdk 0.0.4-v42 → 0.0.4-v44

package/dist/database/adapters/mongodb.adapter.js

@@ -0,0 +1,882 @@
+"use strict";
+/**
+ * MongoDB Database Adapter
+ * Implements database operations for MongoDB
+ */
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MongoDBAdapter = void 0;
+const base_adapter_1 = require("./base.adapter");
+const database_types_1 = require("../types/database.types");
+const query_types_1 = require("../types/query.types");
+/**
+ * MongoDB Connection wrapper
+ */
+class MongoDBConnection {
+    constructor(id, client, db) {
+        this.id = id;
+        this.type = database_types_1.DatabaseType.MONGODB;
+        this.status = database_types_1.ConnectionStatus.CONNECTED;
+        this.client = client;
+        this.db = db;
+    }
+    async connect() {
+        var _a;
+        if (this.client && !((_a = this.client.topology) === null || _a === void 0 ? void 0 : _a.isConnected())) {
+            await this.client.connect();
+            this.status = database_types_1.ConnectionStatus.CONNECTED;
+        }
+    }
+    async disconnect() {
+        if (this.client) {
+            await this.client.close();
+            this.status = database_types_1.ConnectionStatus.DISCONNECTED;
+        }
+    }
+    isConnected() {
+        var _a, _b;
+        return this.status === database_types_1.ConnectionStatus.CONNECTED && ((_b = (_a = this.client) === null || _a === void 0 ? void 0 : _a.topology) === null || _b === void 0 ? void 0 : _b.isConnected());
+    }
+    getClient() {
+        return this.db;
+    }
+}
+/**
+ * MongoDB Adapter
+ */
+class MongoDBAdapter extends base_adapter_1.BaseDatabaseAdapter {
+    constructor() {
+        super(...arguments);
+        this.type = database_types_1.DatabaseType.MONGODB;
+        this.connectionPool = new Map();
+    }
+    // ==================== Connection Methods ====================
+    async connect(config) {
+        try {
+            // TODO: Import mongodb library dynamically
+            // const { MongoClient } = await import('mongodb');
+            // TODO: Create connection URI
+            // const uri = config.connectionString ||
+            //   `mongodb://${config.user}:${config.password}@${config.host}:${config.port || 27017}`;
+            // TODO: Create MongoDB client
+            // const client = new MongoClient(uri, {
+            //   ...config.options,
+            // });
+            // TODO: Connect to MongoDB
+            // await client.connect();
+            // TODO: Get database
+            // const db = client.db(config.database);
+            // TODO: Create connection wrapper
+            // const connectionId = `mongodb-${config.database}-${Date.now()}`;
+            // const connection = new MongoDBConnection(connectionId, client, db);
+            // return connection;
+            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.CONNECTION_ERROR, 'MongoDB adapter not fully implemented yet');
+        }
+        catch (error) {
+            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.CONNECTION_ERROR, `Failed to connect to MongoDB: ${error.message}`, error);
+        }
+    }
+    async disconnect(connection) {
+        await connection.disconnect();
+        this.connectionPool.delete(connection.id);
+    }
+    async testConnection(connection) {
+        const startTime = Date.now();
+        try {
+            const db = connection.getClient();
+            // Test with a simple ping command
+            await db.admin().ping();
+            const responseTime = Date.now() - startTime;
+            return {
+                connected: true,
+                message: 'Successfully connected to MongoDB',
+                databaseType: 'mongodb',
+                responseTime,
+            };
+        }
+        catch (error) {
+            return {
+                connected: false,
+                message: 'Failed to connect to MongoDB',
+                databaseType: 'mongodb',
+                responseTime: Date.now() - startTime,
+                error: error.message,
+            };
+        }
+    }
+    // ==================== Transaction Methods ====================
+    async beginTransaction(connection) {
+        const client = connection.getClient();
+        const session = client.startSession();
+        session.startTransaction();
+        return session;
+    }
+    async commitTransaction(connection, transaction) {
+        await transaction.commitTransaction();
+        await transaction.endSession();
+    }
+    async rollbackTransaction(connection, transaction) {
+        await transaction.abortTransaction();
+        await transaction.endSession();
+    }
+    async createSavepoint(connection, transaction, savepointName) {
+        // MongoDB doesn't support savepoints in the same way as SQL databases
+        // We can simulate this by tracking state, but for now, this is a placeholder
+        throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, 'MongoDB does not support savepoints');
+    }
+    async rollbackToSavepoint(connection, transaction, savepointName) {
+        throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, 'MongoDB does not support savepoints');
+    }
+    async releaseSavepoint(connection, transaction, savepointName) {
+        throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, 'MongoDB does not support savepoints');
+    }
+    // ==================== Query Methods ====================
+    async query(connection, options) {
+        const startTime = Date.now();
+        try {
+            const db = connection.getClient();
+            const collection = db.collection(options.table);
+            // Build MongoDB filter from where clause
+            const filter = this.buildMongoFilter(options.where);
+            // Build MongoDB query
+            let query = collection.find(filter);
+            // Apply projection (select)
+            if (options.select && options.select.length > 0) {
+                const projection = {};
+                options.select.forEach((field) => {
+                    projection[field] = 1;
+                });
+                query = query.project(projection);
+            }
+            // Apply sorting
+            if (options.orderBy) {
+                const sort = {};
+                const orderByArray = Array.isArray(options.orderBy) ? options.orderBy : [options.orderBy];
+                orderByArray.forEach((order) => {
+                    sort[order.column] = order.order === query_types_1.SortOrder.DESC ? -1 : 1;
+                });
+                query = query.sort(sort);
+            }
+            // Apply limit and offset
+            if (options.limit) {
+                query = query.limit(options.limit);
+            }
+            if (options.offset) {
+                query = query.skip(options.offset);
+            }
+            const data = await query.toArray();
+            const executionTime = Date.now() - startTime;
+            return {
+                data,
+                count: data.length,
+                executionTime,
+                databaseType: 'mongodb',
+            };
+        }
+        catch (error) {
+            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `MongoDB query failed: ${error.message}`, error);
+        }
+    }
+    async insert(connection, options) {
+        const startTime = Date.now();
+        try {
+            const db = connection.getClient();
+            const collection = db.collection(options.table);
+            const dataArray = Array.isArray(options.data) ? options.data : [options.data];
+            const result = await collection.insertMany(dataArray);
+            const executionTime = Date.now() - startTime;
+            return {
+                insertedCount: result.insertedCount,
+                insertedIds: Object.values(result.insertedIds).map((id) => id.toString()),
+                data: options.returning ? dataArray : undefined,
+                executionTime,
+                success: true,
+            };
+        }
+        catch (error) {
+            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `MongoDB insert failed: ${error.message}`, error);
+        }
+    }
+    async update(connection, options) {
+        const startTime = Date.now();
+        try {
+            const db = connection.getClient();
+            const collection = db.collection(options.table);
+            const filter = this.buildMongoFilter(options.where);
+            const update = { $set: options.data };
+            const result = await collection.updateMany(filter, update);
+            const executionTime = Date.now() - startTime;
+            return {
+                updatedCount: result.modifiedCount,
+                matchedCount: result.matchedCount,
+                executionTime,
+                success: true,
+            };
+        }
+        catch (error) {
+            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `MongoDB update failed: ${error.message}`, error);
+        }
+    }
+    async delete(connection, options) {
+        const startTime = Date.now();
+        try {
+            const db = connection.getClient();
+            const collection = db.collection(options.table);
+            const filter = this.buildMongoFilter(options.where);
+            const result = await collection.deleteMany(filter);
+            const executionTime = Date.now() - startTime;
+            return {
+                deletedCount: result.deletedCount,
+                executionTime,
+                success: true,
+            };
+        }
+        catch (error) {
+            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `MongoDB delete failed: ${error.message}`, error);
+        }
+    }
+    async upsert(connection, options) {
+        const startTime = Date.now();
+        try {
+            const db = connection.getClient();
+            const collection = db.collection(options.table);
+            // Upsert only works with single records
+            const data = Array.isArray(options.data) ? options.data[0] : options.data;
+            // Build conflict filter
+            const filter = {};
+            options.uniqueColumns.forEach((col) => {
+                if (data[col] !== undefined) {
+                    filter[col] = data[col];
+                }
+            });
+            const update = { $set: data };
+            const result = await collection.updateOne(filter, update, { upsert: true });
+            const executionTime = Date.now() - startTime;
+            return {
+                insertedCount: result.upsertedCount || 0,
+                updatedCount: result.modifiedCount,
+                affectedCount: result.upsertedCount + result.modifiedCount,
+                executionTime,
+                success: true,
+            };
+        }
+        catch (error) {
+            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `MongoDB upsert failed: ${error.message}`, error);
+        }
+    }
+    async executeRaw(connection, options) {
+        const startTime = Date.now();
+        try {
+            const db = connection.getClient();
+            // For MongoDB, raw queries might be aggregation pipelines or commands
+            // This is a simplified implementation
+            const result = await db.command(options.query);
+            const executionTime = Date.now() - startTime;
+            return {
+                rows: Array.isArray(result) ? result : [result],
+                rowCount: Array.isArray(result) ? result.length : 1,
+                executionTime,
+            };
+        }
+        catch (error) {
+            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `MongoDB raw query failed: ${error.message}`, error);
+        }
+    }
+    // ==================== Aggregation Methods ====================
+    async count(connection, options) {
+        try {
+            const db = connection.getClient();
+            const collection = db.collection(options.table);
+            const filter = this.buildMongoFilter(options.where);
+            return await collection.countDocuments(filter);
+        }
+        catch (error) {
+            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `MongoDB count failed: ${error.message}`, error);
+        }
+    }
+    async sum(connection, options) {
+        var _a;
+        try {
+            const db = connection.getClient();
+            const collection = db.collection(options.table);
+            const matchStage = this.buildMongoFilter(options.where);
+            const pipeline = [
+                { $match: matchStage },
+                {
+                    $group: {
+                        _id: null,
+                        total: { $sum: `$${options.column}` },
+                    },
+                },
+            ];
+            const result = await collection.aggregate(pipeline).toArray();
+            return ((_a = result[0]) === null || _a === void 0 ? void 0 : _a.total) || 0;
+        }
+        catch (error) {
+            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `MongoDB sum failed: ${error.message}`, error);
+        }
+    }
+    async avg(connection, options) {
+        var _a;
+        try {
+            const db = connection.getClient();
+            const collection = db.collection(options.table);
+            const matchStage = this.buildMongoFilter(options.where);
+            const pipeline = [
+                { $match: matchStage },
+                {
+                    $group: {
+                        _id: null,
+                        average: { $avg: `$${options.column}` },
+                    },
+                },
+            ];
+            const result = await collection.aggregate(pipeline).toArray();
+            return ((_a = result[0]) === null || _a === void 0 ? void 0 : _a.average) || 0;
+        }
+        catch (error) {
+            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `MongoDB avg failed: ${error.message}`, error);
+        }
+    }
+    async min(connection, options) {
+        var _a;
+        try {
+            const db = connection.getClient();
+            const collection = db.collection(options.table);
+            const matchStage = this.buildMongoFilter(options.where);
+            const pipeline = [
+                { $match: matchStage },
+                {
+                    $group: {
+                        _id: null,
+                        minimum: { $min: `$${options.column}` },
+                    },
+                },
+            ];
+            const result = await collection.aggregate(pipeline).toArray();
+            return ((_a = result[0]) === null || _a === void 0 ? void 0 : _a.minimum) || 0;
+        }
+        catch (error) {
+            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `MongoDB min failed: ${error.message}`, error);
+        }
+    }
+    async max(connection, options) {
+        var _a;
+        try {
+            const db = connection.getClient();
+            const collection = db.collection(options.table);
+            const matchStage = this.buildMongoFilter(options.where);
+            const pipeline = [
+                { $match: matchStage },
+                {
+                    $group: {
+                        _id: null,
+                        maximum: { $max: `$${options.column}` },
+                    },
+                },
+            ];
+            const result = await collection.aggregate(pipeline).toArray();
+            return ((_a = result[0]) === null || _a === void 0 ? void 0 : _a.maximum) || 0;
+        }
+        catch (error) {
+            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `MongoDB max failed: ${error.message}`, error);
+        }
+    }
+    async groupBy(connection, options) {
+        try {
+            const db = connection.getClient();
+            const collection = db.collection(options.table);
+            const matchStage = this.buildMongoFilter(options.where);
+            // Build group ID from columns
+            const groupId = {};
+            options.groupBy.forEach((col) => {
+                groupId[col] = `$${col}`;
+            });
+            // Build aggregations
+            const aggregations = {};
+            if (options.aggregate) {
+                Object.entries(options.aggregate).forEach(([key, agg]) => {
+                    // Support both old format { function: 'avg', column: 'price' }
+                    // and new simplified format { $AVG: 'price' }
+                    if (agg.function && agg.column) {
+                        aggregations[key] = { [`$${agg.function.toLowerCase()}`]: `$${agg.column}` };
+                    }
+                    else {
+                        // Check for $-prefixed aggregation functions
+                        const aggObj = agg;
+                        const aggFunctions = ['$COUNT', '$AVG', '$SUM', '$MIN', '$MAX', 'COUNT', 'AVG', 'SUM', 'MIN', 'MAX'];
+                        for (const func of aggFunctions) {
+                            if (aggObj[func] !== undefined) {
+                                const funcName = func.replace('$', '').toLowerCase();
+                                const column = aggObj[func];
+                                aggregations[key] = { [`$${funcName}`]: column === '*' ? 1 : `$${column}` };
+                                break;
+                            }
+                        }
+                    }
+                });
+            }
+            const pipeline = [
+                { $match: matchStage },
+                {
+                    $group: Object.assign({ _id: groupId }, aggregations),
+                },
+            ];
+            const result = await collection.aggregate(pipeline).toArray();
+            // Transform result to expected format
+            return result.map((doc) => (Object.assign(Object.assign(Object.assign({}, doc._id), doc), { _id: undefined })));
+        }
+        catch (error) {
+            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `MongoDB groupBy failed: ${error.message}`, error);
+        }
+    }
+    async aggregate(connection, options) {
+        try {
+            const db = connection.getClient();
+            const collection = db.collection(options.table);
+            const matchStage = this.buildMongoFilter(options.where);
+            // Build aggregations
+            const aggregations = {};
+            Object.entries(options.operations).forEach(([key, agg]) => {
+                // Support both old format { function: 'avg', column: 'price' }
+                // and new simplified format { $AVG: 'price' }
+                if (agg.function && agg.column) {
+                    aggregations[key] = { [`$${agg.function.toLowerCase()}`]: `$${agg.column}` };
+                }
+                else {
+                    // Check for $-prefixed aggregation functions
+                    const aggObj = agg;
+                    const aggFunctions = ['$COUNT', '$AVG', '$SUM', '$MIN', '$MAX', 'COUNT', 'AVG', 'SUM', 'MIN', 'MAX'];
+                    for (const func of aggFunctions) {
+                        if (aggObj[func] !== undefined) {
+                            const funcName = func.replace('$', '').toLowerCase();
+                            const column = aggObj[func];
+                            aggregations[key] = { [`$${funcName}`]: column === '*' ? 1 : `$${column}` };
+                            break;
+                        }
+                    }
+                }
+            });
+            const pipeline = [
+                { $match: matchStage },
+                {
+                    $group: Object.assign({ _id: null }, aggregations),
+                },
+            ];
+            const result = await collection.aggregate(pipeline).toArray();
+            const _a = result[0] || {}, { _id } = _a, aggregateResult = __rest(_a, ["_id"]);
+            return aggregateResult;
+        }
+        catch (error) {
+            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `MongoDB aggregate failed: ${error.message}`, error);
+        }
+    }
+    // ==================== Schema Methods ====================
+    async createTable(connection, schema, options) {
+        const startTime = Date.now();
+        try {
+            const db = connection.getClient();
+            // MongoDB creates collections automatically, but we can create it explicitly
+            await db.createCollection(schema.name);
+            // Create indexes if specified
+            if (schema.indexes && schema.indexes.length > 0) {
+                const collection = db.collection(schema.name);
+                for (const index of schema.indexes) {
+                    const indexSpec = {};
+                    index.columns.forEach((col) => {
+                        indexSpec[col.name] = col.order === 'DESC' ? -1 : 1;
+                    });
+                    await collection.createIndex(indexSpec, { unique: index.unique });
+                }
+            }
+            const executionTime = Date.now() - startTime;
+            return {
+                success: true,
+                operation: 'create',
+                table: schema.name,
+                executionTime,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                operation: 'create',
+                table: schema.name,
+                error: error.message,
+                executionTime: Date.now() - startTime,
+            };
+        }
+    }
+    async dropTable(connection, tableName) {
+        const startTime = Date.now();
+        try {
+            const db = connection.getClient();
+            await db.dropCollection(tableName);
+            return {
+                success: true,
+                operation: 'drop',
+                table: tableName,
+                executionTime: Date.now() - startTime,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                operation: 'drop',
+                table: tableName,
+                error: error.message,
+                executionTime: Date.now() - startTime,
+            };
+        }
+    }
+    async alterTable(connection, tableName, alterations, options) {
+        // MongoDB doesn't have a schema alteration concept like SQL databases
+        // Schema changes happen implicitly when documents are inserted
+        return {
+            success: true,
+            operation: 'alter',
+            table: tableName,
+            executionTime: 0,
+        };
+    }
+    async getTableSchema(connection, tableName) {
+        try {
+            const db = connection.getClient();
+            const collection = db.collection(tableName);
+            // Get a sample document to infer schema
+            const sampleDoc = await collection.findOne({});
+            // TODO: Infer column definitions from sample document
+            // This is a simplified implementation
+            const columns = sampleDoc
+                ? Object.keys(sampleDoc).map((key) => ({
+                    name: key,
+                    type: typeof sampleDoc[key],
+                }))
+                : [];
+            return {
+                name: tableName,
+                columns,
+            };
+        }
+        catch (error) {
+            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.SCHEMA_ERROR, `Failed to get MongoDB collection schema: ${error.message}`, error);
+        }
+    }
+    async listTables(connection) {
+        try {
+            const db = connection.getClient();
+            const collections = await db.listCollections().toArray();
+            return collections.map((col) => col.name);
+        }
+        catch (error) {
+            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `Failed to list MongoDB collections: ${error.message}`, error);
+        }
+    }
+    async tableExists(connection, tableName) {
+        try {
+            const tables = await this.listTables(connection);
+            return tables.includes(tableName);
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    // ==================== Index Methods ====================
+    async createIndex(connection, options) {
+        const startTime = Date.now();
+        try {
+            const db = connection.getClient();
+            const collection = db.collection(options.table);
+            const indexSpec = {};
+            options.index.columns.forEach((col) => {
+                indexSpec[col.name] = col.order === 'DESC' ? -1 : 1;
+            });
+            await collection.createIndex(indexSpec, {
+                name: options.index.name,
+                unique: options.index.unique,
+            });
+            return {
+                success: true,
+                operation: 'create',
+                indexName: options.index.name,
+                table: options.table,
+                executionTime: Date.now() - startTime,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                operation: 'create',
+                indexName: options.index.name,
+                table: options.table,
+                error: error.message,
+                executionTime: Date.now() - startTime,
+            };
+        }
+    }
+    async dropIndex(connection, options) {
+        const startTime = Date.now();
+        try {
+            const db = connection.getClient();
+            const collection = db.collection(options.table);
+            await collection.dropIndex(options.indexName);
+            return {
+                success: true,
+                operation: 'drop',
+                indexName: options.indexName,
+                table: options.table,
+                executionTime: Date.now() - startTime,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                operation: 'drop',
+                indexName: options.indexName,
+                table: options.table,
+                error: error.message,
+                executionTime: Date.now() - startTime,
+            };
+        }
+    }
+    async listIndexes(connection, options) {
+        try {
+            const db = connection.getClient();
+            const collection = db.collection(options.table);
+            const indexes = await collection.listIndexes().toArray();
+            return indexes.map((index) => ({
+                name: index.name,
+                table: options.table,
+                columns: Object.keys(index.key),
+                unique: index.unique || false,
+                type: index.type || 'BTREE',
+            }));
+        }
+        catch (error) {
+            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.INDEX_ERROR, `Failed to list MongoDB indexes: ${error.message}`, error);
+        }
+    }
+    async getIndexStatistics(connection, tableName, indexName) {
+        try {
+            const db = connection.getClient();
+            const collection = db.collection(tableName);
+            const stats = await collection.stats();
+            // TODO: Parse and return index statistics
+            // This is a simplified implementation
+            return [];
+        }
+        catch (error) {
+            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.INDEX_ERROR, `Failed to get MongoDB index statistics: ${error.message}`, error);
+        }
+    }
+    // ==================== Migration Methods ====================
+    async runMigration(connection, migration, options) {
+        // TODO: Implement migration logic
+        throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.MIGRATION_ERROR, 'MongoDB migration not implemented yet');
+    }
+    async rollbackMigration(connection, migration, options) {
+        // TODO: Implement rollback logic
+        throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.MIGRATION_ERROR, 'MongoDB migration rollback not implemented yet');
+    }
+    async getMigrationHistory(connection, options) {
+        // TODO: Implement migration history
+        return [];
+    }
+    // ==================== Helper Methods ====================
+    /**
+     * Build MongoDB filter from where clause
+     * Supports both simplified syntax (GT, LT, AND, OR, etc.) and legacy $ prefix operators
+     */
+    buildMongoFilter(where) {
+        if (!where) {
+            return {};
+        }
+        if (typeof where !== 'object' || where === null) {
+            return where;
+        }
+        const buildCondition = (condition) => {
+            if (typeof condition !== 'object' || condition === null) {
+                return condition;
+            }
+            // Handle logical operators (supports $AND, AND, and legacy $and)
+            if (condition.$AND || condition.AND || condition.$and) {
+                const andConditions = condition.$AND || condition.AND || condition.$and;
+                if (typeof andConditions === 'object' && !Array.isArray(andConditions)) {
+                    // New syntax: { $AND: { col1: val1, col2: val2 } }
+                    return buildCondition(andConditions);
+                }
+                else {
+                    // Array syntax: { $AND: [cond1, cond2] }
+                    return { $and: andConditions.map(buildCondition) };
+                }
+            }
+            if (condition.$OR || condition.OR || condition.$or) {
+                const orConditions = condition.$OR || condition.OR || condition.$or;
+                if (typeof orConditions === 'object' && !Array.isArray(orConditions)) {
+                    // New syntax: { $OR: { col1: val1, col2: val2 } }
+                    const subConditions = [];
+                    for (const [key, value] of Object.entries(orConditions)) {
+                        if (key === '$AND' || key === 'AND' || key === '$and' || key === '$OR' || key === 'OR' || key === '$or') {
+                            subConditions.push(buildCondition({ [key]: value }));
+                        }
+                        else {
+                            subConditions.push(buildCondition({ [key]: value }));
+                        }
+                    }
+                    return { $or: subConditions };
+                }
+                else {
+                    // Array syntax: { $OR: [cond1, cond2] }
+                    return { $or: orConditions.map(buildCondition) };
+                }
+            }
+            // Handle column conditions
+            const filter = {};
+            for (const [key, value] of Object.entries(condition)) {
+                // Skip logical operators at this level
+                if (key === '$AND' || key === 'AND' || key === '$and' || key === '$OR' || key === 'OR' || key === '$or') {
+                    continue;
+                }
+                if (typeof value === 'object' && value !== null && !Array.isArray(value) && !(value instanceof Date)) {
+                    // Handle comparison operators
+                    const operators = {};
+                    for (const [op, opValue] of Object.entries(value)) {
+                        switch (op) {
+                            // Preferred $-prefixed syntax - map to MongoDB operators
+                            case '$GT':
+                            case 'GT':
+                                operators.$gt = opValue;
+                                break;
+                            case '$GTE':
+                            case 'GTE':
+                                operators.$gte = opValue;
+                                break;
+                            case '$LT':
+                            case 'LT':
+                                operators.$lt = opValue;
+                                break;
+                            case '$LTE':
+                            case 'LTE':
+                                operators.$lte = opValue;
+                                break;
+                            case '$NE':
+                            case '$NOT':
+                            case 'NE':
+                            case 'NOT':
+                                operators.$ne = opValue;
+                                break;
+                            case '$IN':
+                            case 'IN':
+                                operators.$in = opValue;
+                                break;
+                            case '$NOT_IN':
+                            case 'NOT_IN':
+                                operators.$nin = opValue;
+                                break;
+                            case '$LIKE':
+                            case 'LIKE':
+                                // MongoDB uses regex for pattern matching
+                                operators.$regex = opValue.replace(/%/g, '.*').replace(/_/g, '.');
+                                operators.$options = 'i';
+                                break;
+                            case '$IS_NULL':
+                            case 'IS_NULL':
+                                operators.$eq = null;
+                                break;
+                            case '$IS_NOT_NULL':
+                            case 'IS_NOT_NULL':
+                                operators.$ne = null;
+                                break;
+                            case '$BETWEEN':
+                            case 'BETWEEN':
+                                if (Array.isArray(opValue) && opValue.length === 2) {
+                                    operators.$gte = opValue[0];
+                                    operators.$lte = opValue[1];
+                                }
+                                break;
+                            // Legacy lowercase $ operators - pass through
+                            case '$gt':
+                            case '$gte':
+                            case '$lt':
+                            case '$lte':
+                            case '$ne':
+                            case '$in':
+                            case '$nin':
+                            case '$regex':
+                            case '$options':
+                            case '$exists':
+                            case '$type':
+                            case '$eq':
+                            case '$elemMatch':
+                            case '$size':
+                            case '$all':
+                                operators[op] = opValue;
+                                break;
+                        }
+                    }
+                    filter[key] = operators;
+                }
+                else {
+                    // Simple equality
+                    filter[key] = value;
+                }
+            }
+            return filter;
+        };
+        return buildCondition(where);
+    }
+    // ==================== Utility Methods ====================
+    /**
+     * Escape identifier (collection/field name)
+     */
+    escapeIdentifier(identifier) {
+        // MongoDB doesn't require escaping in the same way as SQL
+        // But we can sanitize the identifier
+        return identifier.replace(/[.$]/g, '_');
+    }
+    /**
+     * Escape value
+     */
+    escapeValue(value) {
+        // MongoDB uses BSON, not SQL, so escaping is different
+        // This is mainly for display/logging purposes
+        if (value === null || value === undefined) {
+            return 'null';
+        }
+        if (typeof value === 'string') {
+            return `"${value.replace(/"/g, '\\"')}"`;
+        }
+        if (value instanceof Date) {
+            return value.toISOString();
+        }
+        if (typeof value === 'object') {
+            return JSON.stringify(value);
+        }
+        return String(value);
+    }
+    /**
+     * Get database version
+     */
+    async getDatabaseVersion(connection) {
+        try {
+            const db = connection.getClient();
+            const info = await db.admin().serverInfo();
+            return info.version || 'Unknown';
+        }
+        catch (error) {
+            return 'Unknown';
+        }
+    }
+}
+exports.MongoDBAdapter = MongoDBAdapter;
+//# sourceMappingURL=mongodb.adapter.js.map