DOCSP-9048: Quick Start user study updates (#73)

* DOCSP-9048: Quick Start User Study Updates

Author: Chris Cho

source/includes/figures/atlas_connection_copy_string.png

@@ -7,193 +7,200 @@ Quick Start
 .. contents:: On this page
    :local:
    :backlinks: none
-   :depth: 1
+   :depth: 2
    :class: singlecol
 
-This guide shows you how to create an application that uses the Node.js
-driver to connect to a MongoDB Atlas cluster.
+This guide shows you how to create an application that uses the
+**Node.js driver** to connect to a **MongoDB Atlas cluster**. If you
+prefer to connect to MongoDB using a different driver or programming
+language, see our :driver:`list of official drivers <>`.
 
-Check for Node and NPM
-----------------------
+The Node.js driver is an interface through which you can connect to and
+communicate with MongoDB instances.
 
-Ensure your system has Node version 8 or later and NPM (Node Package
-Manager) installed. Run the following commands to check that you meet
-these requirements:
+MongoDB Atlas is a fully-managed cloud database service that hosts your data
+on MongoDB instances. We show you how to get started with your own free (no
+credit card required) instance in this guide.
 
-First, check the version of Node:
+Follow the steps below to connect your Node.js application with a MongoDB
+instance.
 
-.. code-block:: sh
+Set up Your Project
+-------------------
 
-   node -v
+Install Node and NPM
+~~~~~~~~~~~~~~~~~~~~
 
-You should see output similar to the following:
-
-.. code-block:: sh
-
-   v12.14.1
-
-Next, check the version of NPM:
-
-.. code-block:: sh
-
-   npm -v
-
-You should see output similar to the following:
-
-.. code-block:: sh
-
-   6.13.4
-
-If you do not see any output or encounter an error, you will need to
-install Node and NPM. Visit `nodejs.org <https://nodejs.org>`_ for
-installation instructions.
+Ensure your system has Node.js version 8 or later and NPM (Node Package
+Manager) version 5 or later installed. For more information on how to check
+your version of Node and NPM and installation instructions for your
+system, see `downloading and installing Node.js and npm
+<https://docs.npmjs.com/downloading-and-installing-node-js-and-npm>`_.
 
 Initialize the Project
-----------------------
+~~~~~~~~~~~~~~~~~~~~~~
 
-Now that our system meets the Node driver's requirements, we can
+After you verify that you installed the required versions of Node and NPM,
 create a new project.
 
-First, create a directory for your project:
+First, create a directory for your project in your command line interface:
 
-.. code-block:: sh
+.. code-block:: none
 
-  mkdir node_quickstart
+   mkdir node_quickstart
 
 Then, navigate into that directory so you can work directly with your
 project's files:
 
-.. code-block:: sh
+.. code-block:: none
 
   cd node_quickstart
 
-Finally, initialize npm:
+Next, set up NPM for your project by running the following command.
+This command creates a file called ``package.json``:
 
-.. code-block:: sh
+.. code-block:: none
 
   npm init -y
 
 .. admonition:: Why the -y?
   :class: note
 
-  Specifying ``-y`` tells NPM to use default values. You can omit the
-  ``-y`` flag to proceed through an interactive selection process for
-  common project settings.
+  If you specify the ``-y`` option in the command, NPM automatically
+  accepts the default values for the command. Omit the ``-y`` flag to
+  interactively select your project settings.
 
 Add MongoDB as a Dependency
----------------------------
-
-Next, add the Node MongoDB driver as a project dependency. Use the
-``--save`` flag to save the dependency to the ``package.json`` file that
-was automatically generated in the previous step.
-
-.. code-block:: sh
-
-  npm install --save mongodb
+~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-NPM downloads the dependencies required for installation and saves them
-into a directory called ``node_modules`` in your project directory.
+Next, add the official Node.js MongoDB driver to your project dependencies.
+Use the following command to instruct NPM to download and install the
+``mongodb`` package.
 
-Create a Free Tier Cluster in Atlas
------------------------------------
+.. code-block:: none
 
-You can easily get started with MongoDB with :atlas:`MongoDB Atlas
-<tutorial/create-atlas-account>`, which offers instances of MongoDB
-hosted in the cloud. Atlas doesn't require a credit card to
-sign up, and offers free-tier deployments that are free for life. Follow
-along with our :atlas:`steps to create and set up a free-tier cluster
-<tutorial/create-atlas-account/>`, then :atlas:`load sample data
-<sample-data/load-sample-data/>` to run the examples in this guide.
+  npm install mongodb
 
-Store Configuration Separately
-------------------------------
+This command downloads ``mongodb`` package and dependencies required for its
+installation and saves them into a directory called ``node_modules`` in
+your project directory, and records the dependency information in the
+``package.json`` file you generated in the previous step.
 
-You can store your application configuration separately for security
-and convenience. We use the `dotenv
-<https://www.npmjs.com/package/dotenv>`_ NPM module to store our
-configuration data in a separate local file called ``.env``. If you are
-using git source control, add the ``.env`` file to your ``.gitignore``
-entries to prevent accidentally sharing contents such as database
-credentials.
+At this point, you should have appropriate versions of Node.js and NPM
+installed as well as a project directory that contains the dependencies you
+need to use the Node.js MongoDB driver.
 
-First, add ``dotenv`` to your project:
+Create a MongoDB Cluster
+------------------------
 
-.. code-block:: sh
+Set up a Free Tier Cluster in Atlas
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-  npm install --save dotenv
+After installing the Node MongoDB driver, create a MongoDB instance to store
+and manage your data. Complete the
+:atlas:`Get Started with Atlas <getting-started>` guide to set up a new
+Atlas account, free tier cluster (MongoDB instance), load datasets, and
+interact with the data.
 
-Next, create the ``.env`` file and add a variable called
-``MONGODB_URI``:
+After completing the steps in the Atlas guide, you should have a new MongoDB
+cluster deployed in Atlas, a new database user, and sample datasets loaded
+into your cluster.
 
-.. code-block:: sh
-
-  touch .env
-  echo "MONGODB_URI=<connection_uri>" >> .env
+Connect to your Cluster
+-----------------------
 
-Add your Atlas Connection String
---------------------------------
+In this step, we create and run an application that uses the Node.js MongoDB
+driver to connect to your instance of MongoDB and run a query on the sample
+data.
 
-Open your newly created ``.env`` file. If you are unable to locate this
-file in your project directory, you may need to set your system to
-display hidden files. Once your ``.env`` is open, replace
-``<connection_uri>`` with your connection string from Atlas. Ensure you
-update ``<username>`` and ``<password>`` in your connection string.
+We pass instructions to the driver on where and how to connect to your
+MongoDB instance in a string called the *connection string*. This string
+includes information on the hostname or IP address and port of your
+instance, authentication mechanism, user credentials when applicable, and
+other connection options.
 
-Connect to your Cluster
------------------------
+To retrieve your connection string for the instance and user you created in
+the previous step, log into your Atlas account and navigate to the
+**Clusters** section and click the **Connect** button for the cluster that you
+want to connect to as shown below.
 
-For the final step, we'll write some code that tests your environment's
-connection to your instance of MongoDB.
+.. figure:: /includes/figures/atlas_connection_select_cluster.png
 
-Create a file in your project directory called ``index.js``:
+Proceed to the **Connect Your Application** step and select the Node.js
+driver. Select the "Connection String Only" tab and click the **Copy**
+button to copy the *connection string* to your clipboard as shown below.
 
-.. code-block:: sh
+.. figure:: /includes/figures/atlas_connection_copy_string.png
 
-  touch index.js
+Save your connection string to a safe location that you can access in the
+next step.
 
-Open this file and paste in the following code:
+Next, create a file to contain your application called ``index.js`` in your
+``node_quickstart`` directory. Add the following code, replacing the ``uri``
+variable with your connection string. Make sure to replace the "<password>"
+section of the connection string with the password you created for your user
+that has **atlasAdmin** permissions.
 
 .. code-block:: js
 
   const { MongoClient } = require("mongodb");
-  require("dotenv").config();
 
-  if (!process.env.MONGODB_URI) {
-    throw Error("MONGODB_URI not defined in a .env file. Did you set it up?");
-  }
+  // Replace the uri string with your MongoDB deployment's connection string.
+  const uri =
+    "mongodb+srv://<user>:<password>@<cluster-url>?retryWrites=true&w=majority&useUnifiedTopology=true";
 
-  const client = new MongoClient(process.env.MONGODB_URI, {
-    useUnifiedTopology: true
-  });
+  const client = new MongoClient(uri);
 
   async function run() {
     try {
-      // Connect the client to the server
       await client.connect();
-      // Establish and verify connection
-      await client.db("admin").command({ ping: 1 });
-      console.log("Successfully connected to Atlas.");
-      // your code after this comment
 
-      // your code before this comment
+      const database = client.db('sample_mflix');
+      const collection = database.collection('movies');
+
+      // Query for a movie that has the title 'Back to the Future'
+      const query = { title: 'Back to the Future' };
+      const movie = await collection.findOne(query);
+
+      console.log(movie);
     } finally {
       // Ensures that the client will close when you finish/error
       await client.close();
     }
   }
   run().catch(console.dir);
 
-Run the script with the following command from your terminal:
+Run the sample code with the following command from your command line:
 
-.. code-block:: sh
+.. code-block:: none
 
   node index.js
 
-You should see the output **Successfully connected to Atlas.**
+When you run the command, the sample code should output the details of the
+movie which resembles the following:
+
+::
+
+   {
+     _id: ...,
+     plot: 'A young man is accidentally sent 30 years into the past...',
+     genres: [ 'Adventure', 'Comedy', 'Sci-Fi' ],
+     ...
+     title: 'Back to the Future',
+     ...
+   }
+
+If or receive an error, check whether you included the proper connection
+string in the application code, and loaded the sample dataset in your Atlas
+cluster.
+
+After completing this step, you should have a working application that uses
+the Node.js driver to connect to your MongoDB instance, run a query on the
+sample data, and prints out the result.
 
 Next Steps
 ----------
 
-Learn how to read and modify data in our :doc:`CRUD fundamentals
-</fundamentals/crud>` guide, or how to perform common operations in our
-:doc:`usage examples </usage-examples>`.
+Learn how to read and modify data using the Node.js driver in our
+:doc:`CRUD fundamentals </fundamentals/crud>` guide, or how to perform common
+operations from our :doc:`usage examples </usage-examples>`.