MongoDB.js

// connect() is idempotent on a connected client
const { MongoClient, ObjectId } = require('mongodb');

let _lastClient = null;

function createDBConnection(connectionString, options = {}) {
    if (!connectionString) throw new Error('connectionString is required');
    const client = new MongoClient(connectionString, options);
    _lastClient = client;
    return client;
}

async function connectToDatabase(client, dbName) {
    if (!client) throw new Error('client is required');
    if (!dbName) throw new Error('dbName is required');
    if (typeof client.connect === 'function') {
        try {
            await client.connect();
        } catch (err) {
            throw new Error(`Failed to connect client: ${err.message}`);
        }
    }
    _lastClient = client;
    return client.db(dbName);
}

async function insertData(client, dbName, collectionName, dataObject) {
    if (!dataObject || typeof dataObject !== 'object') throw new Error('dataObject must be an object');
    if (!collectionName) throw new Error('collectionName is required');
    const db = await connectToDatabase(client, dbName);
    const col = db.collection(collectionName);
    const doc = Object.assign({}, dataObject, { createdAt: new Date() });
    const res = await col.insertOne(doc);
    return res;
}

async function getAllDataByCollection(client, dbName, collectionName) {
    if (!collectionName) throw new Error('collectionName is required');
    const db = await connectToDatabase(client, dbName);
    const col = db.collection(collectionName);
    const docs = await col.find({}).toArray();
    return docs;
}

async function getDataById(client, dbName, collectionName, documentId) {
    if (!documentId) throw new Error('documentId is required');
    if (!collectionName) throw new Error('collectionName is required');
    const db = await connectToDatabase(client, dbName);
    const col = db.collection(collectionName);
    let queryId = documentId;
    try {
        queryId = new ObjectId(documentId);
    } catch (e) {
        // keep original value if it's not a valid ObjectId string
    }
    const doc = await col.findOne({ _id: queryId });
    return doc;
}

async function deleteDataById(client, dbName, collectionName, query) {
    if (!query) throw new Error('documentId is required');
    if (!collectionName) throw new Error('collectionName is required');
    const db = await connectToDatabase(client, dbName);
    const col = db.collection(collectionName);
    const res = await col.deleteOne(query);
    return res;
}

async function deleteManyByQuery(client, dbName, collectionName, query) {
    if (!query || typeof query !== 'object') throw new Error('query must be an object');
    if (!collectionName) throw new Error('collectionName is required');
    const db = await connectToDatabase(client, dbName);
    const col = db.collection(collectionName);
    const res = await col.deleteMany(query);
    return res;
}

async function insertManyDocuments(client, dbName, collectionName, documents) {
    if (!Array.isArray(documents) || documents.length === 0) throw new Error('documents must be a non-empty array');
    if (!collectionName) throw new Error('collectionName is required');
    const db = await connectToDatabase(client, dbName);
    const col = db.collection(collectionName);
    const docs = documents.map(d => Object.assign({}, d, { createdAt: new Date() }));
    const res = await col.insertMany(docs);
    return res;
}

async function closeConnection() {
    if (_lastClient && typeof _lastClient.close === 'function') {
        await _lastClient.close();
        _lastClient = null;
        return true;
    }
    return false;
}

module.exports = {
    createDBConnection,
    connectToDatabase,
    insertData,
    getAllDataByCollection,
    getDataById,
    deleteDataById,
    deleteManyByQuery,
    insertManyDocuments,
    closeConnection,
};