Now that we've written both the router and the controller, it's time to turn back to RethinkDB and write the code that physically saves and loads data from the database. In the previous section, you learned how different functions in the controller call different functions in the model, so what we need to do now is implement these functions in the models/rethinkdb.js file.

As an example, let's focus on the function that creates a new note and saves it to the database: the user first creates the note from the app in his browser, then the browser performs an HTTP request that is received from the Node.js server and passed on to the router. At this point, the router handles the request and passes the data to the controller, which, in turn, extracts the data and calls the appropriate function in the model. In this case, the function to save a note in the model is called saveNote() and is implemented as this:

model.saveNote = function (note, done) {
    r.connect({ host: 'localhost', port: 28015 }, function(err, conn) {
        if(err) throw err;
        r.db('test').table('notes').insert(note).run(conn, function(err, results) {
            done();
        });
    });
}

This function does a few things. Let's look at them one by one. First, it creates a connection to the database on localhost, port 28015, which is the default port. If the connection is successful, we run an insert query on our RethinkDB cluster, saving the note object into the database. If you're wondering where this object comes from, it is passed by the controller and as a JavaScript object is represented in JSON format, we can pass this object directly to RethinkDB's insert function. Once the query succeeds, we call a callback function called done() that resumes the execution of the code in the controller.

Almost all other functions within the model behave similarly; let's see another example: the function that removes a note from the database:

model.deleteNoteByID = function (id, done) {
    r.connect({ host: 'localhost', port: 28015 }, function(err, conn) {
        if(err) throw err;
        r.db('test').table('notes').get(id).delete().run(conn, function(err, res) {
            if (err) throw err;
            done();
        });
    });
}

The controller calls this function, passing it the ID of the note to be removed. The model then connects to RethinkDB and runs a get() query to access the document specified by the ID and calls the delete() function on the document in order to remove it from the database. Just as in the previous example, we then call the provided callback function to resume the execution of the controller's code.

model.listenForUpdates = function(cb) {
     r.connect({ host: 'localhost', port: 28015 }, function(err, conn) {
        if(err) throw err;
        r.db('test').table('notes').changes().run(conn, function(err, cursor) {
            cursor.each(function(err, item) {
                cb(item);
            });
        });
    });
}