@warlock.js/cascade 4.0.156 → 4.0.158

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

@@ -1,799 +0,0 @@
-'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");
-                }
-            });
-            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.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