Mongoose and Express discussion

mongoose.md

1. What are the differences and connections between Mongoose schemas and models? How do they work together in an Express.js application?
2. How does Mongoose handle data validation? Discuss the benefits of using Mongoose for data validation as opposed to doing it manually in your Express.js routes.
3. What are virtuals in Mongoose? Discuss how and why you might use them in a project. Give examples of scenarios where virtuals can be particularly useful.
4. What is population in Mongoose? How does it differ from simply storing object IDs in your documents? Discuss scenarios where population is beneficial and when it might be better to avoid it.
5. How does Mongoose handle asynchronous operations? Discuss the role of promises and async/await in managing database interactions in an Express.js application.

Room 5
Teams : Hammam Abu Shehadeh / Ahmed Ahmed / Sara Jouma / Mahmoud Rumaneh

---

1. Schema: A Mongoose ‘schema’ is a document data structure (or shape of the document) that is enforced via the application layer.

Models: are higher-order constructors that take a schema and create an instance of a document equivalent to records in a relational database.

Mongoose Schema vs. Model
A Mongoose model is a wrapper on the Mongoose schema. A Mongoose schema defines the structure of the document, default values, validators, etc., whereas a Mongoose model provides an interface to the database for creating, querying, updating, deleting records, etc.
Connection:

Relation: Schemas and models are closely connected. The model is created by compiling a schema, and the schema is used as a blueprint for the model.
Usage: The model is the entity that you use to perform operations on the database, while the schema defines the structure of the documents that will be stored.
By combining Mongoose schemas and models in your Express.js application, you can easily define the structure of your MongoDB documents and interact with the database through the provided models in your routes or controllers. This separation of concerns helps maintain a clean and organized codebase.

---

2)Mongoose Validation is essentially a customizable middleware that gets defined inside the SchemaType of Mongoose schema. It automatically fires off before a document is saved in the NoSQL DB.
Using express validator can provide more flexibility and independence in terms of choosing different databases in the future. In case you wanted to shift from Mongo DB to any other database. It allows you to perform data validation and sanitization directly within your Express.js routes and handlers, without being tied to a specific database or ORM like Mongoose.

---

3. Virtual properties are fields that you can add to your Mongoose schemas but are not stored in the MongoDB database.
   Computed Properties: Virtuals are useful for creating properties that are derived from other fields in your document. For example, a fullName property can be computed from separate firstName and lastName fields.

personSchema.virtual('fullName').get(function () {
    return this.firstName + ' ' + this.lastName;
});

Formatting and Transformation: Virtuals can be employed to format or transform data before presenting it. For instance, you might want to format a date in a specific way or convert units

 personSchema.virtual('formattedBirthdate').get(function () {
    return moment(this.birthdate).format('MMMM Do, YYYY');
});

Hide or Transform Sensitive Data: You can use virtuals to hide or transform sensitive information before sending it as a response. This is particularly useful when you need to expose certain fields but with modifications.

personSchema.virtual('publicProfile').get(function () {
    return {
        fullName: this.fullName,
        email: this.email
        // ... other public information
    };
});

Aggregation: Virtuals can be employed in aggregation pipelines, allowing you to perform calculations or transformations during the aggregation process.

personSchema.virtual('age').get(function () {
    return moment().diff(this.birthdate, 'years');
});

Person.aggregate([
    {
        $project: {
            fullName: 1,
            age: '$age'
        }
    }
]);

---

4)Population is the process of automatically replacing the specified paths in the document with the document(s) from other collection(s). We may populate a single document, multiple documents, a plain object, multiple plain objects, or all objects returned from a query.

const mongoose = require('mongoose');
const { Schema } = mongoose;

const personSchema = Schema({
  _id: Schema.Types.ObjectId,
  name: String,
  age: Number,
  stories: [{ type: Schema.Types.ObjectId, ref: 'Story' }]
});

const storySchema = Schema({
  author: { type: Schema.Types.ObjectId, ref: 'Person' },
  title: String,
  fans: [{ type: Schema.Types.ObjectId, ref: 'Person' }]
});

const Story = mongoose.model('Story', storySchema);
const Person = mongoose.model('Person', personSchema);

Scenarios where Population is Beneficial:
Reduced Redundancy: Instead of duplicating author information in each book document, you can maintain a separate Author collection and reference it in the Book collection. This reduces redundancy and ensures consistency.

Easy Updates: If an author's details change (e.g., name), you only need to update the Author collection, and the changes will automatically reflect in all referenced books.

