Mongoose Documents vs Models

Mongoose is a widely used Node library commonly used for working with MongoDB, a NoSQL database. Mongoose streamlines the process of working with MongoDB through an object data modeling (ODM) framework. Two of the primary concepts in the Mongoose environment are Documents and Models. In this article, we will discuss the differences between Mongoose Documents and Models, and how they help in developing strong and scalable MongoDB-based applications.

Mongoose Models

A Mongoose Model is a constructor function that establishes the schema of documents in a MongoDB collection. Models are derived from a Schema, which sets the fields and the kind of data contained. The model exposes an interface to accomplish CRUD (Create, Read, Update, Delete) operations on the documents in your collection.

Key Characteristics of Mongoose Models:

Constructor Function: A model acts as a constructor for creating new documents.
Static Methods: Models can have static methods for querying and manipulating documents at the collection level (e.g., find(), update(), delete()).
Schema Definition: The schema defines the structure of the documents, specifying fields, types, and validation.

Syntax:

const mongoose = require('mongoose');
const Schema = mongoose.Schema;
const userSchema = new Schema({
username: String,
email: String,
age: Number
});
const User = mongoose.model('User', userSchema);

Parameters:

Require Mongoose: Import the Mongoose library.
Define Schema: Create a Mongoose schema by specifying the fields and their data types. You can also include additional options like required for validation and default for default values.
Create Model: Use the mongoose.model method to create a model based on the defined schema. The first argument is the singular name of the collection your model is for, and the second argument is the schema.
Export Model: Export the model so that it can be used in other parts of your application.

Example: Here's an example of how you might use this model in another file:

const YourModel = require("./path/to/your/model");

// Create a new instance of the model
const instance = new YourModel({
    fieldName1: "some value",
    fieldName2: 42,
});

// Save the instance to the database
instance.save((error, savedInstance) => {
    if (error) {
        console.error(error);
    } else {
        console.log("Instance saved:", savedInstance);
    }
});

Explanation: This is a basic example, and you can customize it based on your specific requirements. The Mongoose documentation (https://mongoosejs.com/docs/) is a valuable resource for more advanced features and options.

Mongoose Documents

A Document in Mongoose is an instance of a Model. They represent individual records within a collection and adhere to the structure defined by the associated Schema. Documents can be created and manipulated using the corresponding Model. Here's an example of creating a new user Document using the User model

Key Characteristics of Mongoose Documents:

Instance of a Model: A document is an instance created using a model.
Instance Methods: Documents can have instance methods like save(), remove(), and update(), which allow you to interact with a specific document.
Validation: Documents are validated against the schema before they are saved to the database.

Syntax:

const newUser = new User({
username: 'john_doe',
email: 'john@example.com',
age: 25
});
newUser.save()
.then(savedUser => {
console.log('User saved:', savedUser);
})
.catch(error => {
console.error('Error saving user:', error);
});

Example: In this snippet, a new user Document is created using the User model and saved to the MongoDB database using the save method.

const mongoose = require('mongoose');

// Define a schemaconst mongoose = require("mongoose");

// Define a schema
const yourSchema = new mongoose.Schema({
    name: String,
    age: Number,
    email: String,
});

// Create a Mongoose model using the schema
const YourModel = mongoose.model("YourModel", yourSchema);

// Create a new document instance
const document = new YourModel({
    name: "John Doe",
    age: 30,
    email: "john@example.com",
});

// Save the document to the database
document.save((error, savedDocument) => {
    if (error) {
        console.error(error);
    } else {
        console.log("Document saved:", savedDocument);
    }
});

const yourSchema = new mongoose.Schema({
  name: String,
  age: Number,
  email: String,
});

// Create a Mongoose model using the schema
const YourModel = mongoose.model('YourModel', yourSchema);

// Create a new document instance
const document = new YourModel({
  name: 'John Doe',
  age: 30,
  email: 'john@example.com',
});

// Save the document to the database
document.save((error, savedDocument) => {
  if (error) {
    console.error(error);
  } else {
    console.log('Document saved:', savedDocument);
  }
});

Differences between Mongoose Documents and Models

Aspect	Mongoose Model	Mongoose Document
Definition	A Model in Mongoose is a constructor function for creating documents and interacting with a MongoDB collection. It represents a MongoDB collection and is used to define the schema.	A Document in Mongoose is an instance of a model, representing a single record in the MongoDB collection.
Purpose	Models provide the interface for interacting with the collection (e.g., querying, creating, updating, deleting).	Documents represent individual records in the MongoDB collection that adhere to the schema.
Type	A Model is a constructor function that is used to create documents.	A Document is an instance created using a Model.
Methods	Models have static methods like `find()`, `create()`, `update()`, `remove()`.	Documents have instance methods like `save()`, `updateOne()`, `remove()`.
Schema Binding	A Model is tied to a Schema that defines the structure of the documents in the MongoDB collection.	A Document is an instance of a Model, meaning it follows the schema defined by the associated Model.
Operations	Models perform operations at the collection level (e.g., fetching, creating, and updating multiple documents).	Documents perform operations at the instance level (e.g., saving or updating a specific record).
Persistence	Models do not directly persist data to MongoDB but serve as a blueprint for creating and manipulating documents.	Documents are persisted in MongoDB as individual records in the collection.
Use Case	Models are used for querying the database, creating new records, and performing bulk operations.	Documents are used to represent and manipulate individual records from the database.
Creation	A Model is created by using `mongoose.model('ModelName', schema)` and is not an instance of a document.	A Document is created by using a Model's constructor, e.g., `new Model()` to instantiate a document.
Example	`const User = mongoose.model('User', userSchema);`	`const newUser = new User({ name: 'John', age: 30 });`
Field Access	A Model defines the structure and field types of the collection but does not hold data.	A Document holds data corresponding to the fields defined by its Model.
Static Methods	Models have static methods to query, update, or delete records.	Documents only have instance methods for operations like `save()` or `remove()`.
Validation	Models can be used for validation before saving or updating data.	Documents are validated when performing actions like `save()`, ensuring data adheres to the schema.
Example Method Usage	`User.findOne({ name: 'John' })`	`newUser.save()`

Conclusion

Mongoose Models and Documents are both essential pieces for utilizing MongoDB. Models exist to specify the shape of your data, and Documents are single records that conform to that structure. When you know the differences and how to employ both effectively, you can apply the full potential of Mongoose to create scalable and effective applications with MongoDB. Whether you’re creating, reading, updating, or deleting data, Mongoose provides an intuitive and powerful interface to interact with MongoDB collections, ensuring that your application’s data management is streamlined and reliable.