Creating and Saving a record with MongoDB

Creating and Saving a record with MongoDB


I’ve struggled with this specific challenge for several weeks, and finally found the solution by looking at this post but I don’t feel like the lesson or Mongoose documentation is terribly intuitive.
How is one supposed to know that you need to name the function needs to be called createAndSavePerson. It also seems odd to me that a function createAndSavePerson would have a variable with specifics for one person without passing in some arguments for name, age, and favorite foods won’t createAndSavePerson always create and save somebody named for example “bob”?
I literally had to copy the code verbatim from the aforementioned post above because I couldn’t find anything in the Mongoose docs about a function like this. Is this intuitive to everyone else? Am I just missing something or does one have to make several leaps to get this challenge?


Yes, it seems these exercises are causing some headaches. When I went through them for the certification months ago, things went somewhat smoothly. However, once I started revisiting them in order to help out here on the forums, I ran into several problems myself, including missing files in the boilerplate. I signed up to Glitch through my GitHub account the first time, but never paid attention to when I was actually logged into Glitch or not after I completed the exercises the first time months before. I seem to recall being able to access the boilerplate, without being logged in, with no problems until one day I just couldn’t. Someone else had mentioned in another thread that being logged into GitHub was necessary, so I did that and was able to access the full code.

When you access the project through the Glitch link, are the server.js and myApp.js files included in the project? If so, don’t edit the server.js file. In the myApp.js file, the createAndSavePerson() function outline should be there waiting for you, so that you can just add the necessary code to save an instance of the Person model created in the previous exercise. fCC has also included the code to export it and the other functions you fill in to the server.js file where they get handled for evaluation.

If this is not the case for you, meaning you didn’t initially have the myApp.js file included in your project when you entered through the project link at fCC, or you did have it included but the createAndSavePerson() function outline (or any others) was missing, or something just seems off, post that here, and we can try and see what’s going on.

When accessing the project through the fCC link, the myApp file looks like this (without any modification):

* 3. FCC Mongo & Mongoose Challenges
* ==================================

/*  ================== */

/** 1) Install & Set up mongoose */

// Add `mongodb` and `mongoose` to the project's `package.json`. Then require 
// `mongoose`. Store your **mLab** database URI in the private `.env` file 
// as `MONGO_URI`. Connect to the database using `mongoose.connect(<Your URI>)`

/** # SCHEMAS and MODELS #
/*  ====================== */

/** 2) Create a 'Person' Model */

// First of all we need a **Schema**. Each schema maps to a MongoDB collection
// and defines the shape of the documents within that collection. Schemas are
// building block for Models. They can be nested to create complex models,
// but in this case we'll keep things simple. A model allows you to create
// instances of your objects, called **documents**.

// Create a person having this prototype :

// - Person Prototype -
// --------------------
// name : string [required]
// age :  number
// favoriteFoods : array of strings (*)

// Use the mongoose basic *schema types*. If you want you can also add more
// fields, use simple validators like `required` or `unique`, and set
// `default` values. See the [mongoose docs](

// <Your code here >

var Person /* = <Your Model> */

// **Note**: GoMix is a real server, and in real servers interactions with
// the db are placed in handler functions, to be called when some event happens
// (e.g. someone hits an endpoint on your API). We'll follow the same approach
// in these exercises. The `done()` function is a callback that tells us that
// we can proceed after completing an asynchronous operation such as inserting,
// searching, updating or deleting. It's following the Node convention and
// should be called as `done(null, data)` on success, or `done(err)` on error.
// **Warning** - When interacting with remote services, **errors may occur** !

// - Example -
// var someFunc = function(done) {
//   ... do something (risky) ...
//   if(error) return done(error);
//   done(null, result);
// };

/** # [C]RUD part I - CREATE #
/*  ========================== */

/** 3) Create and Save a Person */

// Create a `document` instance using the `Person` constructor you build before.
// Pass to the constructor an object having the fields `name`, `age`,
// and `favoriteFoods`. Their types must be conformant to the ones in
// the Person `Schema`. Then call the method `` on the returned
// document instance, passing to it a callback using the Node convention.
// This is a common pattern, all the **CRUD** methods take a callback 
// function like this as the last argument.

// - Example -
// ...
//, data) {
// your stuff here...
// });