Query Efficiency: When you use populate, Mongoose performs an additional query to fetch the referenced documents. This can be beneficial when you want to retrieve complete details of related documents without manually querying each one.

When to Avoid Population:
Small Embedded Data: If the related data is relatively small and doesn't change frequently, embedding it directly in the document might be more efficient than using population.

Read-Heavy Operations: If your application involves a lot of read-heavy operations where retrieving complete related data is not a frequent requirement, the population might add unnecessary overhead.

Performance Concerns: In scenarios with a large number of documents and frequent queries, using population might result in additional database queries, affecting performance. In such cases, denormalization or embedding data may be more suitable.

---

5)Mongoose utilizes Promises and async/await to handle asynchronous operations when interacting with databases. Promises provide a clean and consistent way to work with asynchronous code, and async/await simplifies the syntax, making the code more readable and maintainable.

**Lujain Mansour / Baraa Sidair / Abdullah Alawad **
1
Mongoose schemas and models play crucial roles in defining the structure of MongoDB documents and interacting with the database.

 A Mongoose schema defines the structure of a document within a MongoDB collection. It specifies the fields, their types, and any 

additional properties such as default values, validation rules, or indexing options.

A Mongoose model is a constructor function that provides an interface to interact with a specific MongoDB collection.

It is created by compiling a Mongoose schema into a model using the mongoose.model() method,
Models are used to perform CRUD (Create, Read, Update, Delete) operations on the MongoDB collection associated with a specific
schema

In an Express.js application, you typically define your Mongoose schemas and models in separate files or modules. These files are then imported and used within your routes or controllers to interact with the MongoDB database

2
Mongoose provides built-in data validation features that can be defined within the schema itself

 Declaring Validation Rules in Schema:

When you define a Mongoose schema, you can specify various validation rules for each field. For example, you can set required, min, max, enum, and custom validation functions

Automatic Validation on Save:
Mongoose automatically validates the data against the defined schema when you attempt to save a document using the save() method. If the data does not meet the specified validation criteria, Mongoose will throw a validation error.

Benefits of Using Mongoose for Data Validation:

• Code Organization:
  Defining validation rules within the schema keeps the validation logic organized and centralizes it with the data model. This makes the codebase cleaner and more maintainable.

• Consistency:
  Mongoose enforces validation consistently across different parts of your application. Whether you create or update documents via Mongoose models or directly in the database, the same validation rules apply.

• Custom Validation:
  Mongoose allows you to define custom validation functions, giving you the flexibility to implement complex validation logic tailored to your application's requirements.

• Easier Maintenance:
  If your data validation requirements change, you can update the Mongoose schema, and the changes will be reflected throughout your application. This is more straightforward than modifying validation logic scattered across multiple route handlers.

3
Virtuals in Mongoose are schema-defined fields that don't persist in the database. They're useful for computed properties or formatting data, enhancing code readability and maintenance. Examples include calculating full names or formatting dates.

Formatting and Transformation:
You can use virtuals to format or transform data before presenting it to the user. For instance, you might store dates in a specific format in the database but want to present them differently in your application.

Reducing Data Redundancy:
Virtuals can help reduce redundancy by providing calculated values without the need to store them in the database. This can be beneficial when certain data can be derived from other fields and doesn't need a dedicated storage space.

Example Scenarios:

User Authentication:
You might have a user schema with hashed passwords stored in the database. A virtual property can be used to check the validity of a user's provided password during authentication without storing the plaintext password.

Displaying Derived Information:
When working with geographic coordinates, you might have separate fields for latitude and longitude. A virtual property can be used to compute the distance between two points.

4
Population in Mongoose is the process of replacing specified paths in a document with documents from another collection. It differs
from storing object IDs directly by providing a seamless way to reference related data. It's beneficial for readability and data consistency
but may impact performance due to additional queries. Consider using population when these factors are crucial, but be cautious in high-
load scenarios where performance is a primary concern.

5

   Mongoose utilizes promises for asynchronous operations, enabling the use of either `.then()` 

or the concise async/await syntax in Express.js applications.
This streamlines database interactions, maintaining a readable and sequential code flow.

Jana AbuHaltam, Lubna Abdelkhaliq, Hala Qitouqa

Q1 Mongoose Schema vs. Model. A Mongoose model is a wrapper on the Mongoose schema. A Mongoose schema defines the structure of the document, default values, validators, etc., whereas a Mongoose model provides an interface to the database for creating, querying, updating, deleting records, etc. Schemas are then "compiled" into models using the mongoose.model() method.

