Prerequisites and Setup

Begin by installing the necessary dependencies via npm. While native drivers are available, the ODM Mongoose simplifies schema definition and query execution significantly.

Connection Configuration

Establish a connection module to manage the database session globally. Ensure the connection pool is initialized correctly for high-performance applications.

const mongoose = require('mongoose');
const DB_URI = 'mongodb://localhost:27017/sample_app';

// Establish connection with standard options
mongoose.connect(DB_URI)
  .then(() => console.log('Database connection established'))
  .catch((err) => console.error('Connection error:', err));

// Handle state changes
mongoose.connection.on('disconnected', () => {
  console.warn('Disconnected from database');
});

module.exports = mongoose;

Expose the mongoose instance as a shared resource to allow access across different application modules without recreating connections.

Schema Design

Define data structures using Schemas to enforce document consistency. In this example, we create a model representing user profiles.

const db = require('./connection');
const Schema = db.Schema;

// Define profile structure
const UserSchema = new Schema({
  username: String,
  password: String,
  age: Number,
  lessonsCompleted: Number,
  gender: Number,
  location: String,
  employer: String
});

// Compile the model from the schema
module.exports = db.model('UserProfile', UserSchema);

This approach ensures that any instance created conforms to the defined field types automatically.

Persistence Operations

Retrieve, create, modify, and remove documents directly using the Model class methods.

Retrieval Queries

Select specific fields to optimize network traffic. The second parameter filters out unwanted fields like _id.

const UserProfile = require('./models/UserProfile');

UserProfile.find({}, { _id: 0, username: 1, age: 1 })
  .then(data => console.log('Retrieved Records:', data))
  .catch(err => console.error(err));

Document Creation

Bulk insertion supports adding multiple records efficiently. Use insertMany for batch operations rather than individual calls.

UserProfile.insertMany([
  { username: 'alice', password: 'pass123', age: 24, location: 'Beijing' },
  { username: 'bob', password: 'pass456', age: 28, location: 'Shanghai' }
])
.then(() => console.log('Bulk insert complete'))
.catch(err => console.error(err));

Deletion Logic

Supports both single and multi-document removal based on filtering criteria. Regular expressions can be used for partial matches.

// Remove documents matching the name pattern
UserProfile.deleteMany({ username: /alice/ })
.then(() => console.log('Removal successful'))
.catch(err => console.error(err));

Updates

Modify attributes selectively. Operators like $inc or $set allow precise updates without rewriting the entire document.

UserProfile.updateOne(
  { username: 'charlie' }, 
  { $inc: { age: 1 } }
).then(() => console.log('Age incremented'));

Abstraction Layer Implementation

To reduce code repetition, wrap database methods in a utility object. This promotes DRY (Don't Repeat Yourself) principles and allows consistent error handling across the project.

Generic Insert Method

Encapsulate insertion logic within a Promise wrapper to support async/await patterns elsewhere in the codebase.

// utils/sql_helper.js
function insert(collection, data) {
  return new Promise((resolve, reject) => {
    collection.insertMany(data, (err) => {
      if (err) return reject(err);
      resolve();
    });
  });
}

Usage Example:

const helper = require('./utils/sql_helper');
const User = require('./models/UserProfile');

helper.insert(User, { username: 'dave', age: 30 })
  .then(() => console.log('Data persisted'))
  .catch(e => console.log(e));

Flexible Delete and Update Handlers

Combine operation types into single functions using string keys for method lookup. This enables passing operation names dynamically.

function deleteRecord(collection, filter, type = 'deleteOne') {
  const method = collection[type];
  return new Promise((resolve, reject) => {
    method.call(collection, filter, (err) => {
      if (err) return reject(err);
      resolve();
    });
  });
}

function updateDocument(collection, whereClause, changeData, type = 'updateOne') {
  return new Promise((resolve, reject) => {
    collection[type](whereClause, changeData, (err) => {
      if (err) return reject(err);
      resolve();
    });
  });
}

Execution Flow:

const util = require('./utils/sql_helper');
const User = require('./models/UserProfile');

util.deleteRecord(User, { username: /^dave/ }, 'deleteMany')
  .then(() => console.log('Operation finished'));

Query wrappers follow the same pattern, resolving the array of found documents.

function queryCollection(collection, filter, projection) {
  return new Promise((resolve, reject) => {
    collection.find(filter, projection).exec((err, data) => {
      if (err) return reject(err);
      resolve(data);
    });
  });
}