Mongoose.model() Function

The mongoose.model() function is a core method in the Mongoose library, used for interacting with MongoDB in a Node.js environment. It helps in creating a MongoDB collection associated with a schema, defining the structure of documents that will be stored within it. This article will explain mongoose.model() function, its syntax, parameters, and provide practical examples to help us understand how to use it effectively in our applications.

What is the mongoose.model() Function?

The mongoose.model() function is used to create models in Mongoose, which act as the interface to MongoDB collections. A model is a constructor function that allows us to create, query, update, and delete documents within a specific MongoDB collection.

When creating a model, Mongoose automatically uses the singular, capitalized form of the model name, pluralizes it, and associates it with a MongoDB collection. For instance, creating a model called User will result in the collection being named users in MongoDB.

Why Use Mongoose Models?

• Data Integrity: Models are based on schemas, ensuring that data stored in the database adheres to a defined structure.
• Ease of Use: Mongoose provides built-in methods for handling CRUD (Create, Read, Update, Delete) operations and validating data before saving it.
• Powerful Querying: Models allow you to execute advanced queries with Mongoose's rich query API.

Syntax:

mongoose.model(<ModelName>, <Schema>)

Parameters:

• Model Name: This is the name of the model. The name is used by Mongoose to create the corresponding MongoDB collection. Mongoose automatically pluralizes and converts the name to lowercase (e.g., User will correspond to the users collection).
  
• Schema: The schema defines the structure of the documents that the model will represent. It is created using the mongoose.Schema() function, where you specify the fields and their types.

Return type:

• The mongoose.model() function returns a model object, which is used to interact with the MongoDB collection.

How to Create a Model with mongoose.model()?

Creating a model involves two steps:

1. Define the Schema: First, we need to create a schema that outlines the structure of the documents in your collection.
2. Create the Model: Then, use the mongoose.model() function to create a model from the schema.

Example: Creating a Model in Mongoose

// Importing mongoose module
const mongoose = require("mongoose")

// Database Address
const url = "mongodb://localhost:27017/GFG"

// Connecting to database
mongoose.connect(url).then((ans) => {
  console.log("ConnectedSuccessful")
}).catch((err) => {
  console.log("Error in the Connection")
})

// Calling Schema class
const Schema = mongoose.Schema;

// Creating Structure of the collection
const collection_structure = new Schema({
  name: {
    type: String,
    require: true
  }
  ,
  marks: {
    type: Number,
    default: 0
  }
})

// Creating collection
const collections = mongoose.model("GFG", collection_structure)

// Inserting one document
collections.create({
  name: "aayush",
  marks: 10
}).then((ans) => {
  console.log("Document inserted")
}).catch((err) => {
  console.log(err.Message);
})

Steps to Run the Application:

1. Installing Module: Install the mongoose module using the following command:

npm install mongoose

Project Structure: Our project structure will look like this:

2. Running the server on Local IP: Data is the directory where MongoDB server is present.

mongod --dbpath=data --bind_ip 127.0.0.1

3. Run index.js file using below command:

node index.js

Output:

MongoDB Database: Our database after executing the above command will look like this:

Running the Server and Output

When you run the application, the following happens:

1. Connection to MongoDB: The mongoose.connect() method connects your Node.js application to the MongoDB database. If successful, you'll see the message "Connected to MongoDB successfully."
2. Schema and Model Creation: The schema defines the structure of the documents (fields like name and marks), and the model is created using mongoose.model().
3. Document Insertion: A new document with the values {name: "Aayush", marks: 10} is inserted into the gfgs collection. If successful, the message "Document inserted successfully." will appear.

MongoDB Database Output

After executing the code, the MongoDB database (GFG) will contain a collection named gfgs with a document similar to the following:

{
  "_id": ObjectId("1234567890abcdef12345678"),
  "name": "Aayush",
  "marks": 10
}

Conclusion

The mongoose.model() function is crucial for interacting with MongoDB in Node.js applications. It creates a model based on a schema, allowing us to manage documents efficiently while ensuring data integrity. With its simple syntax and powerful features, mongoose.model() is an essential tool in any MongoDB-powered Node.js project. By following the examples and tips provided in this article, we can efficiently use the mongoose.model() function to create models and manage your MongoDB collections in Node.js.

zack_aayush

Follow

Improve

Article Tags :

• Technical Scripter
• Web Technologies
• MongoDB
• Databases
• Technical Scripter 2020
• Mongoose

+2 More