Q2 Mongoose registers validation as a pre('save') hook on every schema by default. It allows you to specify both the acceptable range of values and the error message for validation failure in all cases.

Q3 In Mongoose, virtuals are schema properties that are not persisted to the database. Instead, they are calculated and returned on-the-fly when the document data is accessed. Virtuals allow you to define additional properties for your Mongoose documents that are derived from the document's existing properties.
examples:
1-Calculating Derived Properties
2-Formatting Dates
3-Combining Fields
4-Data Transformation
5-Authorization Logic

Q4 Population refers to a Mongoose feature that allows you to reference documents in other collections and pull in the referenced documents when querying. In Mongoose, "population" allows referencing and automatic retrieval of documents from other collections, while simply storing object IDs requires manual retrieval. "Population" is beneficial for managing complex relationships, simplified API responses, and streamlined data aggregation. It might be better to avoid "population" in scenarios of high query frequencies, memory usage concerns, and in cases where data consistency and integrity are crucial.

Q5 In Mongoose, asynchronous operations are managed through Promises, allowing for effective handling of database interactions. In an Express.js application, the use of async/await with Mongoose simplifies asynchronous code, improves error handling, and maintains a cleaner code structure when interacting with the database.

Najwan Shawareb, Rinad Abu Qauod, Hadeel Obaid.

1-In an Express.js application using Mongoose:
Schema: Defines the structure of data in a MongoDB collection.
Model: Represents a compiled version of a schema, providing an interface for interacting with MongoDB.
Working Together: Schemas define data structure, models offer methods to interact with MongoDB. In routes or controllers, you use models to perform database operations.

2-Mongoose Data Validation:
Definition: Mongoose allows validation rules to be defined within the schema for each field.
Automatic Validation: Mongoose automatically validates data against the schema during operations like create or save.
Benefits:
Centralization: Rules are defined in one place (the schema).
Consistency: Ensures uniform validation across routes using the same model.
Error Handling: Provides detailed error messages for effective debugging.
Avoiding Redundancy: Reduces manual validation in each route, making the code cleaner.
Using Mongoose for validation simplifies code maintenance, promotes consistency, and enhances error handling in Express.js applications.

3-Virtuals in Mongoose:
Definition: Fields not stored in MongoDB but computed on-the-fly.

Example:
javascript
Copy code
userSchema.virtual('fullName').get(function () {
return this.firstName + ' ' + this.lastName;
});
Use Cases:

Derived Data: Simplifies manipulation of data.
Presentation Formatting: Formats data for presentation.
Avoiding Redundancy: Computes values dynamically, reducing stored data.
Integration with External Data: Incorporates external data on-the-fly.
Security: Excludes sensitive information in responses.
Virtuals offer flexibility and efficiency in handling computed or formatted data in Mongoose schemas.

4-In Mongoose, population refers to the mechanism of automatically replacing specified paths in a document with documents from other collections. It allows you to reference documents from another collection in a more readable and convenient way.
Differences from Storing Object IDs:
-Readability:
Population improves the readability of your code.
-Data Integrity:
Population helps maintain data integrity by ensuring that the referenced documents exist. It allows for easier validation and handling of non-existent or deleted references.
-Mongoose population provides a more convenient and readable way to work with related documents in different collections, reducing redundancy and improving code maintainability compared to simply storing Object IDs.

*Scenarios where Mongoose Population is Beneficial:
Reducing Data Redundancy, Updating Related Documents, When a document references multiple collections.
*Scenarios to Avoid Mongoose Population:
Small Embedded Documents, High Query Volume, Network Latency Concerns, Security Concerns, Document Size Limitations, Read-Heavy Operations.

5- Mongoose, being a MongoDB ODM (Object-Document Mapper) for Node.js, relies on asynchronous operations to interact with the database. It utilizes promises, and supports async/await for handling these asynchronous tasks in a more readable and concise manner
Promises in Mongoose:

Mongoose methods generally return promises. This allows you to use the .then() and .catch() syntax for handling asynchronous operations.
-Async/Await in Mongoose:

With the introduction of async/await in JavaScript, Mongoose allows developers to write asynchronous code that looks more like synchronous code.

mohmmad smadi , Ammar Kolko , Farah Arar m hakeema alzaidanin:

Q1 : Mongoose schemas define the structure of your data, and models provide an interface to interact with the MongoDB database based on that schema. In an Express.js application, you connect to the database, define your models, and then use those models in route handlers or controllers to perform database operations.

