@ductape/sdk 0.0.4-v9 → 0.0.4-v91

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

@@ -0,0 +1,1284 @@
+"use strict";
+/**
+ * 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;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MongoDBAdapter = void 0;
+const base_adapter_1 = require("./base.adapter");
+const enums_1 = require("../types/enums");
+const database_error_1 = require("../utils/database-error");
+/**
+ * MongoDB database adapter
+ * Provides MongoDB-specific implementations for all database operations
+ */
+class MongoDBAdapter extends base_adapter_1.BaseAdapter {
+    constructor() {
+        super(...arguments);
+        this.databaseType = enums_1.DatabaseType.MONGODB;
+        this.mongoClient = null;
+        this.db = null;
+        this.databaseName = '';
+    }
+    // ==================== CONNECTION METHODS ====================
+    async connect(options) {
+        console.log(`[MongoDBAdapter] connect() called`);
+        console.log(`[MongoDBAdapter] Options:`, JSON.stringify(Object.assign(Object.assign({}, options), { connectionUrl: '***REDACTED***' }), null, 2));
+        try {
+            console.log(`[MongoDBAdapter] Importing 'mongodb' library...`);
+            // Dynamic import of mongodb to avoid bundling issues
+            const { MongoClient } = await Promise.resolve().then(() => __importStar(require('mongodb')));
+            console.log(`[MongoDBAdapter] 'mongodb' library imported successfully`);
+            this.connectionUrl = options.connectionUrl;
+            console.log(`[MongoDBAdapter] Connection URL stored`);
+            console.log(`[MongoDBAdapter] Connection URL length: ${options.connectionUrl.length}`);
+            // Parse connection URL to extract database name
+            console.log(`[MongoDBAdapter] Parsing connection URL...`);
+            const url = new URL(options.connectionUrl);
+            this.databaseName = url.pathname.slice(1) || 'test';
+            const parsedConfig = {
+                protocol: url.protocol,
+                hostname: url.hostname,
+                port: url.port || 'default',
+                database: this.databaseName,
+                username: url.username || 'not specified',
+                hasPassword: !!url.password,
+            };
+            console.log(`[MongoDBAdapter] Connection URL parsed:`, parsedConfig);
+            const clientConfig = {
+                maxPoolSize: options.poolSize || 10,
+                connectTimeoutMS: options.connectionTimeout || 10000,
+                serverSelectionTimeoutMS: options.connectionTimeout || 10000,
+            };
+            console.log(`[MongoDBAdapter] Client config:`, clientConfig);
+            console.log(`[MongoDBAdapter] Creating MongoClient...`);
+            this.mongoClient = new MongoClient(options.connectionUrl, clientConfig);
+            console.log(`[MongoDBAdapter] MongoClient created successfully`);
+            console.log(`[MongoDBAdapter] Connecting to MongoDB...`);
+            await this.mongoClient.connect();
+            console.log(`[MongoDBAdapter] Connected to MongoDB successfully`);
+            console.log(`[MongoDBAdapter] Getting database: ${this.databaseName}`);
+            this.db = this.mongoClient.db(this.databaseName);
+            console.log(`[MongoDBAdapter] Database instance acquired`);
+            console.log(`[MongoDBAdapter] Getting server info...`);
+            // Get server info
+            const adminDb = this.mongoClient.db('admin');
+            const serverInfo = await adminDb.command({ buildInfo: 1 });
+            console.log(`[MongoDBAdapter] Server info retrieved successfully`);
+            console.log(`[MongoDBAdapter] MongoDB version:`, serverInfo.version);
+            this.client = this.mongoClient;
+            this.connected = true;
+            console.log(`[MongoDBAdapter] Connection marked as connected`);
+            return {
+                connected: true,
+                version: serverInfo.version,
+            };
+        }
+        catch (error) {
+            console.error(`[MongoDBAdapter] Connection failed with error:`, error);
+            console.error(`[MongoDBAdapter] Error type:`, error.constructor.name);
+            console.error(`[MongoDBAdapter] Error message:`, error.message);
+            console.error(`[MongoDBAdapter] Error code:`, error.code);
+            console.error(`[MongoDBAdapter] Full error:`, JSON.stringify(error, null, 2));
+            throw database_error_1.DatabaseError.connectionError(`Failed to connect to MongoDB: ${error.message}`, error);
+        }
+    }
+    async testConnection(options) {
+        try {
+            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,
+                version: serverInfo.version,
+            };
+        }
+        catch (error) {
+            return {
+                connected: false,
+            };
+        }
+    }
+    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 {
+            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;
+                }
+            }
+            // 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;
+            }
+            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 database_error_1.DatabaseError.fromDatabaseError(error, 'mongodb');
+        }
+    }
+    async raw(options) {
+        var _a, _b;
+        this.ensureConnected();
+        try {
+            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,
+                    };
+                }
+            }
+            // 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,
+                count: data.length,
+            };
+        }
+        catch (error) {
+            throw database_error_1.DatabaseError.fromDatabaseError(error, 'mongodb');
+        }
+    }
+    // ==================== WRITE METHODS ====================
+    async insert(options) {
+        var _a;
+        this.ensureConnected();
+        try {
+            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 {
+                data: returnedData,
+                count: result.insertedCount,
+                insertedIds: Object.values(result.insertedIds),
+            };
+        }
+        catch (error) {
+            throw database_error_1.DatabaseError.fromDatabaseError(error, 'mongodb');
+        }
+    }
+    async update(options) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
+        this.ensureConnected();
+        try {
+            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
+                    // Support both lowercase (new) and uppercase (legacy) operators
+                    if ('$inc' in value || '$INC' in value) {
+                        if (!updateDoc.$inc)
+                            updateDoc.$inc = {};
+                        updateDoc.$inc[key] = (_b = value.$inc) !== null && _b !== void 0 ? _b : value.$INC;
+                    }
+                    else if ('$dec' in value || '$DEC' in value) {
+                        // MongoDB uses $inc with negative value for decrement
+                        if (!updateDoc.$inc)
+                            updateDoc.$inc = {};
+                        updateDoc.$inc[key] = -((_c = value.$dec) !== null && _c !== void 0 ? _c : value.$DEC);
+                    }
+                    else if ('$mul' in value || '$MUL' in value) {
+                        if (!updateDoc.$mul)
+                            updateDoc.$mul = {};
+                        updateDoc.$mul[key] = (_d = value.$mul) !== null && _d !== void 0 ? _d : value.$MUL;
+                    }
+                    else if ('$min' in value || '$MIN' in value) {
+                        if (!updateDoc.$min)
+                            updateDoc.$min = {};
+                        updateDoc.$min[key] = (_e = value.$min) !== null && _e !== void 0 ? _e : value.$MIN;
+                    }
+                    else if ('$max' in value || '$MAX' in value) {
+                        if (!updateDoc.$max)
+                            updateDoc.$max = {};
+                        updateDoc.$max[key] = (_f = value.$max) !== null && _f !== void 0 ? _f : value.$MAX;
+                    }
+                    else if ('$set' in value || '$SET' in value) {
+                        updateDoc.$set[key] = (_g = value.$set) !== null && _g !== void 0 ? _g : value.$SET;
+                    }
+                    else if (('$unset' in value && value.$unset) || ('$UNSET' in value && value.$UNSET)) {
+                        if (!updateDoc.$unset)
+                            updateDoc.$unset = {};
+                        updateDoc.$unset[key] = '';
+                    }
+                    else if ('$push' in value || '$PUSH' in value) {
+                        if (!updateDoc.$push)
+                            updateDoc.$push = {};
+                        updateDoc.$push[key] = (_h = value.$push) !== null && _h !== void 0 ? _h : value.$PUSH;
+                    }
+                    else if ('$pull' in value || '$PULL' in value) {
+                        if (!updateDoc.$pull)
+                            updateDoc.$pull = {};
+                        updateDoc.$pull[key] = (_j = value.$pull) !== null && _j !== void 0 ? _j : value.$PULL;
+                    }
+                    else if ('$addToSet' in value || '$ADDTOSET' in value) {
+                        if (!updateDoc.$addToSet)
+                            updateDoc.$addToSet = {};
+                        updateDoc.$addToSet[key] = (_k = value.$addToSet) !== null && _k !== void 0 ? _k : value.$ADDTOSET;
+                    }
+                    else if ('$pop' in value || '$POP' in value) {
+                        if (!updateDoc.$pop)
+                            updateDoc.$pop = {};
+                        updateDoc.$pop[key] = (_l = value.$pop) !== null && _l !== void 0 ? _l : value.$POP;
+                    }
+                    else if ('$rename' in value || '$RENAME' in value) {
+                        if (!updateDoc.$rename)
+                            updateDoc.$rename = {};
+                        updateDoc.$rename[key] = (_m = value.$rename) !== null && _m !== void 0 ? _m : value.$RENAME;
+                    }
+                    else if ('$currentDate' in value || '$CURRENTDATE' in value) {
+                        if (!updateDoc.$currentDate)
+                            updateDoc.$currentDate = {};
+                        updateDoc.$currentDate[key] = (_o = value.$currentDate) !== null && _o !== void 0 ? _o : value.$CURRENTDATE;
+                    }
+                }
+                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 {
+                data: returnedData,
+                count: result.modifiedCount,
+            };
+        }
+        catch (error) {
+            throw database_error_1.DatabaseError.fromDatabaseError(error, 'mongodb');
+        }
+    }
+    async delete(options) {
+        var _a;
+        this.ensureConnected();
+        try {
+            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 {
+                count: result.deletedCount,
+                data: deletedData,
+            };
+        }
+        catch (error) {
+            throw database_error_1.DatabaseError.fromDatabaseError(error, 'mongodb');
+        }
+    }
+    async upsert(options) {
+        var _a, _b;
+        this.ensureConnected();
+        try {
+            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 = {};
+            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,
+            });
+            return {
+                data: result.value ? [result.value] : [],
+                count: 1,
+                operation: ((_b = result.lastErrorObject) === null || _b === void 0 ? void 0 : _b.updatedExisting) ? 'updated' : 'inserted',
+            };
+        }
+        catch (error) {
+            throw database_error_1.DatabaseError.fromDatabaseError(error, 'mongodb');
+        }
+    }
+    // ==================== AGGREGATION METHODS ====================
+    async count(options) {
+        var _a, _b;
+        this.ensureConnected();
+        try {
+            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 database_error_1.DatabaseError.fromDatabaseError(error, 'mongodb');
+        }
+    }
+    async sum(options) {
+        var _a, _b;
+        this.ensureConnected();
+        try {
+            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 database_error_1.DatabaseError.fromDatabaseError(error, 'mongodb');
+        }
+    }
+    async avg(options) {
+        var _a, _b;
+        this.ensureConnected();
+        try {
+            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 database_error_1.DatabaseError.fromDatabaseError(error, 'mongodb');
+        }
+    }
+    async min(options) {
+        var _a, _b;
+        this.ensureConnected();
+        try {
+            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 database_error_1.DatabaseError.fromDatabaseError(error, 'mongodb');
+        }
+    }
+    async max(options) {
+        var _a, _b;
+        this.ensureConnected();
+        try {
+            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 database_error_1.DatabaseError.fromDatabaseError(error, 'mongodb');
+        }
+    }
+    async aggregate(builtAggregation) {
+        var _a;
+        this.ensureConnected();
+        try {
+            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 database_error_1.DatabaseError.fromDatabaseError(error, 'mongodb');
+        }
+    }
+    async groupBy(builtGroupBy) {
+        var _a;
+        this.ensureConnected();
+        try {
+            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];
+                    }
+                }
+                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' };
+            }
+            else {
+                transactionOptions.readConcern = { level: 'majority' };
+                transactionOptions.writeConcern = { w: 'majority' };
+            }
+            if (timeout) {
+                transactionOptions.maxCommitTimeMS = timeout;
+            }
+            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 database_error_1.DatabaseError.transactionError(`Failed to begin transaction: ${error.message}`, error);
+        }
+    }
+    async commitTransaction(context) {
+        try {
+            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);
+                }
+            }
+            // 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 });
+                }
+                // Register auto-increment fields in the counters collection
+                if (column.autoIncrement) {
+                    await this.registerAutoIncrementField(definition.name, column.name);
+                }
+            }
+            // 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;
+            }
+            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
+            }
+        }, { 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;
+        }
+        // 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);
+        });
+    }
+    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 {
+            for (const op of operations) {
+                if (op.type === 'ADD' && op.constraint && op.constraint.type === 'UNIQUE') {
+                    // Add unique index
+                    const indexSpec = {};
+                    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 } });
+                }
+            }
+        }
+        catch (error) {
+            throw database_error_1.DatabaseError.schemaError(`Failed to alter collection: ${error.message}`, error);
+        }
+    }
+    async dropTable(tableName, ifExists, cascade) {
+        this.ensureConnected();
+        try {
+            await this.db.collection(tableName).drop();
+        }
+        catch (error) {
+            // 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 listTables() {
+        this.ensureConnected();
+        try {
+            const collections = await this.db.listCollections().toArray();
+            return collections.map((c) => c.name);
+        }
+        catch (error) {
+            throw database_error_1.DatabaseError.schemaError(`Failed to list collections: ${error.message}`, error);
+        }
+    }
+    async listTablesWithInfo() {
+        this.ensureConnected();
+        try {
+            const collections = await this.db.listCollections().toArray();
+            // Get estimated document count for each collection
+            const tablesWithInfo = await Promise.all(collections.map(async (c) => {
+                var _a, _b;
+                try {
+                    const collection = this.db.collection(c.name);
+                    const count = await collection.estimatedDocumentCount();
+                    return {
+                        name: c.name,
+                        estimatedRowCount: count,
+                        comment: (_a = c.options) === null || _a === void 0 ? void 0 : _a.description,
+                    };
+                }
+                catch (error) {
+                    // If we can't get count for a collection, return it without count
+                    return {
+                        name: c.name,
+                        estimatedRowCount: undefined,
+                        comment: (_b = c.options) === null || _b === void 0 ? void 0 : _b.description,
+                    };
+                }
+            }));
+            return tablesWithInfo;
+        }
+        catch (error) {
+            throw database_error_1.DatabaseError.schemaError(`Failed to list collections with info: ${error.message}`, error);
+        }
+    }
+    async tableExists(tableName) {
+        this.ensureConnected();
+        try {
+            const collections = await this.db.listCollections({ name: tableName }).toArray();
+            return collections.length > 0;
+        }
+        catch (error) {
+            throw database_error_1.DatabaseError.schemaError(`Failed to check collection existence: ${error.message}`, error);
+        }
+    }
+    async getTableSchema(tableName) {
+        this.ensureConnected();
+        try {
+            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) {
+            throw database_error_1.DatabaseError.schemaError(`Failed to get collection schema: ${error.message}`, error);
+        }
+    }
+    async createIndex(index, ifNotExists, concurrent) {
+        this.ensureConnected();
+        try {
+            const collection = this.db.collection(index.table);
+            // Build index specification
+            const indexSpec = {};
+            for (const col of index.columns) {
+                indexSpec[col.name] = col.order === 'DESC' ? -1 : 1;
+            }
+            // 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) {
+            // 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(tableName, indexName, ifExists, concurrent, cascade) {
+        this.ensureConnected();
+        try {
+            await this.db.collection(tableName).dropIndex(indexName);
+        }
+        catch (error) {
+            // 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(tableName, includeSystem) {
+        this.ensureConnected();
+        try {
+            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 database_error_1.DatabaseError.schemaError(`Failed to list indexes: ${error.message}`, error);
+        }
+    }
+    async getIndexStatistics(tableName, indexName) {
+        var _a, _b;
+        this.ensureConnected();
+        try {
+            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 database_error_1.DatabaseError.schemaError(`Failed to get index statistics: ${error.message}`, error);
+        }
+    }
+    // ==================== UTILITY METHODS ====================
+    escapeIdentifier(identifier) {
+        // MongoDB doesn't need identifier escaping in the same way SQL databases do
+        return identifier;
+    }
+    escapeValue(value) {
+        // MongoDB uses BSON, no escaping needed
+        return JSON.stringify(value);
+    }
+    /**
+     * Check if value is an update operator object
+     * Supports both lowercase (new) and uppercase (legacy) operators
+     */
+    isUpdateOperator(value) {
+        if (!value || typeof value !== 'object')
+            return false;
+        // Support both lowercase (Mongoose style) and uppercase (legacy) operators
+        const operators = [
+            '$inc', '$INC', '$dec', '$DEC', '$mul', '$MUL', '$min', '$MIN', '$max', '$MAX',
+            '$set', '$SET', '$unset', '$UNSET', '$push', '$PUSH', '$pull', '$PULL',
+            '$addToSet', '$ADDTOSET', '$pop', '$POP', '$rename', '$RENAME', '$currentDate', '$CURRENTDATE'
+        ];
+        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;
+                }
+        }
+        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);
+        }
+    }
+    buildMongoFilter(where) {
+        const filter = {};
+        for (const [key, value] of Object.entries(where)) {
+            // Normalize key to lowercase for logical operators (support both cases for backwards compatibility)
+            const normalizedKey = key.toLowerCase();
+            if (normalizedKey === '$and') {
+                const conditions = Array.isArray(value) ? value : Object.entries(value).map(([k, v]) => ({ [k]: v }));
+                filter.$and = conditions.map((cond) => this.buildMongoFilter(cond));
+            }
+            else if (normalizedKey === '$or') {
+                const conditions = Array.isArray(value) ? value : Object.entries(value).map(([k, v]) => ({ [k]: v }));
+                filter.$or = conditions.map((cond) => this.buildMongoFilter(cond));
+            }
+            else if (normalizedKey === '$not') {
+                filter.$nor = [this.buildMongoFilter(value)];
+            }
+            else if (normalizedKey === '$nor') {
+                const conditions = Array.isArray(value) ? value : [value];
+                filter.$nor = conditions.map((cond) => this.buildMongoFilter(cond));
+            }
+            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)) {
+                    // Normalize operator to lowercase (support both cases for backwards compatibility)
+                    const normalizedOp = op.toLowerCase();
+                    switch (normalizedOp) {
+                        case '$eq':
+                            fieldFilter.$eq = opValue;
+                            break;
+                        case '$ne':
+                            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 '$nin':
+                        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 '$isnull':
+                        case '$is_null':
+                            if (opValue) {
+                                fieldFilter.$eq = null;
+                            }
+                            else {
+                                fieldFilter.$ne = null;
+                            }
+                            break;
+                        case '$isnotnull':
+                        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;
+                        case '$regex':
+                            if (typeof opValue === 'string') {
+                                fieldFilter.$regex = new RegExp(opValue);
+                            }
+                            else if (opValue instanceof RegExp) {
+                                fieldFilter.$regex = opValue;
+                            }
+                            break;
+                        case '$exists':
+                            fieldFilter.$exists = opValue;
+                            break;
+                    }
+                }
+                filter[key] = fieldFilter;
+            }
+            else {
+                // Simple equality
+                filter[key] = value;
+            }
+        }
+        return filter;
+    }
+    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);
+            }
+        }
+    }
+    getJsType(value) {
+        if (value === null)
+            return 'null';
+        if (Array.isArray(value))
+            return 'array';
+        if (value instanceof Date)
+            return 'date';
+        if (value && value._bsontype === 'ObjectId')
+            return 'ObjectId';
+        return typeof value;
+    }
+    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;
+//# sourceMappingURL=mongodb.adapter.js.map