Let's connect to our question and answer service application to Mongoose, and

build the schemas for our API.

The code for

our database connection will be similar to the code we wrote in our sandbox.

You can just copy and paste it over to the app.js file.

Let's open up mongoose_sandbox.js.

And copy the mongoose require and the connection code.

Paste it into the app.js right above the router.

Let's also change the database name to QA for question and answer.

Notice the call to the db.once method is still open.

So let's close it with a curly brackets, parentheses and a semicolon.

Before when we working in our sandbox, we put all of the database interaction

code inside the callback in this once method.

That would ensure that the code would only run after the database connection was open

and ready for business.

Here in the Express app we wouldn't need to worry about that.

All we want to do is log out once the open event occurs.

Setting up the Mongo connection is still asynchronous and

in fact the express app will normally finish setting up and start listening for

requests before the database is ready.

While it would be easy to assume that the requests made during this time

would be dropped, Mongoose actually stores them and

then runs them once the database is ready, which is extremely helpful.

Now that the connection code is in place,

let's set up the schemas in a separate file called models.js

Create the file in the root of the folder called models.js,

and at the top of the file let's put use strict,

And require Mongoose

And store the schema constructor as a local variable.

Now we're ready to write the schemas.

We'll need two schemas, a question and an answer schema.

Let's create a question schema.

As previously decided, we'll need a text property to hold the text of the question,

As well as a time for creation.

And then a rate to store the answers in.

The text and date properties are straightforward.

To let Mongoose know about the relationship between answers and

questions, we'll need to place the answer schema

as the only elements of an array on the question schema.

This is a signal to Mongoose that we want answer documents to be nested inside

question documents.

We haven't created an answer schema yet.

But when we do, let's call it AnswerSchema.

Before we create the answer schema, let's improve the createdAt property.

We know that we want to set this to the current date and

time when every question is created.

Mongoose can take care of that using an object to specify the default value.

Now whenever a question is created using this schema, the current dates and

time will automatically be supplied for this field.

Right now,

AnswerSchema is undefined, since we haven't declared the variable yet.

We should do this above the QuestionSchema so

it will be defined by the time QuestionSchema sees it.

We know we'll need a text attribute and a createdAt time.

We'll also put in updated app time.

Which will initially match createdAt.

Let's also provide votes which is a number,

And the default value should be 0.

Now we have the two schemas that are connected together.

At the bottom of the file we can create and export a question model.

Let's first create the model using Mongoose's model method.

We can then later import the question into our routes file to make use of it there.

Our API is coming along nicely in the next video we'll look at ways to make it

even better.