Q2: 1- Validation is defined in the SchemaType
Validation is middleware. Mongoose registers validation as a pre('save') hook on every schema by default.
Validation always runs as the first pre('save') hook. This means that validation doesn't run on any changes you make in pre('save') hooks.
You can disable automatic validation before save by setting the validateBeforeSave option
You can manually run validation using doc.validate() or doc.validateSync()
You can manually mark a field as invalid (causing validation to fail) by using doc.invalidate(...)
Validators are not run on undefined values. The only exception is the required validator.
When you call Model#save, Mongoose also runs subdocument validation. If an error occurs, your Model#save promise rejects
Validation is customizable.

2- Mongoose offers several benefits over manual validation in Express.js routes:

Schema Definition:
Mongoose allows you to define a schema for your data models, specifying the structure, data types, and validation rules. This schema acts as a blueprint for your documents in MongoDB. This helps in maintaining a consistent structure and ensures that the data adheres to the specified format.

Built-in Validators:
Mongoose provides a variety of built-in validators, such as required, min, max, enum, and more. These validators help you enforce constraints on your data at the schema level, reducing the need for explicit validation code in your Express.js routes.

Middleware Hooks:
Mongoose supports middleware hooks, which are functions that execute at various stages of the data lifecycle, such as before validation, before saving, or after removing a document. This allows you to perform additional logic, transformations, or validations easily, ensuring data consistency.

Error Handling:
Mongoose simplifies error handling by providing a standardized way to catch and handle validation errors. When a validation error occurs, Mongoose returns an error object that can be easily inspected and managed in your Express.js routes.

Consistency Across Routes:
By centralizing data validation in Mongoose schemas, you ensure consistency across different routes and endpoints in your application. This reduces redundancy and makes it easier to manage and maintain your validation logic.

Saves Development Time:
Using Mongoose for data validation saves development time as it abstracts away much of the boilerplate code needed for manual validation. This allows developers to focus more on building features and less on writing repetitive validation code.

Integration with Middleware:
Mongoose integrates seamlessly with Express.js middleware. You can use middleware functions to handle validation, ensuring that validation logic is applied before processing the request further in your route handlers.

Q3: Virtuals in Mongoose are used to create additional properties on your data models without storing them in the actual database. They are handy for calculating or formatting data, improving code organization, and making your code more readable and consistent. Essentially, they help keep your database clean and your code modular.
const userSchema = mongoose.Schema({
email: String
});
// Create a virtual property domain that's computed from email.
userSchema.virtual('domain').get(function() {
return this.email.slice(this.email.indexOf('@') + 1);
});
const User = mongoose.model('User', userSchema);

const doc = await User.create({ email: '[email protected]' });
// domain is now a property on User documents.
doc.domain; // 'gmail.com'

Q4: "population" refers to the process of automatically replacing specified paths in a document with documents from other collections. This is achieved by using references to documents in another collection, rather than embedding the actual documents in the current one.

• When you store object IDs in your documents, you create a reference to another document without embedding the entire document.
  Population is the mechanism by which Mongoose can fetch the referenced documents and replace the object IDs with the actual documents during query execution.
  -Beneficial:
  Reducing Redundancy: Avoid duplicating related data by referencing and populating to store information once and reference it elsewhere.
  Consistency: Ensure up-to-date data retrieval for frequently changing information referenced in many documents.
  Performance: Improve efficiency by using references and population for large datasets, preventing the impact of large embedded documents on performance.

Avoid:
Small Datasets: Opt for embedding if related data is small and infrequently changed to enhance efficiency.
Read Performance: Choose embedding for frequent reads with minimal latency, accepting some redundancy to avoid additional queries.
Complex Queries: Steer clear of population for applications with complex queries spanning multiple collections to prevent performance issues from multiple queries.

Q5 : callback, promises , Async/sync

promises : Promises provide a cleaner way to handle asynchronous code compared to callbacks, especially when dealing with multiple asynchronous operations

Async/await: allowing you to write asynchronous code in a synchronous style Async/await makes the code more readable and resembles synchronous code, making it easier to understand the flow of asynchronous operations

Team: Fda, Noor, Momena
Q1: A Mongoose model is a wrapper on the Mongoose schema. A Mongoose schema defines the structure of the document, default values, validators, etc., whereas a Mongoose model provides an interface to the database for creating, querying, updating, deleting records,

