By the end of this lesson, you should be able to connect to a non-relational database (MongoDB) and perform basic CRUD operations.

• Interact with a document database

• Connect to a MongoDB database with Mongoose
• Perform basic CRUD operations on the database
• Build and run specific queries
• Validate schemas
• Model complex application ideas using embedded data models

1. Fork & clone

2. cp nodemon.sample.json nodemon.json

3. Create a new Cluster on MongoDB Atlas titled something like general-purpose or reuse one you already have.

4. Update the MONGO_DB_CONNECTION in your nodemon.json file with the full connection string. Make sure you include the password you set up for the database and change the name of the database from test to something lke television_characters_dev.

5. npm install

6. npm run dev

Once installation is working, try creating and requesting resources. Note that there is currently no validation set up.

• Take a moment to look through the code that already exists in this repository. Run the code and test out each route, ensuring it does what you expect.

• We will be using both mongoose and mongodb to build this project. Open up each project's documentation.

• Question: What is the difference between mongoose and mongodb?

• Your Answer: mongodb is the actual database and supporting application, whereas mongoose is a package for interacting with the database application with methods for manipulating its content.

• MongoDB uses a number of terms that may be to new to you such as database, collection, and document.

• Question: What is the difference between the above terms? This page may help.

• Your Answer: A database holds the entirety of the documents stored in the cluster. Collections are groupings of document entries. Per the documentation, akin to a classical SQL database table. A document is a single entry in the database.

• Create a new file with the path of api/models/series.js. In that file, define the schema for a television series. Include the fields "title", "start_year", and "season_count".

• Question: Where does String and Number come from?

• Your Answer: Those come from the String and Number constructor functions.

• Merge the following into your schema:

  {
    _id: Schema.Types.ObjectId
  }

• Question: Describe what the above code is adding to your schema.

• Your Answer: It is adding a unique global identifier field that would need to be defined on creation.

• Remove the line we just added from your schema.

• Question: If we create a new document, will there be an ID? Why or why not?

• Your Answer: Yes. Every instantiation of a new document entry will auto-generate an ID.

• Add the following object as the second argument to the new Schema() statement.

  {
    timestamps: { createdAt: 'created_at', updatedAt: 'updated_at' }
  }

• Question: Describe what the above code is adding to your schema.

• Your Answer: It is a schema option in mongoose to add timestamps to your document with customized field names.

• Import the model into your routes/series.js file. Use either basic promises or async/await to update the GET / method to retrieve from the database instead of the given array. This page or this page may be useful.

• Question: What method do you use to return all documents from a collection?

• Your Answer: .find()

• Update the API so that you can create documents in the database. You may either use the <document>.save() method or the Model.create() method.

• Question: What happens if you do not include all the fields as specified in the schema?

• Your Answer: It will create the document but omit entries for those dimensions.

• Take a moment to view your new document in the MongoDB Atlas console.

• Update the API so that you retrieve a document by ID.

• Question: There are a couple different ways to accomplish this goal. Which method did you choose?

• Your Answer: .findById()

• Update the API so that you are able to update a document. Use the Model.updateOne() method.

• Question: What are the arguments for Model.updateOne()?

• Your Answer: 1) a filter object which will retrieve the first matching document based on the values input 2) the update object with the values to be updated, 3) the (optional) options object and 4) an optional callback function.

• Question: The response you receive is not the document you updated. What information is being represented here? Try replacing Model.updateOne() with the Model.findOneAndUpdate() and see the difference in the result.

• Your Answer: The updateOne() call returns an object filled with information about the query itself. findOneAndUpdate() returns the data that was just overwritten.

• Question: This new method will return the old document instead of the new one. What option can you add to your statement to return the new one?

• Your Answer: add new: true to the options object.

• Question: Another field was updated when you ran this command. Which one was it?

• Your Answer: the updated_at field.

• Question: Take a look at the terminal window running your server. You are likely getting the following deprecation warning:

  DeprecationWarning: Mongoose: `findOneAndUpdate()` and `findOneAndDelete()` without the `useFindAndModify` option set to false are deprecated. See: https://mongoosejs.com/docs/deprecations.html#-findandmodify-
  

  Take a look at this page to see how to fix it. Describe the changes that took place.

• Your Answer: By setting the useFindAndModify flag to false you are telling mongoose to use MongoDB's findOneAndUpdate() function rather than its findAndModify() function as there is a function name collision between Mongo and Mongoose.

• Update the API so that you can successfully delete a record. Use the Model.findOneAndDelete() method.

• A lot of information is being returned on each request. Some of this information we may want to keep private. Using the .select() method, return only the "_id", "title", "start_year", and "season_count" on all the above requests.

• Question: At least one of these will throw an error. Which one? How can you get around this issue?

• Your Answer: Create throws an error. Create returns a Promise and the .select() function can only be applied to queries. To avoid errors or accidental inclusion/exclusion of fields, it seems that the select property should be set in the schema model itself and not applied at the route query.

• Modify your GET /api/series route so that you can search through the content based off of query parameters. For example, if your request was GET /api/series?start_year=1997, it would return all series that start in 1997.

• At the moment, there is no validation set on creating any series. Add validation so that each of the three fields are required in order to post to series. Handle any errors that arise with a status code 400 and a brief, standardized message.

• Question: You may notice that you can add custom error messages to individual fields failing. Try adding these and take a look at the error message received. How can you make use of those specific messages for each field?

• Your Answer: You can add a validate object to the Schema field that includes a custom validator function for testing the entry as well as a custom message to return in the error object.

• With Mongo, it is simple to create complex data structures. Add a characters field to your Series model that is an array of objects. Each object should have a name and image_url. Only the name field on the character should be required. Note: Don't forget to change your select statements to include the characters field!

• Question: Take a look at the response from making a new series with a character. What field was created that you did not have to define?

• Your Answer: An ID was automatically assigned to my character subdocument.

• Question: With the current routes that we have, how would you upate the name of a character in a series?

• Your Answer: You would have to use the PUT call to /:id of the Series for the character you wish to update.

• While we can now update subdocuments, it is difficult to make changes that only relate to a single subdocument. To do so, we should make a new set of routes that relates to characters. Start by creating a GET ALL route for characters. The route will look something like the following and will return only the list of characters:

  GET /api/series/:seriesID/characters
  

• Question: Where did you decide to put this route and why?

• Your Answer: I opted to put this route within the series routes as it is still contingent on the id parameter for the series similar to the /:id route. Since child subdocuments are only saved when their parent is saved, it made sense to put this in with the parent schema itself.

Spend the rest of class building out the other routes for characters. A few notes to help:

• It's worth reading the subdocument documentation in full
• Take note of the .id() method for finding subdocuments by id
• Note that in order to save subdocuments, you will need to save the parent record; in our case, you should be calling series.save(), not character.save()

If you're interested in going further, I would recommend looking into references.

• MongoDB Atlas
• Mongoose