Node.js Database Interaction with MongoDB

Before initiating data persistence operations, it is crucial to ensure that the official driver has been correctly installed within your project environment. For modern versions of Node.js (14.0+), we recommend using the mongodb package as a core dependency. Open your terminal or command-line tool and execute the following command to add the dependency:

npm install mongodb

Upon completion, importing the driver module into your project's entry file or configuration file and establishing a connection object is the critical first step. Since MongoDB supports various connection pool strategies, we typically utilize the MongoClient class to manage global database sessions. You must explicitly specify server addresses, port numbers, and authentication information (such as username and password). Below is a standard initialization code snippet:

const { MongoClient } = require('mongodb');

async function connectToDatabase() {
    const uri = 'mongodb://localhost:27017'; // Replace with your actual connection string
    const clientOptions = {}; 
    
    if (process.env.MONGODB_URI) {
        clientOptions.authSource = process.env.AUTH_SOURCE;
    }
    
    try {
        const client = new MongoClient(uri, clientOptions);
        
        await client.connect();
        console.log('Database connection successful');
        
        // Retrieve database and collection objects
        const db = client.db('my_database');
        const collection = db.collection('users');
        
        return { client, db, collection };
    } catch (error) {
        console.error('Connection failed:', error);
        throw error;
    } finally {
        // Ensure resources are properly released to prevent memory leaks
        await client.close();
    }
}

// Invoke the initialization function
connectToDatabase().catch(console.dir);

In this configuration, we specifically emphasize the role of the finally block. Regardless of whether the connection succeeds or an exception occurs, the code will execute the close operation; this is vital for resource management in production environments. Furthermore, storing sensitive connection strings as environment variables represents a best practice that effectively prevents keys from leaking into version control repositories.
Having mastered basic connectivity, you next need to familiarize yourself with MongoDB's most fundamental Create, Read, Update, Delete (CRUD) operational workflows. MongoDB provides rich methods for handling document data; these methods typically accept a callback function as an argument to execute asynchronous operations. Here are specific code examples:

1. Inserting Data

When writing new documents into a collection, you can use the insertOne method or the batch operation method insertMany. It is recommended to use newer driver versions that support transactions for better atomicity guarantees. Below is an example of inserting a single record:

const newDoc = { name: 'Alice', age: 25, email: 'alice@example.com' };

async function insertUser(collection) {
    const result = await collection.insertOne(newDoc);
    
    // Return the generated object ID for subsequent reference
    return result.insertedId; 
}

For scenarios requiring the insertion of multiple data items at once, the insertMany method is more efficient. It accepts an array of documents and returns a response object containing both insert results and error information:

const users = [newDoc, { name: 'Bob', age: 30 }];
await collection.insertMany(users);

2. Querying Data (Find)

Retrieving data is the most frequent operation in database interaction. The find() method returns a cursor; you must retrieve actual result sets by calling toArray(), using limit(), or iterating through loops via this cursor. To optimize performance, ensure indexes are created on collections, especially when query conditions include specific fields:

async function findUsersByAge(collection, minAge) {
    const cursor = collection.find({ age: { $gte: minAge } });
    
    // Convert the cursor to an array for direct result processing
    return await cursor.toArray(); 
}

// Alternatively, use aggregation pipelines for complex queries
const pipeline = [
    { $match: { status: 'active' } },
    { $sort: { createdAt: -1 } },
    { $limit: 50 } // Limit the number of returned items to improve performance
];

3. Updating and Modifying Data (Update)

MongoDB's document structure allows for nested fields and array elements. When performing data updates, you must use operators starting with $ to specify specific modification logic; avoiding direct overwriting of entire documents prevents accidental loss of other information. Common operations include set, inc (increment), push, etc.:

async function updateUserStatus(collection, userId) {
    const updateDoc = { 
        $set: { status: 'verified' }, // Set field value
        $inc: { lastLoginCount: 1 }   // Increment numeric fields
    };

    await collection.updateOne(
        { _id: ObjectId(userId) }, // Query condition
        updateDoc                  // Document to update
    );
}

Note that in update operations, if you are unsure whether any documents will be matched, it is advisable to use the $setOnInsert operator.

4. Deleting Data (Delete)

Deletion operations are typically used for cleaning up expired records or removing specific resources. Similar to updates, precise query conditions must be specified to ensure only target data is affected:

async function deleteUser(collection, userId) {
    const result = await collection.deleteOne({ _id: ObjectId(userId) });

    // Return the number of documents deleted
    return result.deletedCount; 
}

For bulk deletion, you can use the deleteMany method. Before executing large-scale data cleanup, it is recommended to perform backups or validation in a test environment to prevent accidental loss of critical business data.

Transaction Processing and Advanced Feature Application

As business logic complexity increases, single-document operations often struggle to guarantee strong consistency for data. MongoDB 4.0+ introduced multi-document transaction functionality; this is particularly important for scenarios involving cross-collection operations. For example, when a user places an order, both the inventory table and the user orders table must be updated simultaneously; any failure in one step should roll back all changes:

async function processOrder(userId, productId) {
    const session = await client.startSession();
    
    try {
        with(session) { // Use transaction block to ensure atomicity
        
            // Start the transaction context
            await collectionA.updateOne({ userId }, {$inc: { stock: -1 }});
            
            if (await collectionB.countDocuments()) {
                await collectionB.insertOne({ orderId, productId });
            } else {
                throw new Error('Order processing failed');
            }
        }
        
    } catch (error) {
        // Automatic rollback; no need to manually execute rollback()
        session.endSession(); 
        throw error;
    } finally {
        await session.endSession();
    }
}

Beyond transactions, MongoDB offers a rich query optimizer and aggregation framework. Utilizing stages like $lookup and $group can efficiently handle related data processing and analytical statistics requirements without requiring complex SQL JOIN logic to be written in the application layer. Additionally, index management is a key factor in improving read/write performance; regularly creating composite indexes for high-frequency query fields can significantly reduce I/O overhead.

Through the steps outlined above, developers can build flexible yet efficient Node.js backend storage solutions. Mastering these core concepts and operational patterns will lay a solid foundation for subsequent development of microservice architectures.