AUTH_TOKEN

Your authentication token that you acquired after a successful login.

GMAIL_EMAIL

Your email on Gmail that will be used to send confirmation emails.

OAUTH_CLIENT_ID

Your client id that we explained in the Secure Emails lesson.

OAUTH_CLIENT_SECRET

Your client's secret that we explained in the Secure Emails lesson.

OAUTH_REFRESH_TOKEN

Your refresh token that we explained in the Secure Emails lesson.

docker.tar.gz

PORT

CONFIRMATION_SECRET_KEY

CRYPTO_ALGORITHM

INITIALIZATION_VECTOR

MONGO_URI

SALT

TOKEN_SECRET_KEY

hello_world

wrong_hello_world

routes_examples

events

async

mongoose

usermodel

signup

confirmation

login

auth

props

router

react

SignupGUI

ConfirmationGUI

LoginGUI

AuthGUI

navbar

SignupPage

SignupPageGUI

ConfirmationPage

LoginPage

ux-page

home-page

UploadGUI

SpellGUI

ImageGUI

GetGUI

UpdateGUI

DeleteGUI

CRUD

Heroku

GetGUI-copy

SpellGUIV2

ImageGUIV2

CRUDV2

Node.js is a popular JavaScript runtime environment used to create server-side applications. It is an ideal tool for building robust, full-stack web applications with React.

This course is an introduction to web development leveraging these two popular technologies. You’ll learn server-side applications with Node.js and learn to add database functionality with MongoDB fitting into the Express application framework. You’ll then build a user authorization system using the JSON Web Token (JWT).

You’ll then focus on a client-side environment built with React. You’ll build a sample application to get familiar with the framework before styling the application and adding necessary user-interaction elements. You’ll wrap up by tying the frontend and backend together and deploying your web application with Heroku.

By the end of this course, you’ll be prepared to build real-world websites using the most popular JavaScript tools.

Building Full-Stack Web Applications With Node.js and React

The `for await...of` statement creates a loop that iterates over async iterable objects of `readline` only.

The `for await...of` statement creates a loop that iterates over async iterable objects only.

The `for await...of` statement creates a loop that iterates over async iterable objects as well as over sync iterables.

What is the best description for the behavior of the following code?

```
for await (const line of readInterface) {
    const correctedLine = line
      .split(" ")
      .map((word) => {
        if (SpellChecker.isMisspelled(word)) {
          const suggestions = SpellChecker.getCorrectionsForMisspelling(word);

          const matches = stringSimilarity.findBestMatch(word, suggestions);

          return matches.bestMatch.target;
        } else return word;
      })
      .join(" ");

    text += correctedLine + "\n";
  }
```

What is the best description for the behavior of the following code?
<pre><code>for await (const line of readInterface) {
 const correctedLine = line
 .split(&quot; &quot;)
 .map((word) =&gt; {
 if (SpellChecker.isMisspelled(word)) {
 const suggestions = SpellChecker.getCorrectionsForMisspelling(word);

 const matches = stringSimilarity.findBestMatch(word, suggestions);

 return matches.bestMatch.target;
 } else return word;
 })
 .join(&quot; &quot;);

 text += correctedLine + &quot;\n&quot;;
 }
</code></pre>

They perform the same functionality with different implementation techniques. All of them read files line by line.

The first technique is a non-blocking technique that reads the file line by line asynchronously and keeps only one line in the memory at a time.

The second technique is a a non-blocking technique that reads the file line by line synchronously and keeps all the file’s content in the memory.

The third technique is a non-blocking technique that reads the file line by line asynchronously and keeps all the file’s content in the memory.

**(Select all that apply.)** Describe the following three techniques for reading a file in Node.js.

1.
   ```
   const fs = require("fs");
   const readline = require("deadline");

   const readInterface = readline.createInterface({
    input: fs.createReadStream('file.txt'),
    output: process.stdout,
    console: false,
     });

     for await (const line of readInterface) {
    console.log(line)
     }
   ```

2. 
   ```
   const fs = require('fs');

   try {
    const data = fs.readFileSync('file.txt', 'UTF-8');
    const lines = data.split(/\r?\n/);
    lines.forEach((line) => {
        console.log(line);
    });
   } catch (err) {
    console.error(err);
   }
   ```

3. 
   ```
   const fs = require('fs');

   try {
    const data = fs.readFile('file.txt', 'UTF-8');
    const lines = data.split(/\r?\n/);
    lines.forEach((line) => {
        console.log(line);
    });
   } catch (err) {
    console.error(err);
   }
   ```

