@warlock.js/cascade 4.0.162 → 4.0.164

package/cjs/drivers/mongodb/mongodb-driver.js

@@ -0,0 +1,838 @@
+'use strict';var copper=require('@mongez/copper'),logger=require('@warlock.js/logger'),node_events=require('node:events'),databaseTransactionContext=require('../../context/database-transaction-context.js'),dataSourceRegistry=require('../../data-source/data-source-registry.js'),databaseDirtyTracker=require('../../database-dirty-tracker.js'),transactionRollback_error=require('../../errors/transaction-rollback.error.js'),isValidDateValue=require('../../utils/is-valid-date-value.js'),mongodbBlueprint=require('./mongodb-blueprint.js'),mongodbIdGenerator=require('./mongodb-id-generator.js'),mongodbMigrationDriver=require('./mongodb-migration-driver.js'),mongodbQueryBuilder=require('./mongodb-query-builder.js'),mongodbSyncAdapter=require('./mongodb-sync-adapter.js');function _interopNamespace(e){if(e&&e.__esModule)return e;var n=Object.create(null);if(e){Object.keys(e).forEach(function(k){if(k!=='default'){var d=Object.getOwnPropertyDescriptor(e,k);Object.defineProperty(n,k,d.get?d:{enumerable:true,get:function(){return e[k]}});}})}n.default=e;return Object.freeze(n)}const DEFAULT_TRANSACTION_OPTIONS = {
+    readPreference: "primary",
+    readConcern: { level: "local" },
+    writeConcern: { w: "majority" },
+};
+// ============================================================
+// Lazy-loaded MongoDB SDK Types
+// ============================================================
+/**
+ * Cached MongoDB module (loaded once, reused)
+ */
+let MongoDBClient;
+let ObjectId;
+let isModuleExists = null;
+let loadingPromise;
+/**
+ * Installation instructions for MongoDB package
+ */
+const MONGODB_INSTALL_INSTRUCTIONS = `
+MongoDB driver requires the mongodb package.
+Install it with:
+
+  npm install mongodb
+
+Or with your preferred package manager:
+
+  pnpm add mongodb
+  yarn add mongodb
+`.trim();
+/**
+ * Load MongoDB module
+ */
+async function loadMongoDB() {
+    try {
+        loadingPromise = Promise.resolve().then(function(){return /*#__PURE__*/_interopNamespace(require('mongodb'))});
+        MongoDBClient = await loadingPromise;
+        ObjectId = MongoDBClient.ObjectId;
+        isModuleExists = true;
+    }
+    catch {
+        isModuleExists = false;
+    }
+}
+loadMongoDB();
+function isMongoDBDriverLoaded() {
+    return isModuleExists;
+}
+async function assertModuleIsLoaded() {
+    if (isModuleExists === false) {
+        throw new Error(MONGODB_INSTALL_INSTRUCTIONS);
+    }
+    if (isModuleExists === null) {
+        await loadingPromise;
+        return await assertModuleIsLoaded();
+    }
+}
+/**
+ * MongoDB driver implementation that fulfils the Cascade driver contract.
+ *
+ * It encapsulates the native Mongo client, exposes lifecycle events, and
+ * provides helpers for CRUD, transactions, atomic updates, and sync adapters.
+ */
+class MongoDbDriver {
+    config;
+    driverOptions;
+    events = new node_events.EventEmitter();
+    client;
+    database;
+    connected = false;
+    syncAdapterInstance;
+    migrationDriverInstance;
+    transactionOptions;
+    idGeneratorInstance;
+    _blueprint;
+    get blueprint() {
+        if (!this._blueprint) {
+            this._blueprint = new mongodbBlueprint.MongoDBBlueprint(this.database);
+        }
+        return this._blueprint;
+    }
+    /**
+     * The name of this driver.
+     */
+    name = "mongodb";
+    /**
+     * Current database name
+     */
+    _databaseName;
+    /**
+     * MongoDB driver model defaults.
+     *
+     * MongoDB follows NoSQL conventions:
+     * - camelCase naming for fields (createdAt, updatedAt, deletedAt)
+     * - Manual ID generation (auto-increment id field separate from _id)
+     * - Timestamps enabled by default
+     * - Trash delete strategy with per-collection trash tables
+     */
+    modelDefaults = {
+        namingConvention: "camelCase",
+        createdAtColumn: "createdAt",
+        updatedAtColumn: "updatedAt",
+        deletedAtColumn: "deletedAt",
+        timestamps: true,
+        autoGenerateId: true,
+        strictMode: "strip",
+        deleteStrategy: "trash",
+        trashTable: (table) => `${table}Trash`, // Per-collection trash (usersTrash, productsTrash)
+    };
+    /**
+     * Create a new MongoDB driver using the supplied connection options.
+     *
+     * @param config - Connection configuration
+     * @param driverOptions - Driver-specific options
+     */
+    constructor(config, driverOptions) {
+        this.config = config;
+        this.driverOptions = driverOptions;
+        this.transactionOptions = {
+            ...DEFAULT_TRANSACTION_OPTIONS,
+            ...driverOptions?.transactionOptions,
+        };
+    }
+    /**
+     * Get data base name
+     */
+    get databaseName() {
+        if (!this._databaseName) {
+            this.resolveDatabaseName();
+        }
+        return this._databaseName;
+    }
+    /**
+     * Resolve database name either from config or uri
+     */
+    resolveDatabaseName() {
+        if (this.config.database) {
+            this._databaseName = this.config.database;
+        }
+        else if (this.config.uri) {
+            this._databaseName = this.config.uri.split("/").pop()?.split("?")?.[0];
+        }
+    }
+    /**
+     * Indicates whether the driver currently maintains an active connection.
+     */
+    get isConnected() {
+        return this.connected;
+    }
+    /**
+     * Get the MongoDB database instance.
+     *
+     * @returns The MongoDB Db instance
+     * @throws {Error} If not connected
+     *
+     * @example
+     * ```typescript
+     * const db = driver.getDatabase();
+     * const collection = db.collection("users");
+     * ```
+     */
+    getDatabase() {
+        if (!this.database) {
+            throw new Error("Database not available. Ensure the driver is connected before accessing the database.");
+        }
+        return this.database;
+    }
+    /**
+     * Get the ID generator instance for this driver.
+     *
+     * Creates a MongoIdGenerator on first access if autoGenerateId is enabled.
+     *
+     * @returns The ID generator instance, or undefined if disabled
+     *
+     * @example
+     * ```typescript
+     * const idGenerator = driver.getIdGenerator();
+     * if (idGenerator) {
+     *   const id = await idGenerator.generateNextId({ table: "users" });
+     * }
+     * ```
+     */
+    getIdGenerator() {
+        // Return undefined if ID generation is disabled
+        if (this.driverOptions?.autoGenerateId === false) {
+            return undefined;
+        }
+        // Create ID generator lazily on first access
+        if (!this.idGeneratorInstance) {
+            this.idGeneratorInstance = new mongodbIdGenerator.MongoIdGenerator(this, this.driverOptions?.counterCollection);
+        }
+        return this.idGeneratorInstance;
+    }
+    /**
+     * Establish a MongoDB connection using the configured options.
+     * Throws if the connection attempt fails.
+     */
+    async connect() {
+        if (this.connected) {
+            return;
+        }
+        await assertModuleIsLoaded();
+        const uri = this.resolveUri();
+        const { MongoClient, ObjectId: ObjectIdMongoDB } = MongoDBClient;
+        ObjectId = ObjectIdMongoDB;
+        const client = new MongoClient(uri, this.buildClientOptions());
+        try {
+            logger.log.info("database.mongodb", "connection", `Connecting to database ${copper.colors.bold(copper.colors.yellowBright(this.databaseName))}`);
+            await client.connect();
+            this.client = client;
+            this.database = client.db(this.databaseName);
+            this.connected = true;
+            logger.log.success("database.mongodb", "connection", "Connected to database");
+            client.on("close", () => {
+                if (this.connected) {
+                    this.connected = false;
+                    this.emit("disconnected");
+                    logger.log.warn("database.mongodb", "connection", "Disconnected from database");
+                }
+            });
+            if (this.config.logging) {
+                const ignoredCommands = ["isMaster", "hello", "ping", "saslStart", "saslContinue"];
+                client.on("commandStarted", (event) => {
+                    if (ignoredCommands.includes(event.commandName))
+                        return;
+                    let cmdStr = JSON.stringify(event.command);
+                    if (cmdStr.length > 300) {
+                        cmdStr = cmdStr.substring(0, 300) + "...";
+                    }
+                    logger.log.info({
+                        module: "database.mongodb",
+                        action: "query.executing",
+                        message: `[${event.commandName}] ${cmdStr}`,
+                        context: { command: event.command },
+                    });
+                });
+                client.on("commandSucceeded", (event) => {
+                    if (ignoredCommands.includes(event.commandName))
+                        return;
+                    logger.log.success({
+                        module: "database.mongodb",
+                        action: "query.executed",
+                        message: `[${event.duration.toFixed(2)}ms] [${event.commandName}]`,
+                    });
+                });
+                client.on("commandFailed", (event) => {
+                    if (ignoredCommands.includes(event.commandName))
+                        return;
+                    logger.log.error({
+                        module: "database.mongodb",
+                        action: "query.error",
+                        message: `[${event.duration.toFixed(2)}ms] [${event.commandName}]`,
+                        context: { failure: event.failure },
+                    });
+                });
+            }
+            this.emit("connected");
+        }
+        catch (error) {
+            await client.close().catch(() => undefined);
+            this.emit("disconnected");
+            logger.log.error("database.mongodb", "connection", `Failed to connect to database: ${error.message}`);
+            throw error;
+        }
+    }
+    /**
+     * Close the underlying MongoDB connection.
+     */
+    async disconnect() {
+        if (!this.client) {
+            return;
+        }
+        try {
+            await this.client.close();
+        }
+        finally {
+            this.connected = false;
+            this.emit("disconnected");
+        }
+    }
+    /**
+     * Subscribe to driver lifecycle events.
+     */
+    on(event, listener) {
+        this.events.on(event, listener);
+    }
+    /**
+     * Insert a single document into the given collection.
+     */
+    async insert(table, document, options) {
+        const collection = this.getDatabaseInstance().collection(table);
+        const mongoOptions = this.withSession(options);
+        const result = await collection.insertOne(document, mongoOptions);
+        return {
+            document: {
+                ...document,
+                _id: result.insertedId,
+            },
+        };
+    }
+    /**
+     * Insert multiple documents into the given collection.
+     */
+    async insertMany(table, documents, options) {
+        const collection = this.getDatabaseInstance().collection(table);
+        const mongoOptions = this.withSession(options);
+        const result = await collection.insertMany(documents, mongoOptions);
+        return documents.map((document, index) => {
+            const insertedId = result.insertedIds[index];
+            return {
+                document: {
+                    ...document,
+                    _id: insertedId,
+                },
+            };
+        });
+    }
+    /**
+     * Update a single document that matches the provided filter.
+     */
+    async update(table, filter, update, options) {
+        const collection = this.getDatabaseInstance().collection(table);
+        const mongoOptions = this.withSession(options);
+        const result = await collection.updateOne(filter, update, mongoOptions);
+        return { modifiedCount: result.modifiedCount };
+    }
+    /**
+     * Replace a single document that matches the provided filter.
+     */
+    async replace(table, filter, document, options) {
+        const collection = this.getDatabaseInstance().collection(table);
+        const result = await collection.findOneAndReplace(filter, document);
+        return result?.value;
+    }
+    /**
+     * Find one and update a single document that matches the provided filter and return the updated document
+     */
+    async findOneAndUpdate(table, filter, update, options) {
+        const collection = this.getDatabaseInstance().collection(table);
+        const mongoOptions = this.withSession(options);
+        const result = await collection.findOneAndUpdate(filter, update, {
+            returnDocument: "after",
+            ...mongoOptions,
+        });
+        return result;
+    }
+    /**
+     * Upsert (insert or update) a single document.
+     *
+     * Uses MongoDB's findOneAndUpdate with upsert option.
+     *
+     * @param table - Target collection name
+     * @param filter - Filter conditions to find existing document
+     * @param document - Document data to insert or update
+     * @param options - Optional upsert options
+     * @returns The upserted document
+     */
+    async upsert(table, filter, document, options) {
+        const collection = this.getDatabaseInstance().collection(table);
+        const mongoOptions = this.withSession(options);
+        // Use $set to update all fields from document
+        const update = { $set: document };
+        const result = await collection.findOneAndUpdate(filter, update, {
+            upsert: true,
+            returnDocument: "after",
+            ...mongoOptions,
+        });
+        return result;
+    }
+    /**
+     * Find one and delete a single document that matches the provided filter and return the deleted document.
+     *
+     * @param table - Target collection name
+     * @param filter - Filter conditions
+     * @param options - Optional delete options
+     * @returns The deleted document or null if not found
+     */
+    async findOneAndDelete(table, filter, options) {
+        const collection = this.getDatabaseInstance().collection(table);
+        const mongoOptions = this.withSession(options);
+        const result = await collection.findOneAndDelete(filter, mongoOptions || {});
+        return result;
+    }
+    /**
+     * Update multiple documents that match the provided filter.
+     */
+    async updateMany(table, filter, update, options) {
+        const collection = this.getDatabaseInstance().collection(table);
+        const mongoOptions = this.withSession(options);
+        const result = await collection.updateMany(filter, update, mongoOptions);
+        return { modifiedCount: result.modifiedCount };
+    }
+    /**
+     * Delete a single document that matches the provided filter.
+     */
+    async delete(table, filter = {}, options) {
+        const collection = this.getDatabaseInstance().collection(table);
+        const mongoOptions = this.withSession(options);
+        const result = await collection.deleteOne(filter, mongoOptions);
+        return result.deletedCount > 0 ? 1 : 0;
+    }
+    /**
+     * Delete documents that match the provided filter.
+     */
+    async deleteMany(table, filter = {}, options) {
+        const collection = this.getDatabaseInstance().collection(table);
+        const mongoOptions = this.withSession(options);
+        const result = await collection.deleteMany(filter, mongoOptions);
+        return result.deletedCount ?? 0;
+    }
+    /**
+     * Remove all records from a collection.
+     *
+     * This uses deleteMany with an empty filter to remove all documents.
+     * For very large collections, consider using the migration driver's
+     * dropTable + createTable approach for better performance.
+     */
+    async truncateTable(table, options) {
+        const collection = this.getDatabaseInstance().collection(table);
+        const mongoOptions = this.withSession(options);
+        const result = await collection.deleteMany({}, mongoOptions);
+        return result.deletedCount ?? 0;
+    }
+    /**
+     * Serialize the given data
+     */
+    serialize(data) {
+        for (const [key, value] of Object.entries(data)) {
+            if (value === undefined) {
+                continue; // Skip undefined values
+            }
+            if (value instanceof ObjectId) {
+                value.toString();
+            }
+            else if (value instanceof Date) {
+                value.toISOString();
+            }
+            else if (typeof value === "bigint") {
+                value.toString();
+            }
+            else ;
+        }
+        return data;
+    }
+    /**
+     * Get the dirty tracker for this driver.
+     */
+    getDirtyTracker(data) {
+        return new databaseDirtyTracker.DatabaseDirtyTracker(data);
+    }
+    /**
+     * Deserialize the given data
+     */
+    deserialize(data) {
+        if (data._id && typeof data._id === "string") {
+            data._id = new ObjectId(data._id);
+        }
+        for (const [key, value] of Object.entries(data)) {
+            // Only re-inflate strings — Mongo driver already returns Date objects from DB reads
+            if (typeof value === "string" && isValidDateValue.isValidDateValue(value)) {
+                data[key] = new Date(value);
+            }
+        }
+        return data;
+    }
+    /**
+     * Provide a Mongo-backed query builder instance for the given collection.
+     */
+    queryBuilder(table) {
+        return new mongodbQueryBuilder.MongoQueryBuilder(table, dataSourceRegistry.dataSourceRegistry.get());
+    }
+    /**
+     * Begin a MongoDB transaction, returning commit/rollback helpers.
+     */
+    async beginTransaction() {
+        const client = this.getClientInstance();
+        const session = client.startSession();
+        await session.startTransaction(this.transactionOptions);
+        databaseTransactionContext.databaseTransactionContext.enter({ session });
+        let finished = false;
+        const finalize = async (operation) => {
+            if (finished)
+                return;
+            try {
+                await operation();
+            }
+            finally {
+                finished = true;
+                databaseTransactionContext.databaseTransactionContext.exit();
+                await session.endSession().catch(() => undefined);
+            }
+        };
+        return {
+            context: session,
+            commit: async () => {
+                await finalize(async () => {
+                    try {
+                        await session.commitTransaction();
+                    }
+                    catch (error) {
+                        await session.abortTransaction().catch(() => undefined);
+                        throw error;
+                    }
+                });
+            },
+            rollback: async () => {
+                await finalize(async () => {
+                    await session.abortTransaction();
+                });
+            },
+        };
+    }
+    /**
+     * Execute a function within a transaction scope (recommended pattern).
+     *
+     * Automatically commits on success, rolls back on any error, and guarantees
+     * resource cleanup. This is the recommended way to use transactions.
+     *
+     * **MongoDB Requirements:**
+     * - Requires MongoDB 4.0+ with replica set or sharded cluster
+     * - Standalone MongoDB instances do not support transactions
+     *
+     * @param fn - Async function to execute within transaction
+     * @param options - Transaction options (read preference, write concern, etc.)
+     * @returns The return value of the callback function
+     * @throws {Error} If transaction fails, is explicitly rolled back, or replica set not configured
+     */
+    async transaction(fn, options) {
+        // Prevent nested transaction() calls
+        if (databaseTransactionContext.databaseTransactionContext.hasActiveTransaction()) {
+            throw new Error("Nested transaction() calls are not supported. " +
+                "Use beginTransaction() with savepoints for advanced transaction patterns.");
+        }
+        // Check if MongoDB is running as a replica set (required for transactions)
+        await this.ensureReplicaSetAvailable();
+        const client = this.getClientInstance();
+        const session = client.startSession();
+        try {
+            await session.startTransaction({
+                ...this.transactionOptions,
+                ...options,
+            });
+            // Set transaction context for queries within callback
+            databaseTransactionContext.databaseTransactionContext.enter({ session });
+            try {
+                // Create transaction context with rollback method
+                const ctx = {
+                    rollback(reason) {
+                        throw new transactionRollback_error.TransactionRollbackError(reason);
+                    },
+                };
+                // Execute callback
+                const result = await fn(ctx);
+                // Auto-commit on success
+                await session.commitTransaction();
+                return result;
+            }
+            catch (error) {
+                // Auto-rollback on any error (including explicit rollback)
+                await session.abortTransaction().catch(() => undefined);
+                throw error;
+            }
+            finally {
+                // Guaranteed context cleanup
+                databaseTransactionContext.databaseTransactionContext.exit();
+            }
+        }
+        finally {
+            // Guaranteed session cleanup
+            await session.endSession().catch(() => undefined);
+        }
+    }
+    /**
+     * Execute atomic operations (typically $inc/$set style updates) against documents.
+     *
+     * Uses `updateMany` so callers can atomically modify any set of documents.
+     */
+    async atomic(table, filter, operations, options) {
+        const collection = this.getDatabaseInstance().collection(table);
+        const mongoOptions = this.withSession(options);
+        const result = await collection.updateMany(filter, operations, mongoOptions);
+        return { modifiedCount: result.modifiedCount };
+    }
+    /**
+     * Lazily create (and cache) the Mongo sync adapter.
+     * The adapter uses this driver instance to ensure all operations
+     * participate in active transactions via the session context.
+     */
+    syncAdapter() {
+        if (!this.syncAdapterInstance) {
+            this.syncAdapterInstance = new mongodbSyncAdapter.MongoSyncAdapter(this);
+        }
+        return this.syncAdapterInstance;
+    }
+    /**
+     * Lazily create (and cache) the Mongo migration driver.
+     * The migration driver handles schema operations like indexes, collections, etc.
+     */
+    migrationDriver() {
+        if (!this.migrationDriverInstance) {
+            this.migrationDriverInstance = new mongodbMigrationDriver.MongoMigrationDriver(this);
+        }
+        return this.migrationDriverInstance;
+    }
+    /**
+     * Expose the underlying Mongo client for advanced consumers.
+     */
+    getClient() {
+        return this.getClientInstance();
+    }
+    /**
+     * Retrieve the active Mongo client, throwing if the driver is disconnected.
+     */
+    getClientInstance() {
+        if (!this.client) {
+            throw new Error("Mongo driver is not connected.");
+        }
+        return this.client;
+    }
+    /**
+     * Retrieve the active Mongo database, throwing if the driver is disconnected.
+     * @private
+     */
+    getDatabaseInstance() {
+        if (!this.database) {
+            throw new Error("Mongo driver is not connected to a database.");
+        }
+        return this.database;
+    }
+    /**
+     * Resolve the Mongo connection string based on provided options.
+     */
+    resolveUri() {
+        if (this.config.uri) {
+            return this.config.uri;
+        }
+        const host = this.config.host ?? "localhost";
+        const port = this.config.port ?? 27017;
+        return `mongodb://${host}:${port}`;
+    }
+    /**
+     * Build the Mongo client options derived from the driver configuration.
+     */
+    buildClientOptions() {
+        const baseOptions = {
+            ...(this.config.clientOptions ?? {}),
+        };
+        if (this.config.logging) {
+            baseOptions.monitorCommands = true;
+        }
+        if (this.config.username && !baseOptions.auth) {
+            baseOptions.auth = {
+                username: this.config.username,
+                password: this.config.password,
+            };
+        }
+        if (this.config.authSource && !baseOptions.authSource) {
+            baseOptions.authSource = this.config.authSource;
+        }
+        return baseOptions;
+    }
+    /**
+     * Emit a driver lifecycle event.
+     */
+    emit(event, ...args) {
+        this.events.emit(event, ...args);
+    }
+    /**
+     * Ensure MongoDB is running as a replica set (required for transactions).
+     *
+     * @throws {Error} If MongoDB is running as a standalone instance
+     */
+    async ensureReplicaSetAvailable() {
+        try {
+            const admin = this.database.admin();
+            const status = await admin.serverStatus();
+            if (!status.repl) {
+                throw new Error("MongoDB transactions require a replica set or sharded cluster. " +
+                    "Standalone MongoDB instances do not support transactions.\n\n" +
+                    "For local development:\n" +
+                    "  - Run MongoDB with --replSet flag: mongod --replSet rs0\n" +
+                    "  - Or use Docker with replica set configuration\n" +
+                    "  - Or use MongoDB Atlas (cloud) which provides replica sets by default");
+            }
+        }
+        catch (error) {
+            if (error.message?.includes("replica set")) {
+                throw error;
+            }
+            throw new Error(`Failed to check MongoDB replica set status: ${error.message}`);
+        }
+    }
+    /**
+     * Attach the active transaction session (when available) to Mongo options.
+     */
+    withSession(options) {
+        const session = databaseTransactionContext.databaseTransactionContext.getSession();
+        if (!session) {
+            return options;
+        }
+        const baseOptions = options ? { ...options } : {};
+        baseOptions.session = session;
+        return baseOptions;
+    }
+    // ============================================================
+    // SQL Compatibility Operations (Not supported in MongoDB)
+    // ============================================================
+    /**
+     * Return a SQL serializer for this driver's dialect.
+     * Not supported for MongoDB.
+     */
+    getSQLSerializer() {
+        throw new Error("MongoDB driver does not support SQL serialization.");
+    }
+    /**
+     * Execute a raw SQL query.
+     * Not supported for MongoDB.
+     */
+    async query(_sql, _params) {
+        throw new Error("MongoDB driver does not support raw SQL queries.");
+    }
+    // ============================================================
+    // Database Lifecycle Operations
+    // ============================================================
+    /**
+     * Create a new database.
+     *
+     * In MongoDB, databases are created automatically when data is first written.
+     * This method creates an empty collection to ensure the database exists.
+     *
+     * @param name - Database name to create
+     * @returns true if created, false if already exists
+     */
+    async createDatabase(name) {
+        const client = this.getClientInstance();
+        // Check if database already exists
+        if (await this.databaseExists(name)) {
+            return false;
+        }
+        try {
+            // MongoDB creates databases on first write, so create a system collection
+            const db = client.db(name);
+            await db.createCollection("__init__");
+            // Drop the temp collection
+            await db.collection("__init__").drop();
+            logger.log.success("database", "lifecycle", `Created database ${name}`);
+            return true;
+        }
+        catch (error) {
+            logger.log.error("database", "lifecycle", `Failed to create database ${name}: ${error}`);
+            throw error;
+        }
+    }
+    /**
+     * Drop a database.
+     *
+     * @param name - Database name to drop
+     * @returns true if dropped, false if didn't exist
+     */
+    async dropDatabase(name) {
+        const client = this.getClientInstance();
+        // Check if database exists
+        if (!(await this.databaseExists(name))) {
+            return false;
+        }
+        try {
+            await client.db(name).dropDatabase();
+            logger.log.success("database", "lifecycle", `Dropped database ${name}`);
+            return true;
+        }
+        catch (error) {
+            logger.log.error("database", "lifecycle", `Failed to drop database ${name}: ${error}`);
+            throw error;
+        }
+    }
+    /**
+     * Check if a database exists.
+     *
+     * @param name - Database name to check
+     * @returns true if database exists
+     */
+    async databaseExists(name) {
+        const client = this.getClientInstance();
+        const result = await client.db("admin").admin().listDatabases();
+        return result.databases.some((db) => db.name === name);
+    }
+    /**
+     * List all databases.
+     *
+     * @returns Array of database names
+     */
+    async listDatabases() {
+        const client = this.getClientInstance();
+        const result = await client.db("admin").admin().listDatabases();
+        return result.databases
+            .map((db) => db.name)
+            .filter((name) => !["admin", "local", "config"].includes(name));
+    }
+    // ============================================================
+    // Table/Collection Management Operations
+    // ============================================================
+    /**
+     * Drop a collection.
+     *
+     * @param name - Collection name to drop
+     * @throws Error if collection doesn't exist
+     */
+    async dropTable(name) {
+        const db = this.getDatabaseInstance();
+        await db.collection(name).drop();
+        logger.log.success("database", "collection", `Dropped collection ${name}`);
+    }
+    /**
+     * Drop a collection if it exists.
+     *
+     * @param name - Collection name to drop
+     */
+    async dropTableIfExists(name) {
+        if (await this.blueprint.tableExists(name)) {
+            await this.dropTable(name);
+        }
+    }
+    /**
+     * Drop all collections in the current database.
+     *
+     * Useful for `migrate:fresh` command.
+     */
+    async dropAllTables() {
+        const collections = await this.blueprint.listTables();
+        if (collections.length === 0) {
+            return;
+        }
+        const db = this.getDatabaseInstance();
+        for (const collection of collections) {
+            await db.collection(collection).drop();
+        }
+        logger.log.success("database", "collection", `Dropped ${collections.length} collections`);
+    }
+}exports.MongoDbDriver=MongoDbDriver;exports.isMongoDBDriverLoaded=isMongoDBDriverLoaded;//# sourceMappingURL=mongodb-driver.js.map