@ductape/sdk 0.0.4-v5 → 0.0.4-v51

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

@@ -0,0 +1,1072 @@
+"use strict";
+/**
+ * MongoDB Database Adapter
+ * Implements database operations for MongoDB
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+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 uuid_1 = require("uuid");
+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;
+    }
+    getMongoClient() {
+        return this.client;
+    }
+}
+/**
+ * MongoDB Transaction implementation
+ * Note: MongoDB uses sessions for transactions and does NOT support savepoints
+ */
+class MongoDBTransaction {
+    constructor(connection, session, options) {
+        this.id = (0, uuid_1.v4)();
+        this.connection = connection;
+        this.status = database_types_1.TransactionStatus.ACTIVE;
+        this.isolationLevel = options === null || options === void 0 ? void 0 : options.isolationLevel;
+        this.createdAt = new Date();
+        this.session = session;
+        this.native = session;
+    }
+    async commit() {
+        if (this.status !== database_types_1.TransactionStatus.ACTIVE) {
+            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.TRANSACTION_ERROR, `Cannot commit transaction: status is ${this.status}`);
+        }
+        await this.session.commitTransaction();
+        await this.session.endSession();
+        this.status = database_types_1.TransactionStatus.COMMITTED;
+    }
+    async rollback() {
+        if (this.status !== database_types_1.TransactionStatus.ACTIVE) {
+            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.TRANSACTION_ERROR, `Cannot rollback transaction: status is ${this.status}`);
+        }
+        await this.session.abortTransaction();
+        await this.session.endSession();
+        this.status = database_types_1.TransactionStatus.ROLLED_BACK;
+    }
+    async savepoint(_name) {
+        throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.NOT_SUPPORTED, 'MongoDB does not support savepoints. Transactions are atomic - either all changes commit or all rollback.');
+    }
+    isActive() {
+        return this.status === database_types_1.TransactionStatus.ACTIVE;
+    }
+    getSession() {
+        return this.session;
+    }
+}
+/**
+ * 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 {
+            // Dynamic import of mongodb library
+            // @ts-ignore - mongodb is an optional peer dependency
+            const { MongoClient } = await Promise.resolve().then(() => __importStar(require('mongodb')));
+            const options = config.options || {};
+            // Build connection URI
+            let uri;
+            if (options.connectionString || options.uri) {
+                uri = options.connectionString || options.uri;
+            }
+            else {
+                const host = options.host || 'localhost';
+                const port = options.port || 27017;
+                const username = options.username || options.user;
+                const password = options.password;
+                const authSource = options.authSource || 'admin';
+                if (username && password) {
+                    uri = `mongodb://${encodeURIComponent(username)}:${encodeURIComponent(password)}@${host}:${port}/${config.database}?authSource=${authSource}`;
+                }
+                else {
+                    uri = `mongodb://${host}:${port}/${config.database}`;
+                }
+            }
+            // Create MongoDB client with options
+            const clientOptions = {
+                maxPoolSize: options.poolSize || 10,
+                minPoolSize: options.minPoolSize || 2,
+                connectTimeoutMS: options.connectionTimeout || 10000,
+                socketTimeoutMS: options.idleTimeout || 30000,
+                retryWrites: options.retryWrites !== false,
+                retryReads: options.retryReads !== false,
+            };
+            // Add SSL/TLS options if specified
+            if (options.ssl || options.tls) {
+                clientOptions.tls = true;
+                if (options.tlsCAFile)
+                    clientOptions.tlsCAFile = options.tlsCAFile;
+                if (options.tlsCertificateKeyFile)
+                    clientOptions.tlsCertificateKeyFile = options.tlsCertificateKeyFile;
+                clientOptions.tlsAllowInvalidCertificates = options.tlsAllowInvalidCertificates || false;
+            }
+            // Add replica set options if specified
+            if (options.replicaSet) {
+                clientOptions.replicaSet = options.replicaSet;
+            }
+            const client = new MongoClient(uri, clientOptions);
+            // Connect to MongoDB
+            await client.connect();
+            // Test connection
+            await client.db(config.database).command({ ping: 1 });
+            // Get database
+            const db = client.db(config.database);
+            // Create connection wrapper
+            const connectionId = `mongodb-${config.database}-${Date.now()}`;
+            const connection = new MongoDBConnection(connectionId, client, db);
+            // Store in pool map
+            this.connectionPool.set(connectionId, connection);
+            return connection;
+        }
+        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, options) {
+        try {
+            // MongoDB needs to access the MongoClient for sessions, not just the db
+            const mongoConnection = connection;
+            const client = mongoConnection.getMongoClient();
+            const session = client.startSession();
+            // Build transaction options
+            const txnOptions = {
+                writeConcern: { w: 'majority' },
+            };
+            // Map isolation level to MongoDB read concern
+            if (options === null || options === void 0 ? void 0 : options.isolationLevel) {
+                switch (options.isolationLevel) {
+                    case database_types_1.TransactionIsolationLevel.READ_UNCOMMITTED:
+                    case database_types_1.TransactionIsolationLevel.READ_COMMITTED:
+                        txnOptions.readConcern = { level: 'local' };
+                        break;
+                    case database_types_1.TransactionIsolationLevel.REPEATABLE_READ:
+                        txnOptions.readConcern = { level: 'snapshot' };
+                        break;
+                    case database_types_1.TransactionIsolationLevel.SERIALIZABLE:
+                        txnOptions.readConcern = { level: 'linearizable' };
+                        break;
+                    default:
+                        txnOptions.readConcern = { level: 'snapshot' };
+                }
+            }
+            else {
+                txnOptions.readConcern = { level: 'snapshot' };
+            }
+            session.startTransaction(txnOptions);
+            return new MongoDBTransaction(connection, session, options);
+        }
+        catch (error) {
+            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.TRANSACTION_ERROR, `Failed to begin MongoDB transaction: ${error.message}. Note: MongoDB transactions require a replica set or sharded cluster.`, error);
+        }
+    }
+    async commitTransaction(connection, transaction) {
+        await transaction.commit();
+    }
+    async rollbackTransaction(connection, transaction) {
+        await transaction.rollback();
+    }
+    async createSavepoint(_connection, _transaction, _savepointName) {
+        throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.NOT_SUPPORTED, 'MongoDB does not support savepoints. Transactions are atomic - either all changes commit or all rollback.');
+    }
+    async rollbackToSavepoint(_connection, _transaction, _savepoint) {
+        throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.NOT_SUPPORTED, 'MongoDB does not support savepoints.');
+    }
+    async releaseSavepoint(_connection, _transaction, _savepoint) {
+        throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.NOT_SUPPORTED, '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(([alias, agg]) => {
+                    const aggObj = agg;
+                    if (aggObj.$COUNT !== undefined) {
+                        aggregations[alias] = { $sum: 1 };
+                    }
+                    else if (aggObj.$SUM !== undefined) {
+                        aggregations[alias] = { $sum: `$${aggObj.$SUM}` };
+                    }
+                    else if (aggObj.$AVG !== undefined) {
+                        aggregations[alias] = { $avg: `$${aggObj.$AVG}` };
+                    }
+                    else if (aggObj.$MIN !== undefined) {
+                        aggregations[alias] = { $min: `$${aggObj.$MIN}` };
+                    }
+                    else if (aggObj.$MAX !== undefined) {
+                        aggregations[alias] = { $max: `$${aggObj.$MAX}` };
+                    }
+                    else if (aggObj.$ARRAY_AGG !== undefined) {
+                        aggregations[alias] = { $push: `$${aggObj.$ARRAY_AGG}` };
+                    }
+                });
+            }
+            const pipeline = [
+                { $match: matchStage },
+                {
+                    $group: Object.assign({ _id: groupId }, aggregations),
+                },
+            ];
+            // Add having clause (filter after grouping)
+            if (options.having) {
+                pipeline.push({ $match: this.buildMongoFilter(options.having) });
+            }
+            // Add sorting
+            if (options.orderBy) {
+                const sortSpec = {};
+                const orderByArray = Array.isArray(options.orderBy) ? options.orderBy : [options.orderBy];
+                orderByArray.forEach((order) => {
+                    sortSpec[order.column] = order.order.toLowerCase() === query_types_1.SortOrder.DESC ? -1 : 1;
+                });
+                pipeline.push({ $sort: sortSpec });
+            }
+            // Add limit and offset
+            if (options.offset) {
+                pipeline.push({ $skip: options.offset });
+            }
+            if (options.limit) {
+                pipeline.push({ $limit: options.limit });
+            }
+            const result = await collection.aggregate(pipeline).toArray();
+            // Transform result to expected format
+            return result.map((doc) => {
+                const { _id } = doc, rest = __rest(doc, ["_id"]);
+                return Object.assign(Object.assign({}, _id), rest);
+            });
+        }
+        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(([alias, agg]) => {
+                const aggObj = agg;
+                if (aggObj.$COUNT !== undefined) {
+                    aggregations[alias] = { $sum: 1 };
+                }
+                else if (aggObj.$SUM !== undefined) {
+                    aggregations[alias] = { $sum: `$${aggObj.$SUM}` };
+                }
+                else if (aggObj.$AVG !== undefined) {
+                    aggregations[alias] = { $avg: `$${aggObj.$AVG}` };
+                }
+                else if (aggObj.$MIN !== undefined) {
+                    aggregations[alias] = { $min: `$${aggObj.$MIN}` };
+                }
+                else if (aggObj.$MAX !== undefined) {
+                    aggregations[alias] = { $max: `$${aggObj.$MAX}` };
+                }
+                else if (aggObj.$ARRAY_AGG !== undefined) {
+                    aggregations[alias] = { $push: `$${aggObj.$ARRAY_AGG}` };
+                }
+            });
+            // Build group stage
+            let groupId = null;
+            if (options.groupBy && options.groupBy.length > 0) {
+                groupId = {};
+                options.groupBy.forEach((col) => {
+                    groupId[col] = `$${col}`;
+                });
+            }
+            const pipeline = [
+                { $match: matchStage },
+                {
+                    $group: Object.assign({ _id: groupId }, aggregations),
+                },
+            ];
+            // Add having clause (filter after grouping)
+            if (options.having) {
+                pipeline.push({ $match: this.buildMongoFilter(options.having) });
+            }
+            const result = await collection.aggregate(pipeline).toArray();
+            if (groupId) {
+                // Return all grouped results
+                return result.map((doc) => {
+                    const { _id } = doc, rest = __rest(doc, ["_id"]);
+                    return Object.assign(Object.assign({}, _id), rest);
+                });
+            }
+            else {
+                // Return single aggregate result
+                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