Full-Stack Web Development with Vue.js and Node: Build scalable and powerful web apps with modern web stack: MongoDB, Vue, Node.js, and Express

To install Node.js using the installer, perform the steps:

Just hit Close and we will be done.

Node.js can be easily installed using Homebrew in macOS. Homebrew is a free and open source software package manager that is used to install software on macOS. I personally prefer Homebrew because it makes it very easy to install different software on Mac:

$ /usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"

$ brew install node

To install from the default distribution, we can install Node.js on Linux by using this command:

$ sudo apt-get install -y nodejs

To install Node.js from NodeSource, perform the following steps:

$ curl -sL https://deb.nodesource.com/setup_9.x | sudo -E bash 

$ sudo apt-get install -y nodejs

To install a package specific to our application only, we can use this command:

$ npm install <package_name> --save

To install a package globally, we can use this command:

 $ npm install -g <package_name>

We can manually create a package.json file and specify the options ourselves, or we can use a command to create it interactively from the command prompt. 

Let's go ahead and initialize a sample application with a package.json using npm.

First, create a folder in your projects directory using the command:

$ mkdir testproject

To create a package.json file, run the following command in the application that we created:

$ npm init

Running this command will ask us a bunch of questions that we can answer interactively from the command line:

In the end, it will create a package.json file, which will have the following content:

 $ cd Downloads
 $ mv mongodb-osx-x86_64-3.0.7.tgz ~/

 $ tar -zxvf mongodb-osx-x86_64-3.0.7.tgz

 $ mkdir -p /data/db

 $ ~/mongodb/bin/mongod

Here, we have successfully installed and started the mongo server.

To install MongoDB in macOS from Homebrew, follow these steps:

$ brew install mongodb

 $ sudo mkdir -p /data/db

 $ ~/mongodb/bin/mongod

Hence, MongoDB is finally installed.

To install MongoDB using apt-get, perform the following steps:

 $ sudo apt-get install -y mongodb-org

 $ cd /var/log/mongodb/mongod.log

 $ sudo service mongod start

 $ [initandlisten] waiting for connections on port   <port>

 $ sudo service mongod stop

 $ sudo service mongod restart

 $ curl -O https://fastdl.mongodb.org/linux/mongodb-linux-x86_64-
 3.4.10.tgz

 $ tar -zxvf mongodb-linux-x86_64-3.4.10.tgz

 $ mkdir -p mongodb
 $ cp -R -n mongodb-linux-x86_64-3.4.10/ mongodb

 $ export PATH=<mongodb-install-directory>/bin:$PATH

 $ mkdir -p /data/db

 $ mongod

This is the place where we can see all of our databases, collections, and documents. To display the list of databases that we have, we can use the following:

> show dbs

Now, this command should list all the existing databases. To use the database that we want, we can simply run this command:

> use <database_name>

But if there is no database listed, don't worry. MongoDB provides us with a functionality where, when we run the preceding command, even if that database does not exist, it will automatically create a database with the given name for us.

So, if we already have a database that we want to use, we simply run that command and, if there are no databases yet, we create one using this command:

> use posts

When we run this command, a database named posts will be created.

Now, let's quickly review the commands used in MongoDB. The insert command is used to create new documents in a collection in MongoDB. Let's add a new record to the database that we just created called posts.

Here as well, in order to add a document to a collection, we first need a collection, which we don't have yet. But MongoDB allows us to create a collection easily by running the insert command. Again, if the collection exists, it will add the document to the given collection and, if the collection does not exist, it will simply create a new collection.

Now, in the Mongo shell, run the following command:

> db.posts.insertOne({
    title: 'MEVN',
    description: 'Yet another Javascript full stack technology'
});

The command will create a new collection called posts in the posts database. The output of this command is:

It will return a JSON object that has the ID of the document that we just created in the insertedId key and a flag that the event was received as acknowledged.

This command is used when we want to fetch the records from a collection.  We can either fetch all the records or a specific document by passing parameters as well. We can add a few more documents to the posts database to better learn the command

Fetching all documents

To fetch all the records from the postscollection, run the following command:

> db.posts.find()

This will return all the documents that we have in the posts collection:

Fetching a specific document

Let's find a post where the title is MEVN. To do that, we can run:

> db.posts.find({ 'title': 'MEVN' })

This command will return only those documents whose title is MEVN:

This command is used when we want to update a certain part of a collection. Let's say we want to update the description of a post whose title is Vue.js; we can run the following command:

> db.posts.updateOne(
     { "title" : "MEVN" },
     { $set: { "description" : "A frontend framework for Javascript programming language" } }
 )

The output for this command will be:

We can see here that the matchedCount is 1, which means that as regards the parameter that we sent to update the record with the title MEVN, there was one document in the posts collection that matched the query.

The other key called modifiedCount gives us the count of the documents that got updated.

The delete command is used to remove documents from a collection. There are several ways to delete a document from MongoDB.

> db.posts.remove({ title: 'MEVN' })

> db.posts.deleteOne({ title: 'Expressjs' })

> db.posts.remove({})