var createAndSavePerson = function(done) {
  done(null /*, data*/);


/** 4) Create many People with `Model.create()` */

// Sometimes you need to create many Instances of your Models,
// e.g. when seeding a database with initial data. `Model.create()`
// takes an array of objects like [{name: 'John', ...}, {...}, ...],
// as the 1st argument, and saves them all in the db.
// Create many people using `Model.create()`, using the function argument
// 'arrayOfPeople'.

var createManyPeople = function(arrayOfPeople, done) {
    done(null/*, data*/);

/** # C[R]UD part II - READ #
/*  ========================= */

/** 5) Use `Model.find()` */

// Find all the people having a given name, using `Model.find() -> [Person]`
// In its simplest usage, `Model.find()` accepts a **query** document (a JSON
// object ) as the first argument, and returns an **array** of matches.
// It supports an extremely wide range of search options. Check it in the docs.
// Use the function argument `personName` as search key.

var findPeopleByName = function(personName, done) {
  done(null/*, data*/);


/** 6) Use `Model.findOne()` */

// `Model.findOne()` behaves like `.find()`, but it returns **only one**
// document, even if there are more. It is especially useful
// when searching by properties that you have declared as unique.
// Find just one person which has a certain food in her favorites,
// using `Model.findOne() -> Person`. Use the function
// argument `food` as search key

var findOneByFood = function(food, done) {

  done(null/*, data*/);

/** 7) Use `Model.findById()` */

// When saving a document, mongodb automatically add the field `_id`,
// and set it to a unique alphanumeric key. Searching by `_id` is an
// extremely frequent operation, so `moongose` provides a dedicated
// method for it. Find the (only!!) person having a certain Id,
// using `Model.findById() -> Person`.
// Use the function argument 'personId' as search key.

var findPersonById = function(personId, done) {
  done(null/*, data*/);

/** # CR[U]D part III - UPDATE # 
/*  ============================ */

/** 8) Classic Update : Find, Edit then Save */

// In the good old days this was what you needed to do if you wanted to edit
// a document and be able to use it somehow e.g. sending it back in a server
// response. Mongoose has a dedicated updating method : `Model.update()`,
// which is directly binded to the low-level mongo driver.
// It can bulk edit many documents matching certain criteria, but it doesn't
// pass the edited document to its callback, only a 'status' message.
// Furthermore it makes validation difficult, because it just
// direcly calls the mongodb driver.

// Find a person by Id ( use any of the above methods ) with the parameter
// `personId` as search key. Add "hamburger" to the list of her `favoriteFoods`
// (you can use Array.push()). Then - **inside the find callback** - `.save()`
// the updated `Person`.

// [*] Hint: This may be tricky if in your `Schema` you declared
// `favoriteFoods` as an `Array` without specifying the type (i.e. `[String]`).
// In that case `favoriteFoods` defaults to `Mixed` type, and you have to
// manually mark it as edited using `document.markModified('edited-field')`
// ( - #Mixed )

var findEditThenSave = function(personId, done) {
  var foodToAdd = 'hamburger';
  done(null/*, data*/);

/** 9) New Update : Use `findOneAndUpdate()` */

// Recent versions of `mongoose` have methods to simplify documents updating.
// Some more advanced features (i.e. pre/post hooks, validation) beahve
// differently with this approach, so the 'Classic' method is still useful in
// many situations. `findByIdAndUpdate()` can be used when searching by Id.
// Find a person by `name` and set her age to `20`. Use the function parameter
// `personName` as search key.
// Hint: We want you to return the **updated** document. In order to do that
// you need to pass the options document `{ new: true }` as the 3rd argument
// to `findOneAndUpdate()`. By default the method
// passes the unmodified object to its callback.

var findAndUpdate = function(personName, done) {
  var ageToSet = 20;

  done(null/*, data*/);

/** # CRU[D] part IV - DELETE #
/*  =========================== */

/** 10) Delete one Person */

// Delete one person by her `_id`. You should use one of the methods
// `findByIdAndRemove()` or `findOneAndRemove()`. They are similar to the
// previous update methods. They pass the removed document to the cb.
// As usual, use the function argument `personId` as search key.

var removeById = function(personId, done) {
  done(null/*, data*/);

/** 11) Delete many People */

// `Model.remove()` is useful to delete all the documents matching given criteria.
// Delete all the people whose name is "Mary", using `Model.remove()`.
// Pass to it a query ducument with the "name" field set, and of course a callback.
// Note: `Model.remove()` doesn't return the removed document, but a document
// containing the outcome of the operation, and the number of items affected.
// Don't forget to pass it to the `done()` callback, since we use it in tests.

var removeManyPeople = function(done) {
  var nameToRemove = "Mary";

  done(null/*, data*/);

/** # C[R]UD part V -  More about Queries # 
/*  ======================================= */

/** 12) Chain Query helpers */

// If you don't pass the `callback` as the last argument to `Model.find()`
// (or to the other similar search methods introduced before), the query is
// not executed, and can even be stored in a variable for later use.
// This kind of object enables you to build up a query using chaining syntax.
// The actual db search is executed when you finally chain
// the method `.exec()`, passing your callback to it.
// There are many query helpers, here we'll use the most 'famous' ones.

// Find people who like "burrito". Sort them alphabetically by name,
// Limit the results to two documents, and hide their age.
// Chain `.find()`, `.sort()`, `.limit()`, `.select()`, and then `.exec()`,
// passing the `done(err, data)` callback to it.

var queryChain = function(done) {
  var foodToSearch = "burrito";
  done(null/*, data*/);

/** **Well Done !!**
/* You completed these challenges, let's go celebrate !

/** # Further Readings... #
/*  ======================= */
// If you are eager to learn and want to go deeper, You may look at :
// * Indexes ( very important for query efficiency ),
// * Pre/Post hooks,
// * Validation,
// * Schema Virtuals and  Model, Static, and Instance methods,
// * and much more in the [mongoose docs](

//----- **DO NOT EDIT BELOW THIS LINE** ----------------------------------

exports.PersonModel = Person;
exports.createAndSavePerson = createAndSavePerson;
exports.findPeopleByName = findPeopleByName;
exports.findOneByFood = findOneByFood;
exports.findPersonById = findPersonById;
exports.findEditThenSave = findEditThenSave;
exports.findAndUpdate = findAndUpdate;
exports.createManyPeople = createManyPeople;
exports.removeById = removeById;
exports.removeManyPeople = removeManyPeople;
exports.queryChain = queryChain;


Yes something is broken - I’m using ‘passing’ code I’ve found on the forum that is identical to what I wrote, and it’s not passing… it’s telling me I’m missing a done() argument…

What should I do?


Can you throw your code into a GitHub repository and put the repository link in a reply to this reply?

If you’re not sure about how to do that, here’s a short and sweet video tutorial:

If you haven’t linked your Glitch account to your GitHub account, you’ll have to do that.

Once I see that link, I’ll take a look at your code. And, maybe some other members will take a look as well. Many heads are better than one and all that…


Thank you! Here’s the Git Repo link:



Thanks to stack overflow!

This is related to a challenge in freeCodeCamp:

If you are trying to complete this challenge then please scroll down the template myApp.js file which has proper instructions and function declaration for each step. you will find a empty function with createAndSavePerson(), Please write your logic in that one.


Your right something definitely seems off, in Glitch I had server.js and myApp.js files there but it felt like there was a logical step or two missing from the instructions to the actual implementation. One of the things I like about FCC is they don’t spoon feed you as much as other platforms but I feel like something is definitely lacking here.

Another example of this is in the next challenge… “Use Model.find() to search your database” I was wracking my brain trying to get this to work for the past few days I kept getting this error E11000 duplicate key error index: flashy-lathe.people.$name_1 dup key: { : today I logged on and it worked (I changed nothing at all).


I know I would’ve avoided a fair bit of frustration if I had taken, say, a week just to go through YouTube tutorials on node.js, MongoDb, and Express; there are some fantastic ones out there.

Once you get done with the full stack certification, go through this tutorial.

It’s super easy to follow and will really solidify your skills. It’s Node, Express and Mongoose, so you’ll be familiar with what’s going on right from the beginning. Plus, you’ll be introduced the Handlebars.js template engine, which is a little bit nicer, IMO, than Pug, which is the template engine fCC introduces.


I’ll look into that. Glad to see a tutorial that uses Handlebars over Pug.