@ductape/sdk 0.0.4-v51 → 0.0.4-v52

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

@@ -1,7 +1,12 @@
 "use strict";
 /**
- * MongoDB Database Adapter
- * Implements database operations for MongoDB
+ * MongoDB Adapter
+ *
+ * Database adapter for MongoDB databases using the 'mongodb' driver.
+ * Implements all methods from BaseAdapter with MongoDB-specific operations.
+ *
+ * Note: MongoDB uses collections instead of tables, and documents instead of rows.
+ * The adapter translates SQL-like operations to MongoDB operations.
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -36,1036 +41,1134 @@ var __importStar = (this && this.__importStar) || (function () {
         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");
+const enums_1 = require("../types/enums");
+const database_error_1 = require("../utils/database-error");
 /**
- * MongoDB Connection wrapper
+ * MongoDB database adapter
+ * Provides MongoDB-specific implementations for all database operations
  */
-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 {
+class MongoDBAdapter extends base_adapter_1.BaseAdapter {
     constructor() {
         super(...arguments);
-        this.type = database_types_1.DatabaseType.MONGODB;
-        this.connectionPool = new Map();
+        this.databaseType = enums_1.DatabaseType.MONGODB;
+        this.mongoClient = null;
+        this.db = null;
+        this.databaseName = '';
     }
-    // ==================== Connection Methods ====================
-    async connect(config) {
+    // ==================== CONNECTION METHODS ====================
+    async connect(options) {
         try {
-            // Dynamic import of mongodb library
-            // @ts-ignore - mongodb is an optional peer dependency
+            // Dynamic import of mongodb to avoid bundling issues
             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 = {
+            this.connectionUrl = options.connectionUrl;
+            // Parse connection URL to extract database name
+            const url = new URL(options.connectionUrl);
+            this.databaseName = url.pathname.slice(1) || 'test';
+            this.mongoClient = new MongoClient(options.connectionUrl, {
                 maxPoolSize: options.poolSize || 10,
-                minPoolSize: options.minPoolSize || 2,
                 connectTimeoutMS: options.connectionTimeout || 10000,
-                socketTimeoutMS: options.idleTimeout || 30000,
-                retryWrites: options.retryWrites !== false,
-                retryReads: options.retryReads !== false,
+                serverSelectionTimeoutMS: options.connectionTimeout || 10000,
+            });
+            await this.mongoClient.connect();
+            this.db = this.mongoClient.db(this.databaseName);
+            // Get server info
+            const adminDb = this.mongoClient.db('admin');
+            const serverInfo = await adminDb.command({ buildInfo: 1 });
+            this.client = this.mongoClient;
+            this.connected = true;
+            return {
+                connected: true,
+                version: serverInfo.version,
             };
-            // 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);
+            throw database_error_1.DatabaseError.connectionError(`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();
+    async testConnection(options) {
         try {
-            const db = connection.getClient();
-            // Test with a simple ping command
-            await db.admin().ping();
-            const responseTime = Date.now() - startTime;
+            const { MongoClient } = await Promise.resolve().then(() => __importStar(require('mongodb')));
+            const client = new MongoClient(options.connectionUrl, {
+                connectTimeoutMS: options.connectionTimeout || 5000,
+                serverSelectionTimeoutMS: options.connectionTimeout || 5000,
+            });
+            await client.connect();
+            const adminDb = client.db('admin');
+            const serverInfo = await adminDb.command({ buildInfo: 1 });
+            await client.close();
             return {
                 connected: true,
-                message: 'Successfully connected to MongoDB',
-                databaseType: 'mongodb',
-                responseTime,
+                version: serverInfo.version,
             };
         }
         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) {
+    async disconnect() {
+        if (this.mongoClient) {
+            await this.mongoClient.close();
+            this.mongoClient = null;
+            this.db = null;
+            this.client = null;
+            this.connected = false;
+        }
+    }
+    // ==================== QUERY METHODS ====================
+    async query(query) {
+        var _a;
+        this.ensureConnected();
         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' };
+            const collection = this.db.collection(query.options.table);
+            const session = (_a = query.options.transaction) === null || _a === void 0 ? void 0 : _a.client;
+            // Build MongoDB filter from where clause
+            const filter = this.buildMongoFilter(query.options.where || {});
+            // Build options
+            const findOptions = { session };
+            // Select specific fields
+            if (query.options.select) {
+                findOptions.projection = {};
+                for (const field of query.options.select) {
+                    findOptions.projection[field] = 1;
                 }
             }
-            else {
-                txnOptions.readConcern = { level: 'snapshot' };
+            // Sorting
+            if (query.options.orderBy) {
+                findOptions.sort = {};
+                const orderByArray = Array.isArray(query.options.orderBy)
+                    ? query.options.orderBy
+                    : [query.options.orderBy];
+                for (const order of orderByArray) {
+                    findOptions.sort[order.column] = order.order === 'DESC' ? -1 : 1;
+                }
+            }
+            // Pagination
+            if (query.options.limit) {
+                findOptions.limit = query.options.limit;
+            }
+            if (query.options.offset) {
+                findOptions.skip = query.options.offset;
             }
-            session.startTransaction(txnOptions);
-            return new MongoDBTransaction(connection, session, options);
+            const cursor = collection.find(filter, findOptions);
+            const data = await cursor.toArray();
+            // Get total count for pagination
+            const count = await collection.countDocuments(filter, { session });
+            return {
+                data: data,
+                count,
+            };
         }
         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);
+            throw database_error_1.DatabaseError.fromDatabaseError(error, 'mongodb');
         }
     }
-    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();
+    async raw(options) {
+        var _a, _b;
+        this.ensureConnected();
         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 query = options.query;
+            // If query is an object with MongoDB command keys, run it as a database command
+            if (query && typeof query === 'object' && !Array.isArray(query)) {
+                const commandKeys = ['create', 'drop', 'findAndModify', 'createIndexes', 'dropIndexes',
+                    'collMod', 'shardCollection', 'update', 'insert', 'delete', 'aggregate', 'count',
+                    'distinct', 'mapReduce', 'validate', 'listCollections', 'listIndexes'];
+                const isCommand = commandKeys.some(key => key in query);
+                if (isCommand) {
+                    // Run as a database command
+                    const result = await this.db.command(query);
+                    return {
+                        data: result.value ? [result.value] : (((_a = result.cursor) === null || _a === void 0 ? void 0 : _a.firstBatch) || [result]),
+                        count: result.n || result.ok || 1,
+                    };
+                }
             }
-            const data = await query.toArray();
-            const executionTime = Date.now() - startTime;
+            // Otherwise, treat as a find query on a collection
+            const collection = this.db.collection(options.collection || options.table || '');
+            const session = (_b = options.transaction) === null || _b === void 0 ? void 0 : _b.client;
+            // For MongoDB, 'query' is the filter object
+            const filter = query;
+            const cursor = collection.find(filter, { session });
+            const data = await cursor.toArray();
             return {
-                data,
+                data: 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);
+            throw database_error_1.DatabaseError.fromDatabaseError(error, 'mongodb');
         }
     }
-    async insert(connection, options) {
-        const startTime = Date.now();
+    // ==================== WRITE METHODS ====================
+    async insert(options) {
+        var _a;
+        this.ensureConnected();
         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;
+            const collection = this.db.collection(options.table);
+            const session = (_a = options.transaction) === null || _a === void 0 ? void 0 : _a.client;
+            const data = Array.isArray(options.data) ? options.data : [options.data];
+            if (data.length === 0) {
+                return { data: [], count: 0, insertedIds: [] };
+            }
+            // Get auto-increment fields for this collection
+            const autoIncrementFields = await this.getAutoIncrementFields(options.table);
+            // Get schema metadata for default values
+            const schemaColumns = await this.getSchemaMetadata(options.table);
+            // Process each document and assign auto-increment values and defaults
+            const processedData = await Promise.all(data.map(async (doc) => {
+                const processedDoc = Object.assign({}, doc);
+                // Apply default values for missing fields
+                for (const column of schemaColumns) {
+                    if (column.defaultValue !== undefined && column.defaultValue !== null) {
+                        if (processedDoc[column.name] === undefined || processedDoc[column.name] === null) {
+                            processedDoc[column.name] = this.resolveDefaultValue(column.defaultValue, column.type);
+                        }
+                    }
+                }
+                // For each auto-increment field, get the next value if not already set
+                for (const field of autoIncrementFields) {
+                    if (processedDoc[field] === undefined || processedDoc[field] === null) {
+                        processedDoc[field] = await this.getNextAutoIncrementValue(options.table, field);
+                    }
+                }
+                return processedDoc;
+            }));
+            const result = await collection.insertMany(processedData, { session });
+            // Get inserted documents if returning is requested
+            let returnedData = [];
+            if (options.returning) {
+                const insertedIds = Object.values(result.insertedIds);
+                returnedData = await collection.find({ _id: { $in: insertedIds } }, { session }).toArray();
+            }
             return {
-                insertedCount: result.insertedCount,
-                insertedIds: Object.values(result.insertedIds).map((id) => id.toString()),
-                data: options.returning ? dataArray : undefined,
-                executionTime,
-                success: true,
+                data: returnedData,
+                count: result.insertedCount,
+                insertedIds: Object.values(result.insertedIds),
             };
         }
         catch (error) {
-            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `MongoDB insert failed: ${error.message}`, error);
+            throw database_error_1.DatabaseError.fromDatabaseError(error, 'mongodb');
         }
     }
-    async update(connection, options) {
-        const startTime = Date.now();
+    async update(options) {
+        var _a;
+        this.ensureConnected();
         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;
+            const collection = this.db.collection(options.table);
+            const session = (_a = options.transaction) === null || _a === void 0 ? void 0 : _a.client;
+            // Build MongoDB filter
+            const filter = this.buildMongoFilter(options.where || {});
+            // Build update document
+            const updateDoc = { $set: {} };
+            for (const [key, value] of Object.entries(options.data)) {
+                if (value && typeof value === 'object' && this.isUpdateOperator(value)) {
+                    // Handle update operators - MongoDB has native support
+                    if ('$INC' in value) {
+                        if (!updateDoc.$inc)
+                            updateDoc.$inc = {};
+                        updateDoc.$inc[key] = value.$INC;
+                    }
+                    else if ('$DEC' in value) {
+                        // MongoDB uses $inc with negative value for decrement
+                        if (!updateDoc.$inc)
+                            updateDoc.$inc = {};
+                        updateDoc.$inc[key] = -value.$DEC;
+                    }
+                    else if ('$MUL' in value) {
+                        if (!updateDoc.$mul)
+                            updateDoc.$mul = {};
+                        updateDoc.$mul[key] = value.$MUL;
+                    }
+                    else if ('$MIN' in value) {
+                        if (!updateDoc.$min)
+                            updateDoc.$min = {};
+                        updateDoc.$min[key] = value.$MIN;
+                    }
+                    else if ('$MAX' in value) {
+                        if (!updateDoc.$max)
+                            updateDoc.$max = {};
+                        updateDoc.$max[key] = value.$MAX;
+                    }
+                    else if ('$SET' in value) {
+                        updateDoc.$set[key] = value.$SET;
+                    }
+                    else if ('$UNSET' in value && value.$UNSET) {
+                        if (!updateDoc.$unset)
+                            updateDoc.$unset = {};
+                        updateDoc.$unset[key] = '';
+                    }
+                    else if ('$PUSH' in value) {
+                        if (!updateDoc.$push)
+                            updateDoc.$push = {};
+                        updateDoc.$push[key] = value.$PUSH;
+                    }
+                    else if ('$PULL' in value) {
+                        if (!updateDoc.$pull)
+                            updateDoc.$pull = {};
+                        updateDoc.$pull[key] = value.$PULL;
+                    }
+                    else if ('$ADDTOSET' in value) {
+                        if (!updateDoc.$addToSet)
+                            updateDoc.$addToSet = {};
+                        updateDoc.$addToSet[key] = value.$ADDTOSET;
+                    }
+                }
+                else {
+                    updateDoc.$set[key] = value;
+                }
+            }
+            // Remove empty $set
+            if (Object.keys(updateDoc.$set).length === 0) {
+                delete updateDoc.$set;
+            }
+            const result = await collection.updateMany(filter, updateDoc, { session });
+            // Get updated documents if returning is requested
+            let returnedData = [];
+            if (options.returning) {
+                returnedData = await collection.find(filter, { session }).toArray();
+            }
             return {
-                updatedCount: result.modifiedCount,
-                matchedCount: result.matchedCount,
-                executionTime,
-                success: true,
+                data: returnedData,
+                count: result.modifiedCount,
             };
         }
         catch (error) {
-            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `MongoDB update failed: ${error.message}`, error);
+            throw database_error_1.DatabaseError.fromDatabaseError(error, 'mongodb');
         }
     }
-    async delete(connection, options) {
-        const startTime = Date.now();
+    async delete(options) {
+        var _a;
+        this.ensureConnected();
         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;
+            const collection = this.db.collection(options.table);
+            const session = (_a = options.transaction) === null || _a === void 0 ? void 0 : _a.client;
+            // Build MongoDB filter
+            const filter = this.buildMongoFilter(options.where || {});
+            // Get documents before delete if returning is requested
+            let deletedData;
+            if (options.returning) {
+                deletedData = await collection.find(filter, { session }).toArray();
+            }
+            const result = await collection.deleteMany(filter, { session });
             return {
-                deletedCount: result.deletedCount,
-                executionTime,
-                success: true,
+                count: result.deletedCount,
+                data: deletedData,
             };
         }
         catch (error) {
-            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `MongoDB delete failed: ${error.message}`, error);
+            throw database_error_1.DatabaseError.fromDatabaseError(error, 'mongodb');
         }
     }
-    async upsert(connection, options) {
-        const startTime = Date.now();
+    async upsert(options) {
+        var _a, _b;
+        this.ensureConnected();
         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 collection = this.db.collection(options.table);
+            const session = (_a = options.transaction) === null || _a === void 0 ? void 0 : _a.client;
+            // Build filter from conflict keys
             const filter = {};
-            options.uniqueColumns.forEach((col) => {
-                if (data[col] !== undefined) {
-                    filter[col] = data[col];
-                }
+            for (const key of options.conflictKeys) {
+                filter[key] = options.data[key];
+            }
+            // Build update document
+            const updateDoc = { $set: options.data };
+            const result = await collection.findOneAndUpdate(filter, updateDoc, {
+                upsert: true,
+                returnDocument: 'after',
+                session,
             });
-            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,
+                data: result.value ? [result.value] : [],
+                count: 1,
+                operation: ((_b = result.lastErrorObject) === null || _b === void 0 ? void 0 : _b.updatedExisting) ? 'updated' : 'inserted',
             };
         }
         catch (error) {
-            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `MongoDB upsert failed: ${error.message}`, error);
+            throw database_error_1.DatabaseError.fromDatabaseError(error, 'mongodb');
         }
     }
-    async executeRaw(connection, options) {
-        const startTime = Date.now();
+    // ==================== AGGREGATION METHODS ====================
+    async count(options) {
+        var _a, _b;
+        this.ensureConnected();
         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,
-            };
+            const collection = this.db.collection(options.table);
+            const session = (_a = options.transaction) === null || _a === void 0 ? void 0 : _a.client;
+            const filter = this.buildMongoFilter(options.where || {});
+            if (options.distinct && options.column) {
+                // For distinct count, use aggregation
+                const result = await collection.aggregate([
+                    { $match: filter },
+                    { $group: { _id: `$${options.column}` } },
+                    { $count: 'count' },
+                ], { session }).toArray();
+                return ((_b = result[0]) === null || _b === void 0 ? void 0 : _b.count) || 0;
+            }
+            return await collection.countDocuments(filter, { session });
         }
         catch (error) {
-            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `MongoDB raw query failed: ${error.message}`, error);
+            throw database_error_1.DatabaseError.fromDatabaseError(error, 'mongodb');
         }
     }
-    // ==================== Aggregation Methods ====================
-    async count(connection, options) {
+    async sum(options) {
+        var _a, _b;
+        this.ensureConnected();
         try {
-            const db = connection.getClient();
-            const collection = db.collection(options.table);
-            const filter = this.buildMongoFilter(options.where);
-            return await collection.countDocuments(filter);
+            const collection = this.db.collection(options.table);
+            const session = (_a = options.transaction) === null || _a === void 0 ? void 0 : _a.client;
+            const filter = this.buildMongoFilter(options.where || {});
+            const result = await collection.aggregate([
+                { $match: filter },
+                { $group: { _id: null, sum: { $sum: `$${options.column}` } } },
+            ], { session }).toArray();
+            return ((_b = result[0]) === null || _b === void 0 ? void 0 : _b.sum) || 0;
         }
         catch (error) {
-            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `MongoDB count failed: ${error.message}`, error);
+            throw database_error_1.DatabaseError.fromDatabaseError(error, 'mongodb');
         }
     }
-    async sum(connection, options) {
-        var _a;
+    async avg(options) {
+        var _a, _b;
+        this.ensureConnected();
         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;
+            const collection = this.db.collection(options.table);
+            const session = (_a = options.transaction) === null || _a === void 0 ? void 0 : _a.client;
+            const filter = this.buildMongoFilter(options.where || {});
+            const result = await collection.aggregate([
+                { $match: filter },
+                { $group: { _id: null, avg: { $avg: `$${options.column}` } } },
+            ], { session }).toArray();
+            return ((_b = result[0]) === null || _b === void 0 ? void 0 : _b.avg) || 0;
         }
         catch (error) {
-            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `MongoDB sum failed: ${error.message}`, error);
+            throw database_error_1.DatabaseError.fromDatabaseError(error, 'mongodb');
         }
     }
-    async avg(connection, options) {
-        var _a;
+    async min(options) {
+        var _a, _b;
+        this.ensureConnected();
         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;
+            const collection = this.db.collection(options.table);
+            const session = (_a = options.transaction) === null || _a === void 0 ? void 0 : _a.client;
+            const filter = this.buildMongoFilter(options.where || {});
+            const result = await collection.aggregate([
+                { $match: filter },
+                { $group: { _id: null, min: { $min: `$${options.column}` } } },
+            ], { session }).toArray();
+            return (_b = result[0]) === null || _b === void 0 ? void 0 : _b.min;
         }
         catch (error) {
-            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `MongoDB avg failed: ${error.message}`, error);
+            throw database_error_1.DatabaseError.fromDatabaseError(error, 'mongodb');
         }
     }
-    async min(connection, options) {
-        var _a;
+    async max(options) {
+        var _a, _b;
+        this.ensureConnected();
         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;
+            const collection = this.db.collection(options.table);
+            const session = (_a = options.transaction) === null || _a === void 0 ? void 0 : _a.client;
+            const filter = this.buildMongoFilter(options.where || {});
+            const result = await collection.aggregate([
+                { $match: filter },
+                { $group: { _id: null, max: { $max: `$${options.column}` } } },
+            ], { session }).toArray();
+            return (_b = result[0]) === null || _b === void 0 ? void 0 : _b.max;
         }
         catch (error) {
-            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `MongoDB min failed: ${error.message}`, error);
+            throw database_error_1.DatabaseError.fromDatabaseError(error, 'mongodb');
         }
     }
-    async max(connection, options) {
+    async aggregate(builtAggregation) {
         var _a;
+        this.ensureConnected();
         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;
+            const options = builtAggregation.options;
+            const collection = this.db.collection(options.table);
+            const session = (_a = options.transaction) === null || _a === void 0 ? void 0 : _a.client;
+            // Use the pre-built pipeline
+            const result = await collection.aggregate(builtAggregation.pipeline || [], { session }).toArray();
+            // Remove _id from result
+            if (result[0]) {
+                delete result[0]._id;
+            }
+            return result[0] || {};
         }
         catch (error) {
-            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `MongoDB max failed: ${error.message}`, error);
+            throw database_error_1.DatabaseError.fromDatabaseError(error, 'mongodb');
         }
     }
-    async groupBy(connection, options) {
+    async groupBy(builtGroupBy) {
+        var _a;
+        this.ensureConnected();
         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 options = builtGroupBy.options;
+            const collection = this.db.collection(options.table);
+            const session = (_a = options.transaction) === null || _a === void 0 ? void 0 : _a.client;
+            // Use the pre-built pipeline
+            const results = await collection.aggregate(builtGroupBy.pipeline || [], { session }).toArray();
+            return results.map((row) => {
+                var _a;
+                const group = {};
+                const aggregates = {};
+                // _id contains the group keys
+                if (row._id && typeof row._id === 'object') {
+                    Object.assign(group, row._id);
+                }
+                else if (((_a = options.groupBy) === null || _a === void 0 ? void 0 : _a.length) === 1) {
+                    group[options.groupBy[0]] = row._id;
+                }
+                // Everything else is aggregates
+                for (const key of Object.keys(row)) {
+                    if (key !== '_id') {
+                        aggregates[key] = row[key];
                     }
-                });
-            }
-            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 });
+                }
+                return { group, aggregates: aggregates };
+            });
+        }
+        catch (error) {
+            throw database_error_1.DatabaseError.fromDatabaseError(error, 'mongodb');
+        }
+    }
+    // ==================== TRANSACTION METHODS ====================
+    async beginTransaction(isolationLevel, readOnly, timeout) {
+        this.ensureConnected();
+        try {
+            const session = this.mongoClient.startSession();
+            const id = `mongo_txn_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+            const transactionOptions = {};
+            // MongoDB supports read concern and write concern instead of isolation levels
+            if (isolationLevel === enums_1.IsolationLevel.SERIALIZABLE) {
+                transactionOptions.readConcern = { level: 'snapshot' };
+                transactionOptions.writeConcern = { w: 'majority' };
             }
-            // Add limit and offset
-            if (options.offset) {
-                pipeline.push({ $skip: options.offset });
+            else {
+                transactionOptions.readConcern = { level: 'majority' };
+                transactionOptions.writeConcern = { w: 'majority' };
             }
-            if (options.limit) {
-                pipeline.push({ $limit: options.limit });
+            if (timeout) {
+                transactionOptions.maxCommitTimeMS = timeout;
             }
-            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);
-            });
+            session.startTransaction(transactionOptions);
+            return {
+                id,
+                databaseType: 'mongodb',
+                isolationLevel: isolationLevel || enums_1.IsolationLevel.READ_COMMITTED,
+                readOnly: readOnly || false,
+                timeout,
+                startedAt: new Date(),
+                client: session,
+                savepoints: new Map(),
+                status: 'active',
+            };
         }
         catch (error) {
-            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `MongoDB groupBy failed: ${error.message}`, error);
+            throw database_error_1.DatabaseError.transactionError(`Failed to begin transaction: ${error.message}`, error);
         }
     }
-    async aggregate(connection, options) {
+    async commitTransaction(context) {
         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}` };
+            await context.client.commitTransaction();
+            await context.client.endSession();
+            context.status = 'committed';
+        }
+        catch (error) {
+            context.status = 'error';
+            await context.client.endSession();
+            throw database_error_1.DatabaseError.transactionError(`Failed to commit transaction: ${error.message}`, error);
+        }
+    }
+    async rollbackTransaction(context) {
+        try {
+            await context.client.abortTransaction();
+            await context.client.endSession();
+            context.status = 'rolled_back';
+        }
+        catch (error) {
+            context.status = 'error';
+            await context.client.endSession();
+            throw database_error_1.DatabaseError.transactionError(`Failed to rollback transaction: ${error.message}`, error);
+        }
+    }
+    async createSavepoint(context, name) {
+        // MongoDB does not support savepoints
+        throw new database_error_1.DatabaseError('MongoDB does not support savepoints. Savepoints are only available in PostgreSQL and MySQL.', enums_1.DatabaseErrorType.NOT_SUPPORTED);
+    }
+    async releaseSavepoint(context, savepoint) {
+        // MongoDB does not support savepoints
+        throw new database_error_1.DatabaseError('MongoDB does not support savepoints. Savepoints are only available in PostgreSQL and MySQL.', enums_1.DatabaseErrorType.NOT_SUPPORTED);
+    }
+    async rollbackToSavepoint(context, savepoint) {
+        // MongoDB does not support savepoints
+        throw new database_error_1.DatabaseError('MongoDB does not support savepoints. Savepoints are only available in PostgreSQL and MySQL.', enums_1.DatabaseErrorType.NOT_SUPPORTED);
+    }
+    supportsSavepoints() {
+        return false;
+    }
+    // ==================== SCHEMA METHODS ====================
+    async createTable(definition, options) {
+        this.ensureConnected();
+        try {
+            // In MongoDB, creating a collection is optional as it's created on first insert
+            // But we can explicitly create it for validation
+            await this.db.createCollection(definition.name);
+            // Create indexes
+            if (definition.indexes) {
+                for (const index of definition.indexes) {
+                    await this.createIndex(index);
                 }
-                else if (aggObj.$MAX !== undefined) {
-                    aggregations[alias] = { $max: `$${aggObj.$MAX}` };
+            }
+            // Create unique constraints as unique indexes and register auto-increment fields
+            for (const column of definition.columns) {
+                if (column.unique && column.name !== '_id') {
+                    await this.db.collection(definition.name).createIndex({ [column.name]: 1 }, { unique: true });
                 }
-                else if (aggObj.$ARRAY_AGG !== undefined) {
-                    aggregations[alias] = { $push: `$${aggObj.$ARRAY_AGG}` };
+                // Register auto-increment fields in the counters collection
+                if (column.autoIncrement) {
+                    await this.registerAutoIncrementField(definition.name, column.name);
                 }
-            });
-            // 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) });
+            // Store schema metadata for default values and other app-level features
+            await this.storeSchemaMetadata(definition.name, definition.columns);
+        }
+        catch (error) {
+            // Ignore "collection already exists" error if ifNotExists is true
+            if ((options === null || options === void 0 ? void 0 : options.ifNotExists) && error.code === 48) {
+                return;
             }
-            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);
-                });
+            throw database_error_1.DatabaseError.schemaError(`Failed to create collection: ${error.message}`, error);
+        }
+    }
+    /**
+     * Register an auto-increment field in the counters collection.
+     * This creates/updates the counter document for the given collection and field.
+     */
+    async registerAutoIncrementField(collectionName, fieldName) {
+        const countersCollection = this.db.collection('_ductape_counters');
+        // Initialize the counter for this collection/field combination
+        await countersCollection.updateOne({ _id: `${collectionName}.${fieldName}` }, {
+            $setOnInsert: {
+                collection: collectionName,
+                field: fieldName,
+                currentValue: 0
             }
-            else {
-                // Return single aggregate result
-                const _a = result[0] || {}, { _id } = _a, aggregateResult = __rest(_a, ["_id"]);
-                return aggregateResult;
+        }, { upsert: true });
+    }
+    /**
+     * Get the next auto-increment value atomically.
+     * Uses findOneAndUpdate with $inc to ensure atomic increment even under high concurrency.
+     */
+    async getNextAutoIncrementValue(collectionName, fieldName) {
+        const countersCollection = this.db.collection('_ductape_counters');
+        const result = await countersCollection.findOneAndUpdate({ _id: `${collectionName}.${fieldName}` }, { $inc: { currentValue: 1 } }, { returnDocument: 'after', upsert: true });
+        return result.currentValue;
+    }
+    /**
+     * Get all auto-increment fields for a collection from the counters collection.
+     */
+    async getAutoIncrementFields(collectionName) {
+        const countersCollection = this.db.collection('_ductape_counters');
+        const counters = await countersCollection.find({ collection: collectionName }).toArray();
+        return counters.map((c) => c.field);
+    }
+    /**
+     * Store schema metadata for a collection (including default values).
+     * MongoDB doesn't have native schema enforcement, so we store this for application-level use.
+     */
+    async storeSchemaMetadata(collectionName, columns) {
+        const metadataCollection = this.db.collection('_ductape_schema');
+        await metadataCollection.updateOne({ _id: collectionName }, {
+            $set: {
+                collection: collectionName,
+                columns: columns.map(col => ({
+                    name: col.name,
+                    type: col.type,
+                    defaultValue: col.defaultValue,
+                    nullable: col.nullable,
+                    unique: col.unique,
+                    primaryKey: col.primaryKey,
+                    autoIncrement: col.autoIncrement,
+                })),
+                updatedAt: new Date()
             }
+        }, { upsert: true });
+    }
+    /**
+     * Get schema metadata for a collection to apply defaults during insert.
+     */
+    async getSchemaMetadata(collectionName) {
+        const metadataCollection = this.db.collection('_ductape_schema');
+        const schema = await metadataCollection.findOne({ _id: collectionName });
+        return (schema === null || schema === void 0 ? void 0 : schema.columns) || [];
+    }
+    /**
+     * Resolve a default value to its actual value.
+     * Handles special values like 'now', 'NOW()', true, false, etc.
+     */
+    resolveDefaultValue(defaultValue, fieldType) {
+        if (defaultValue === undefined || defaultValue === null) {
+            return undefined;
         }
-        catch (error) {
-            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `MongoDB aggregate failed: ${error.message}`, error);
+        // Handle string-based special defaults
+        if (typeof defaultValue === 'string') {
+            const lowerDefault = defaultValue.toLowerCase();
+            // Date/time defaults
+            if (lowerDefault === 'now' || lowerDefault === 'now()' || lowerDefault === 'current_timestamp') {
+                return new Date();
+            }
+            // Boolean defaults (for string representations)
+            if (lowerDefault === 'true')
+                return true;
+            if (lowerDefault === 'false')
+                return false;
+            // UUID defaults
+            if (lowerDefault === 'uuid' || lowerDefault === 'uuid()' || lowerDefault === 'gen_random_uuid()') {
+                return this.generateUUID();
+            }
         }
+        // Return as-is for other values (numbers, booleans, objects, etc.)
+        return defaultValue;
+    }
+    /**
+     * Generate a UUID v4.
+     */
+    generateUUID() {
+        return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
+            const r = Math.random() * 16 | 0;
+            const v = c === 'x' ? r : (r & 0x3 | 0x8);
+            return v.toString(16);
+        });
     }
-    // ==================== Schema Methods ====================
-    async createTable(connection, schema, options) {
-        const startTime = Date.now();
+    async alterTable(tableName, operations) {
+        this.ensureConnected();
+        // MongoDB is schemaless, so we don't need to alter the schema
+        // However, we can handle index and constraint operations
         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) {
+            for (const op of operations) {
+                if (op.type === 'ADD' && op.constraint && op.constraint.type === 'UNIQUE') {
+                    // Add unique index
                     const indexSpec = {};
-                    index.columns.forEach((col) => {
-                        indexSpec[col.name] = col.order === 'DESC' ? -1 : 1;
-                    });
-                    await collection.createIndex(indexSpec, { unique: index.unique });
+                    for (const col of op.constraint.columns) {
+                        indexSpec[col] = 1;
+                    }
+                    await this.db.collection(tableName).createIndex(indexSpec, { unique: true });
+                }
+                else if (op.type === 'DROP' && op.constraintName) {
+                    // Drop index
+                    await this.db.collection(tableName).dropIndex(op.constraintName);
+                }
+                else if (op.type === 'RENAME' && op.oldName && op.newName) {
+                    // Rename field in all documents
+                    await this.db.collection(tableName).updateMany({}, { $rename: { [op.oldName]: op.newName } });
                 }
             }
-            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,
-            };
+            throw database_error_1.DatabaseError.schemaError(`Failed to alter collection: ${error.message}`, error);
         }
     }
-    async dropTable(connection, tableName) {
-        const startTime = Date.now();
+    async dropTable(tableName, ifExists, cascade) {
+        this.ensureConnected();
         try {
-            const db = connection.getClient();
-            await db.dropCollection(tableName);
-            return {
-                success: true,
-                operation: 'drop',
-                table: tableName,
-                executionTime: Date.now() - startTime,
-            };
+            await this.db.collection(tableName).drop();
         }
         catch (error) {
-            return {
-                success: false,
-                operation: 'drop',
-                table: tableName,
-                error: error.message,
-                executionTime: Date.now() - startTime,
-            };
+            // Ignore "collection doesn't exist" error if ifExists is true
+            if (ifExists && error.code === 26) {
+                return;
+            }
+            throw database_error_1.DatabaseError.schemaError(`Failed to drop collection: ${error.message}`, error);
         }
     }
-    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) {
+    async listTables() {
+        this.ensureConnected();
         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,
-            };
+            const collections = await this.db.listCollections().toArray();
+            return collections.map((c) => c.name);
         }
         catch (error) {
-            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.SCHEMA_ERROR, `Failed to get MongoDB collection schema: ${error.message}`, error);
+            throw database_error_1.DatabaseError.schemaError(`Failed to list collections: ${error.message}`, error);
         }
     }
-    async listTables(connection) {
+    async tableExists(tableName) {
+        this.ensureConnected();
         try {
-            const db = connection.getClient();
-            const collections = await db.listCollections().toArray();
-            return collections.map((col) => col.name);
+            const collections = await this.db.listCollections({ name: tableName }).toArray();
+            return collections.length > 0;
         }
         catch (error) {
-            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `Failed to list MongoDB collections: ${error.message}`, error);
+            throw database_error_1.DatabaseError.schemaError(`Failed to check collection existence: ${error.message}`, error);
         }
     }
-    async tableExists(connection, tableName) {
+    async getTableSchema(tableName) {
+        this.ensureConnected();
         try {
-            const tables = await this.listTables(connection);
-            return tables.includes(tableName);
+            const collection = this.db.collection(tableName);
+            // Sample documents to infer schema
+            const sampleDocs = await collection.find().limit(100).toArray();
+            // Infer columns from sample documents
+            const fieldTypes = new Map();
+            for (const doc of sampleDocs) {
+                this.extractFieldTypes(doc, '', fieldTypes);
+            }
+            const columns = Array.from(fieldTypes.entries()).map(([name, types]) => ({
+                name,
+                type: Array.from(types).join('|'),
+                nullable: true, // MongoDB is schemaless
+                isPrimaryKey: name === '_id',
+                isUnique: name === '_id',
+                isAutoIncrement: false,
+            }));
+            // Get indexes
+            const indexes = await this.listIndexes(tableName);
+            // Get estimated document count
+            const estimatedCount = await collection.estimatedDocumentCount();
+            return {
+                name: tableName,
+                columns,
+                indexes,
+                constraints: [],
+                primaryKey: ['_id'],
+                estimatedRowCount: estimatedCount,
+            };
         }
         catch (error) {
-            return false;
+            throw database_error_1.DatabaseError.schemaError(`Failed to get collection schema: ${error.message}`, error);
         }
     }
-    // ==================== Index Methods ====================
-    async createIndex(connection, options) {
-        const startTime = Date.now();
+    async createIndex(index, ifNotExists, concurrent) {
+        this.ensureConnected();
         try {
-            const db = connection.getClient();
-            const collection = db.collection(options.table);
+            const collection = this.db.collection(index.table);
+            // Build index specification
             const indexSpec = {};
-            options.index.columns.forEach((col) => {
+            for (const col of index.columns) {
                 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,
+            }
+            // Build index options
+            const indexOptions = {
+                name: index.name,
+                unique: index.unique || false,
+                background: true, // Always create in background
             };
+            // Partial index
+            if (index.where) {
+                // Parse the where clause to a MongoDB filter
+                // This is simplified - a real implementation would parse the expression
+                indexOptions.partialFilterExpression = {};
+            }
+            await collection.createIndex(indexSpec, indexOptions);
         }
         catch (error) {
-            return {
-                success: false,
-                operation: 'create',
-                indexName: options.index.name,
-                table: options.table,
-                error: error.message,
-                executionTime: Date.now() - startTime,
-            };
+            // Ignore if index already exists and ifNotExists is true
+            if (ifNotExists && error.code === 85) {
+                return;
+            }
+            throw database_error_1.DatabaseError.schemaError(`Failed to create index: ${error.message}`, error);
         }
     }
-    async dropIndex(connection, options) {
-        const startTime = Date.now();
+    async dropIndex(tableName, indexName, ifExists, concurrent, cascade) {
+        this.ensureConnected();
         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,
-            };
+            await this.db.collection(tableName).dropIndex(indexName);
         }
         catch (error) {
-            return {
-                success: false,
-                operation: 'drop',
-                indexName: options.indexName,
-                table: options.table,
-                error: error.message,
-                executionTime: Date.now() - startTime,
-            };
+            // Ignore if index doesn't exist and ifExists is true
+            if (ifExists && error.code === 27) {
+                return;
+            }
+            throw database_error_1.DatabaseError.schemaError(`Failed to drop index: ${error.message}`, error);
         }
     }
-    async listIndexes(connection, options) {
+    async listIndexes(tableName, includeSystem) {
+        this.ensureConnected();
         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',
+            const collection = this.db.collection(tableName);
+            const indexes = await collection.indexes();
+            return indexes
+                .filter((idx) => includeSystem || idx.name !== '_id_')
+                .map((idx) => ({
+                name: idx.name,
+                table: tableName,
+                columns: Object.keys(idx.key),
+                unique: idx.unique || false,
+                primaryKey: idx.name === '_id_',
+                type: 'BTREE', // MongoDB uses B-tree by default
             }));
         }
         catch (error) {
-            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.INDEX_ERROR, `Failed to list MongoDB indexes: ${error.message}`, error);
+            throw database_error_1.DatabaseError.schemaError(`Failed to list indexes: ${error.message}`, error);
         }
     }
-    async getIndexStatistics(connection, tableName, indexName) {
+    async getIndexStatistics(tableName, indexName) {
+        var _a, _b;
+        this.ensureConnected();
         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 [];
+            const collection = this.db.collection(tableName);
+            const stats = await collection.aggregate([
+                { $collStats: { storageStats: {} } },
+            ]).toArray();
+            const indexStats = ((_b = (_a = stats[0]) === null || _a === void 0 ? void 0 : _a.storageStats) === null || _b === void 0 ? void 0 : _b.indexSizes) || {};
+            const results = [];
+            for (const [name, size] of Object.entries(indexStats)) {
+                if (indexName && name !== indexName)
+                    continue;
+                results.push({
+                    indexName: name,
+                    tableName,
+                    scans: 0, // MongoDB doesn't expose this easily
+                    tuplesRead: 0,
+                    sizeBytes: size,
+                    sizeFormatted: this.formatBytes(size),
+                });
+            }
+            return results;
         }
         catch (error) {
-            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.INDEX_ERROR, `Failed to get MongoDB index statistics: ${error.message}`, error);
+            throw database_error_1.DatabaseError.schemaError(`Failed to get 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');
+    // ==================== UTILITY METHODS ====================
+    escapeIdentifier(identifier) {
+        // MongoDB doesn't need identifier escaping in the same way SQL databases do
+        return identifier;
     }
-    async getMigrationHistory(connection, options) {
-        // TODO: Implement migration history
-        return [];
+    escapeValue(value) {
+        // MongoDB uses BSON, no escaping needed
+        return JSON.stringify(value);
     }
-    // ==================== Helper Methods ====================
     /**
-     * Build MongoDB filter from where clause
-     * Supports both simplified syntax (GT, LT, AND, OR, etc.) and legacy $ prefix operators
+     * Check if value is an update operator object
      */
-    buildMongoFilter(where) {
-        if (!where) {
-            return {};
+    isUpdateOperator(value) {
+        if (!value || typeof value !== 'object')
+            return false;
+        const operators = ['$INC', '$DEC', '$MUL', '$MIN', '$MAX', '$SET', '$UNSET', '$PUSH', '$PULL', '$ADDTOSET'];
+        return operators.some(op => op in value);
+    }
+    getParameterPlaceholder(index) {
+        // MongoDB doesn't use parameter placeholders like SQL
+        return '';
+    }
+    getColumnTypeString(columnType, options) {
+        // MongoDB is schemaless, but we can map to BSON types
+        const typeMap = {
+            [enums_1.ColumnType.INTEGER]: 'int',
+            [enums_1.ColumnType.BIGINT]: 'long',
+            [enums_1.ColumnType.FLOAT]: 'double',
+            [enums_1.ColumnType.DOUBLE]: 'double',
+            [enums_1.ColumnType.DECIMAL]: 'decimal',
+            [enums_1.ColumnType.STRING]: 'string',
+            [enums_1.ColumnType.TEXT]: 'string',
+            [enums_1.ColumnType.BOOLEAN]: 'bool',
+            [enums_1.ColumnType.DATE]: 'date',
+            [enums_1.ColumnType.DATETIME]: 'date',
+            [enums_1.ColumnType.TIMESTAMP]: 'date',
+            [enums_1.ColumnType.JSON]: 'object',
+            [enums_1.ColumnType.JSONB]: 'object',
+            [enums_1.ColumnType.UUID]: 'string',
+            [enums_1.ColumnType.BINARY]: 'binData',
+            [enums_1.ColumnType.ARRAY]: 'array',
+        };
+        return typeMap[columnType] || columnType;
+    }
+    getSupportedFeatures() {
+        return [
+            base_adapter_1.DatabaseFeature.TRANSACTIONS,
+            base_adapter_1.DatabaseFeature.JSON,
+            base_adapter_1.DatabaseFeature.ARRAYS,
+            base_adapter_1.DatabaseFeature.TTL,
+            base_adapter_1.DatabaseFeature.CHANGE_STREAMS,
+            base_adapter_1.DatabaseFeature.SECONDARY_INDEXES,
+            base_adapter_1.DatabaseFeature.AGGREGATION_PIPELINE,
+            base_adapter_1.DatabaseFeature.ATOMIC_COUNTERS,
+            base_adapter_1.DatabaseFeature.BATCH_OPERATIONS,
+            base_adapter_1.DatabaseFeature.REGEX,
+        ];
+    }
+    parseError(error) {
+        const code = error.code;
+        let type = enums_1.DatabaseErrorType.UNKNOWN_ERROR;
+        // Map MongoDB error codes
+        switch (code) {
+            case 11000: // Duplicate key
+                type = enums_1.DatabaseErrorType.UNIQUE_VIOLATION;
+                break;
+            case 18: // Authentication failed
+                type = enums_1.DatabaseErrorType.AUTHENTICATION_ERROR;
+                break;
+            case 26: // Namespace not found
+                type = enums_1.DatabaseErrorType.NOT_FOUND;
+                break;
+            case 48: // Namespace already exists
+                type = enums_1.DatabaseErrorType.SCHEMA_ERROR;
+                break;
+            default:
+                if (error.name === 'MongoNetworkError') {
+                    type = enums_1.DatabaseErrorType.CONNECTION_ERROR;
+                }
         }
-        if (typeof where !== 'object' || where === null) {
-            return where;
+        return {
+            type,
+            message: error.message || 'Unknown database error',
+            code: String(code),
+            details: {
+                codeName: error.codeName,
+                keyPattern: error.keyPattern,
+                keyValue: error.keyValue,
+            },
+        };
+    }
+    // ==================== PRIVATE HELPER METHODS ====================
+    ensureConnected() {
+        if (!this.connected || !this.db) {
+            throw new database_error_1.DatabaseError('Not connected to MongoDB database', enums_1.DatabaseErrorType.CONNECTION_ERROR);
         }
-        const buildCondition = (condition) => {
-            if (typeof condition !== 'object' || condition === null) {
-                return condition;
+    }
+    buildMongoFilter(where) {
+        const filter = {};
+        for (const [key, value] of Object.entries(where)) {
+            if (key === '$AND') {
+                filter.$and = Object.entries(value).map(([k, v]) => this.buildMongoFilter({ [k]: v }));
             }
-            // 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) };
-                }
+            else if (key === '$OR') {
+                filter.$or = Object.entries(value).map(([k, v]) => this.buildMongoFilter({ [k]: v }));
             }
-            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) };
-                }
+            else if (key === '$NOT') {
+                filter.$nor = [this.buildMongoFilter(value)];
             }
-            // 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;
-                        }
+            else if (value !== null && typeof value === 'object' && !Array.isArray(value) && !(value instanceof Date)) {
+                // Handle operators
+                const fieldFilter = {};
+                for (const [op, opValue] of Object.entries(value)) {
+                    switch (op) {
+                        case '$EQ':
+                            fieldFilter.$eq = opValue;
+                            break;
+                        case '$NE':
+                        case '$NOT':
+                            fieldFilter.$ne = opValue;
+                            break;
+                        case '$GT':
+                            fieldFilter.$gt = opValue;
+                            break;
+                        case '$GTE':
+                            fieldFilter.$gte = opValue;
+                            break;
+                        case '$LT':
+                            fieldFilter.$lt = opValue;
+                            break;
+                        case '$LTE':
+                            fieldFilter.$lte = opValue;
+                            break;
+                        case '$IN':
+                            fieldFilter.$in = opValue;
+                            break;
+                        case '$NOT_IN':
+                            fieldFilter.$nin = opValue;
+                            break;
+                        case '$LIKE':
+                            // Convert SQL LIKE pattern to regex (case-sensitive)
+                            // 1. Escape regex special characters first (except % and _)
+                            // 2. Replace SQL wildcards with regex equivalents
+                            // 3. Anchor pattern to match full string
+                            const likePattern = '^' + opValue
+                                .replace(/[.*+?^${}()|[\]\\]/g, (char) => {
+                                // Don't escape % and _ - they are SQL wildcards
+                                if (char === '%' || char === '_')
+                                    return char;
+                                return '\\' + char;
+                            })
+                                .replace(/%/g, '.*')
+                                .replace(/_/g, '.') + '$';
+                            fieldFilter.$regex = new RegExp(likePattern);
+                            break;
+                        case '$ILIKE':
+                            // Convert SQL ILIKE pattern to regex (case-insensitive)
+                            const ilikePattern = '^' + opValue
+                                .replace(/[.*+?^${}()|[\]\\]/g, (char) => {
+                                if (char === '%' || char === '_')
+                                    return char;
+                                return '\\' + char;
+                            })
+                                .replace(/%/g, '.*')
+                                .replace(/_/g, '.') + '$';
+                            fieldFilter.$regex = new RegExp(ilikePattern, 'i');
+                            break;
+                        case '$IS_NULL':
+                            if (opValue) {
+                                fieldFilter.$eq = null;
+                            }
+                            else {
+                                fieldFilter.$ne = null;
+                            }
+                            break;
+                        case '$IS_NOT_NULL':
+                            if (opValue) {
+                                fieldFilter.$ne = null;
+                            }
+                            else {
+                                fieldFilter.$eq = null;
+                            }
+                            break;
+                        case '$BETWEEN':
+                            const [min, max] = opValue;
+                            fieldFilter.$gte = min;
+                            fieldFilter.$lte = max;
+                            break;
+                        case '$CONTAINS':
+                            fieldFilter.$elemMatch = { $eq: opValue };
+                            break;
+                        case '$OVERLAPS':
+                            fieldFilter.$elemMatch = { $in: opValue };
+                            break;
                     }
-                    filter[key] = operators;
-                }
-                else {
-                    // Simple equality
-                    filter[key] = value;
                 }
+                filter[key] = fieldFilter;
             }
-            return filter;
-        };
-        return buildCondition(where);
+            else {
+                // Simple equality
+                filter[key] = value;
+            }
+        }
+        return filter;
     }
-    // ==================== 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, '_');
+    extractFieldTypes(obj, prefix, fieldTypes) {
+        for (const [key, value] of Object.entries(obj)) {
+            const fieldName = prefix ? `${prefix}.${key}` : key;
+            const type = this.getJsType(value);
+            if (!fieldTypes.has(fieldName)) {
+                fieldTypes.set(fieldName, new Set());
+            }
+            fieldTypes.get(fieldName).add(type);
+            // Recurse into nested objects (but not arrays)
+            if (value && typeof value === 'object' && !Array.isArray(value) && !(value instanceof Date)) {
+                this.extractFieldTypes(value, fieldName, fieldTypes);
+            }
+        }
     }
-    /**
-     * 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) {
+    getJsType(value) {
+        if (value === null)
             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);
+        if (Array.isArray(value))
+            return 'array';
+        if (value instanceof Date)
+            return 'date';
+        if (value && value._bsontype === 'ObjectId')
+            return 'ObjectId';
+        return typeof 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';
-        }
+    formatBytes(bytes) {
+        if (bytes === 0)
+            return '0 B';
+        const k = 1024;
+        const sizes = ['B', 'KB', 'MB', 'GB', 'TB'];
+        const i = Math.floor(Math.log(bytes) / Math.log(k));
+        return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
     }
 }
 exports.MongoDBAdapter = MongoDBAdapter;