General code review fixes

Author: osamaakb

module3-crud-and-data-models/assets/relationalDBmeme.png

@@ -1,4 +1,4 @@
-## Intoduction To Database Schemas
+## Introduction To Database Schemas
 
 A database schema is a blueprint or architecture of how our data will look. It doesn’t hold data itself, but instead describes the shape of the data and how it might relate to other tables or models.
 
@@ -31,21 +31,24 @@ CREATE TABLE customer (
 
 ```
 
-We can see that the schema definition for the `customer` has a `name` which is a type `string` and a `zipcode` that is of type `number`.
+We can see that the schema definition for the `customer` has a `name` that is type `string` and a `zipcode` that is of type `number`.
 
 ## Introduction to CRUD operations
 
-When we are building APIs, we want our models to provide four basic types of functionality. The model must be able to Create, Read, Update, and Delete resources. Computer scientists often refer to these functions by the acronym `CRUD`. A model should have the ability to perform at most these four functions in order to be complete.
+When we are building APIs, we want our models to provide four basic types of functionality. The model must be able to Create, Read, Update, and Delete resources. Computer scientists often refer to these functions by the acronym CRUD. A model should have the ability to perform at most these four functions in order to be complete.
 
 ### CRUD and REST
 
-### What is REST?
+**What is REST?**
 
-REST is a set of architectural constraints. API developers can implement REST in a variety of ways. When a client request is made via a RESTful API, it transfers a representation of the state of the resource to the requester or endpoint. This information, or representation, is delivered in one of several formats, JSON is the most generally popular file format to use.
+REST is a set of architectural constraints. API developers can implement REST in a variety of ways. When a client request is made via a RESTful API, it transfers data as an object in some format to the requester or endpoint. There are several formats, JSON is the most generally popular file format to use.
+
+**Resource in REST**
+A resource in REST is a like an Object or an Entity in a Database. Once a resource is identified then its representation is to be decided using a standard format so that the server can send the resource in the decided on format and client can understand the same format. A resource can be any information that can be named (e.g. a person, a user, an invoice, a collection of invoices, etc).
 
 ### CRUD (CREATE, READ, UPDATE, DELETE)
 
-In a REST environment, CRUD often corresponds to the HTTP methods `POST`, `GET`, `PUT`, and `DELETE`, respectively. These are the fundamental elements of a persistent storage system.
+In a REST environment, CRUD often corresponds to the [HTTP request methods](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods) `POST`, `GET`, `PUT`, and `DELETE`, respectively. These are the fundamental elements of a persistent storage system.
 
 For example, imagine we are working with a system that is keeping track of meals and their corresponding prices for a restaurant. Let’s look at how we would implement CRUD operations.
 
@@ -60,11 +63,11 @@ Note: Use `POST` when you want to add a child resource under resources collectio
 
 `POST http://www.myrestaurant.com/api/dishes/`
 
-We will need to send the `dish` data too.
+We will need to send the dish data too.
 
 #### Read
 
-To read resources in a REST environment, we use the GET method. in practice, reading a resource shouldn't change any information - it should only retrieve it.
+To read resources in a REST environment, we use the GET method. In practice, reading a resource shouldn't change any information - it should only retrieve it.
 
 To read resources in a REST environment, we use the GET method. Reading a resource should never change any information - it should only retrieve it. REST itself is more like a set of guidelines. Technically, you can change data in a `GET` request, but since we are creating a RESTful API, you shouldn't do that. Having a GET request that updates data in your database would be confusing to the users of your API and violate the expected behavior of REST.
 
@@ -86,7 +89,7 @@ Note: Use `PUT` when you want to modify a singular resource which is already a p
 #### Delete
 
 The CRUD operation Delete corresponds to the HTTP method DELETE. It is used to remove a resource from the system.
-Let’s say that the world avocado shortage has reached a critical point, and we can no longer afford to serve this modern delicacy at all. We should go into the database and delete the item that corresponds to `Avocado Toast`, which we know has an `id` of 1223.
+Let’s say that the world avocado shortage has reached a critical point, and we can no longer afford to serve this modern delicacy at all. We should go into the database and delete the item that corresponds to **Avocado Toast**, which we know has an `id` of 1223.
 
 ##### Request:
 

module3-crud-and-data-models/r1-schema-and-data-models/README.md

@@ -8,31 +8,39 @@ Without a clean, efficient, consistent database schema, you’ll struggle to mak
 
 Most developers don't see the difference between relational database schema and MongoDB schema, but in reality, it is not the same
 
-<img src="https://i.imgur.com/3yobiPB.jpg" alt="meme" width="400"/>
+<img src="../assets/relationalDBmeme.png" alt="meme" width="400"/>
 
 In a nutshell, in relational databases, models are usually independent of queries, there is no duplication of data as data will _mostly_ be separated into different tables, and it is rigid, you will have to define types and fields for your schema beforehand.
 
-in the other hand, `MongoDB`, you have more flexibility, there are no rules, documents can have new data or fields at any point of time, no need to define types.
+In the other hand, `MongoDB`, you have more flexibility, there are no rules, documents can have new data or fields at any point of time, no need to define types.
 
 ### Embedding vs. Referencing
 
 One of the key points to establish a good schema design (especially, if you are using MongoDB) is whether to embed or reference your data.
 
-#### When to `Embed`:
+#### Embedding
+
+When a collection has a document, and, this document contains another document, another document contains another sub-document, and so on. This is called embedding or nesting.
+
+#### When to Embed
 
 - To retrive all data in a single query.
 - Avoid expense JOINs or $lookups.
 - Update all data with a single operation.
 - In one-to-one or one-to-many relationships between documents.
 
+#### Referencing
+
+When a value of a field in your table or collection referes to a value of another field in another table or collection.
+
 #### When to `Reference`
 
 - If you need smaller documents or tables, your data will be separated across multiple documents or tables.
 - No duplicate of data.
 - To reduce accessed data not accessed on every query.
 - In many-to-many relationships between tables and documents.
 
-In general, there are few `rules` you can follow to better design your schema:
+In general, there are few **rules** you can follow to better design your schema:
 
 ##### 1. Favor embedding over referencing unless there is a compelling reason not to.
 

module3-crud-and-data-models/r1.1-principles-of-setting-up-your-schema/README.md

@@ -2,7 +2,7 @@
 
 ## Introduction to MVC projects
 
-When beginning a new project (especially, when using express), there are several different methods that can be used to set up the overall file structure and flow. One of the most commonly used architectural patterns is called MVC. This acronym stands for "Model, View, Controller".
+When beginning a new project (especially, when using Express), there are several different methods that can be used to set up the overall file structure and flow. One of the most commonly used architectural patterns is called MVC. This acronym stands for "Model, View, Controller".
 This pattern is favored because of its alignment with the computer science design principle, [**separation of concerns**](https://en.wikipedia.org/wiki/Separation_of_concerns). By dividing up responsibilities within our file structure, for example, we can have our db connection work in one file and api routes in another file, ...etc.
 
 ```
@@ -27,7 +27,7 @@ package-lock.json
 
 ### Models
 
-In this folder, you can write the functionality & logics related to the Database (if you aren't using ORM) like insert, fetch, update, delete queries. It takes the query request from the controller & sends the response back to the controller.
+In this folder, you can write the functionality & logics related to the database (if you aren't using ORM) like insert, fetch, update, delete queries. It takes the query request from the controller & sends the response back to the controller.
 The naming convention for the model files is: `name-here-model.js`.
 
 Here’s an example model using JavaScript and Mongoose.
@@ -91,4 +91,4 @@ router.get('/posts', (req, res) => {
 ## Resources
 
 - [MVC Architecture with NodeJS and Mongoose](https://medium.com/geekculture/mvc-architecture-with-express-server-e35aedfe7889)
-- [express MVC structure](https://codingstatus.com/express-mvc-structure/)
+- [Express MVC structure](https://codingstatus.com/express-mvc-structure/)

module3-crud-and-data-models/r3-model-view-controller/README.md

@@ -56,7 +56,7 @@ module.exports = app;
 
 - #### Create
 
-Create or add a new `food` item to our foods.
+Create or add a new food item to our foods.
 
 Example:
 
@@ -113,4 +113,4 @@ app.delete("/food/:id", async (request, response) => {
 
 ## Resources
 
-- [CRUD operations in mongoose](https://mongoosejs.com/docs/models.html#Querying)
+- [CRUD operations in Mongoose](https://mongoosejs.com/docs/models.html#Querying)

module3-crud-and-data-models/r3.2-models-and-controllers-in-mongoose/README.md

@@ -1,6 +1,7 @@
 ## Building Your Own Methods on Mongoose
 
-In Mongoose, instances of Models are documents. Documents have many of their own built-in instance methods. We may also define our own custom document instance methods.
+In Mongoose, instances of models are documents. Documents have many of their own built-in instance methods (called static methods). We may also define our own custom document instance methods.
+We use instance methods to add new custom methods to our model that didn't exist before, that will help us reduce our code duplications if that method is used in multiple places, and, imporove the overall code structure.
 
 For example:
 
@@ -27,4 +28,4 @@ dog.findSimilarTypes((err, dogs) => {
 
 ## Resources
 
-- [instance methods in Mongoose](https://mongoosejs.com/docs/guide.html#methods)
+- [Instance methods in Mongoose](https://mongoosejs.com/docs/guide.html#methods)