Q2-a customizable middleware that gets defined inside the Schema Type of Mongoose schema. It automatically fires off before a document is saved in the NoSQL DB , Type of validation ( Built-in validation ,Custom validation), the benefit is that it has a built in validation and Error Handling the cabiblity of defining Default Values which lead to more code organization.

Q3- is feature that allow you to define a property on document that is not stored in MongoDB . Virtuals are typically used for computed properties on documents. , let's say we have a User model. Every user has an email, but you also want the email's domain. For example, the domain portion of '[[email protected]]' is 'gmail.com'. Below is one way to implement the domain property using a virtual. You define virtuals on a schema using the [Schema#virtual() function]

Q4-Population is the process or method of automatically replacing the specified paths in the document with document(s) from other collection(s).is a method used to automatically replace the _id or id fields of a document with the a document from another collection. when can use to a void data duplication so we can use reference to another document to have consistency in data so updates apply on places . avoid population when we have Frequency of Updates to avoid heavy database operation and effect on performance

Q4- part 2 . store only the object ID, don't have access to the actual data of the referenced document. if you want to display the data of the referenced document, you'll need to perform an additional query to retrieve it.
Populating the referenced document, allows you to automatically replace the object ID with the actual data of the referenced document.
This means that you can retrieve all the data you need in a single query.

Q5-
Mongoose uses promises to handle asynchronous operations. Promises are a way to handle asynchronous operations in JavaScript, and they provide a way to handle errors and return values in a consistent and predictable way. using .then() and .catch() methods , Mongoose functions that return Promises can be used with async/await, providing a more synchronous code structure.

Room 1: Belal, Musab, Hassan, Mohammad Abdullah

1. What are the differences and connections between Mongoose schemas and models? How do they work together in an Express.js application?

---

Schemas

A Mongoose schema defines the structure of the document, default values, validators, etc., within a MongoDB collection. It's a blueprint for how your data should look. a schema answers "what will the data in this collection look like?"

Models

A Mongoose model is a wrapper on the Mongoose schema. A Mongoose model provides an interface to the database for creating, querying, updating, deleting records, etc. You can think of a model as a constructor which takes in plain JavaScript objects, then adds methods and hooks to them for interacting with the database. a model provides functionality like "Are there any records matching this query?" or "Add a new document to the collection"

2. How does Mongoose handle data validation? Discuss the benefits of using Mongoose for data validation as opposed to doing it manually in your Express.js routes.

---

• Validation is defined in the SchemaType in mongoose. Validation is a middleware in mongoose.
• Using Mongoose for validation we can define validation rules in the schema, ensuring consistency.
• It simplifies route handlers by abstracting away the validation logic.
• Mongoose validation reduces code duplication. Without Mongoose validation, we have to manually validate data every time before saving it, which can lead to a lot of duplicated code if you're saving data in multiple places in your application.
• Error handling is connected by default with validation in mongoose. When a validation fails, Mongoose will return an error detailing what went wrong.

3. What are virtuals in Mongoose? Discuss how and why you might use them in a project. Give examples of scenarios where virtuals can be particularly useful.

---

In Mongoose, a virtual is a property that is not stored in MongoDB. Virtuals are typically used for computed properties on documents. They are typically used for computation based on the values of other fields. They are defined on the mongoose schema.
Use cases:

1. to format the data in a way that's more convenient for the application. For example, combining firstName and lastName into fullName as shown above.
2. for complex calculations. if you have a schema for a product with price and tax fields, you could use a virtual to calculate the total price.
3. A common use case for virtuals is to create a virtual field for a password in a user schema. When the password is set, a hashing algorithm can be used to store a hashed version of the password in the database, while the plain text password remains as a virtual and never gets stored.

4. What is population in Mongoose? How does it differ from simply storing object IDs in your documents? Discuss scenarios where population is beneficial and when it might be better to avoid it.

---

Population in Mongoose is a feature that replaces ObjectIDs in a document with the actual data from the referenced documents, similar to a JOIN operation in SQL. This feature allows you to work with related data as if it was embedded directly into the document, simplifying your code and enhancing readability.

5. How does Mongoose handle asynchronous operations? Discuss the role of promises and async/await in managing database interactions in an Express.js application.

---

mongoose operations by default are asynchronous because they return promise whenever they get called. we can handle returned promise with .then() and .catch() or use async/await to make the code more concise.
Overall, promises and async/await are fundamental in managing database interactions in an Express.js application with MongoDB. using promises or async methods achieves a clean and manageable way to handle asynchronous operations, making it easier to work with the database and handle errors effectively.