@ductape/sdk 0.1.7 → 0.1.8

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

@@ -1,1284 +0,0 @@
-"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