(Select all that apply.) Describe the following three techniques for reading a file in Node.js.
<ol>
<li>
<pre><code>const fs = require(&quot;fs&quot;);
const readline = require(&quot;deadline&quot;);

const readInterface = readline.createInterface({
 input: fs.createReadStream('file.txt'),
 output: process.stdout,
 console: false,
 });

 for await (const line of readInterface) {
 console.log(line)
 }
</code></pre>
</li>
<li>
<pre><code>const fs = require('fs');

try {
 const data = fs.readFileSync('file.txt', 'UTF-8');
 const lines = data.split(/\r?\n/);
 lines.forEach((line) =&gt; {
 console.log(line);
 });
} catch (err) {
 console.error(err);
}
</code></pre>
</li>
<li>
<pre><code>const fs = require('fs');

try {
 const data = fs.readFile('file.txt', 'UTF-8');
 const lines = data.split(/\r?\n/);
 lines.forEach((line) =&gt; {
 console.log(line);
 });
} catch (err) {
 console.error(err);
}
</code></pre>
</li>
</ol>

```
router.post("/upload", auth, upload.multiple("files"), fileController.upload);
```

```
router.post("/upload", auth, upload.array("files"), fileController.upload);
```

```
router.post("/upload", auth, upload.array("files", 10), fileController.upload);
```

```
router.post("/upload", auth, upload.array("files", 100), fileController.upload);
```

**(Select all that apply.)** How can we upload multiple files using the `Multer` package? 

(Select all that apply.) How can we upload multiple files using the <code>Multer</code> package?

MongoDB can't handle storing the file's object in the database instance.

MongoDB can handle storing files up to 16MB only.

The code will work and the performance won't be affected.

The code will work but the performance will be downgraded.

Which of the following statements holds true in the code below keeping in mind the file object is stored in the database instead of the disk?

```
exports.upload = async (req, res) => {
   // ...rest of the code
   const file = await File.create({
      name,
      createdBy,
      description,
      createdAt: Date.now(),
      filePath: fs.readFileSync(path),
   });
}
```

Which of the following statements holds true in the code below keeping in mind the file object is stored in the database instead of the disk?
<pre><code>exports.upload = async (req, res) =&gt; {
 // ...rest of the code
 const file = await File.create({
 name,
 createdBy,
 description,
 createdAt: Date.now(),
 filePath: fs.readFileSync(path),
 });
}
</code></pre>

No, the possible errors that can occur from the async operations should be handled.

No, there’s no other option to handle it in Node.js

Yes, we can handle it using the `then...catch` technique.

Yes, we can handle it using the `promises` technique in Node.js.

**(Select all that apply.)** Can the following handler be rewritten without the `try..catch` technique? 

```
exports.upload = async (req, res) => {
  try {
    const { error } = validate(req.body);
    if (error) return res.status(400).send(error.details[0].message);

    const { createdBy, name, description } = req.body;

    if (req.file.mimetype === "text/plain") {
      await spellCheck(req.file.path);
    }

    let path = req.file.path;
    if (req.file.mimetype.match(/^image/)) {
      path = await processImage(req.file.path);
    }

    const file = await File.create({
      name,
      createdBy,
      description,
      createdAt: Date.now(),
      filePath: BASE_URL + path,
    });

    res.status(200).json({ message: "File uploaded successfully", data: file });
  } catch (err) {
    console.log(err);
    return res.status(400).send(err.message);
  }
};

```

(Select all that apply.) Can the following handler be rewritten without the <code>try..catch</code> technique?
<pre><code>exports.upload = async (req, res) =&gt; {
 try {
 const { error } = validate(req.body);
 if (error) return res.status(400).send(error.details[0].message);

 const { createdBy, name, description } = req.body;

 if (req.file.mimetype === &quot;text/plain&quot;) {
 await spellCheck(req.file.path);
 }

 let path = req.file.path;
 if (req.file.mimetype.match(/^image/)) {
 path = await processImage(req.file.path);
 }

 const file = await File.create({
 name,
 createdBy,
 description,
 createdAt: Date.now(),
 filePath: BASE_URL + path,
 });

 res.status(200).json({ message: &quot;File uploaded successfully&quot;, data: file });
 } catch (err) {
 console.log(err);
 return res.status(400).send(err.message);
 }
};

</code></pre>

Choose the correct answer(s)

Choose the correct answer(s)

Test your skills on how to handle business logic.

Before You Begin

The Server-side

User Authentication with a JSON Web Token

Set up the Client-side Environment

Develop the Client-side

Business Logic

Server-side Routes

Client-side Routes

Appendix

Conclusion

Test Yourself: Business Logic