table of content

Unit 0: Getting Set Up

Lesson 0 Setting up Node.js and the JavaScript engine

0.1 What you’re going to learn

0.2 Understanding Node.js

0.3 The minimally qualified reader

0.4 Why learn to develop in Node.js?

0.5 Preparing yourself for this book

Summary

Lesson 1: Configuring your environment

1.1 Installing Node.js

1.2 Installing a text editor

1.3 Setting up SCM and deployment tools

1.4 Working with the Node.js REPL in terminal

Summary

Lesson 2: Running a Node.js application

2.1 Creating a JavaScript file

2.2 Running your JavaScript file with Node.js

2.3 Running Individual JavaScript Commands

Summary

Unit 1: Getting Started with Node.js

Lesson 3: Creating a Node.js module

3.1 Creating a Node.js module

3.2 Running npm commands

3.3 Initializing a Node.js application

Summary

Lesson 4: Building a simple web server in Node.js

4.1 Understanding web servers

4.2 Initializing the application with npm

4.3 Coding the application

4.4 Running the application

Summary

Lesson 5: Handling incoming data

5.1 Reworking your server code

5.2 Analyzing request data

5.3 Adding routes to a web application

Summary

Lesson 6: Writing better routes and serving external files

6.1 Serving static files with the `fs` module

6.2 Serving assets

6.3 Moving your routes to another file

Summary

Lesson 7: Capstone: Creating your first web application

7.1 Initializing the application

7.2 Application directory structure

7.3 Creating `main.js` and `router.js`

7.4 Creating views

7.5 Adding assets

7.6 Creating routes

Summary

Unit 2: Easier web development with Express.js

Lesson 8: Setting up an app with Express.js

8.1 Installing the Express.js package

8.2 Building your first Express.js application

8.3 Working your way around a web framework

Summary

Lesson 9: Routing in Express.js

9.1 Building routes with Express.js

9.2 Analyzing Request data

9.3 Using MVC

Summary

Lesson 10: Connecting views with templates

10.1 Connecting a templating engine

10.2 Passing data from your controllers

10.3 Setting up partials and layouts

Summary

Lesson 11: Configurations and error handling

11.1 Modifying your start script

11.2 Handling errors with Express.js

11.3 Serving static files

Summary

Lesson 12: Capstone: Enhancing the Confetti Cuisine site with Express.js

12.1 Initializing the application

12.2 Building the application

12.3 Adding more routes

12.4 Routing to views

12.5 Serving static views

12.6 Passing content to the views

12.7 Handling the errors

Summary

Unit 3: Connecting to a database

Lesson 13: Set up a MongoDB database

13.1 Setting up MongoDB

13.2 Running commands in the MongoDB shell

13.3 Connecting MongoDB to your application

Summary

Lesson 14: Building Models with Mongoose

14.1 Setting up Mongoose with your Node.js application

14.2 Creating a schema

14.3 Organizing your models

Summary

Lesson 15: Connecting Controllers and Models

15.1 Creating a controller for subscribers

15.2 Saving posted data to a model

15.3 Using promises with Mongoose

Summary

Lesson 16: Capstone: Saving user subscriptions

16.1 Setting up the database

16.2 Modeling data

16.3 Adding subscriber views and routes

Summary

Unit 4: Building a user model

Lesson 17: Improving your data models

17.1 Adding validations on the model

17.2 Testing models in REPL

17.3 Creating model associations

17.4 Populating data from associated models

Summary

Lesson 18: Building the user model

18.1 Building the user model

18.2 Adding CRUD methods to your models

18.3 Building the index page

18.4 Cleaning up your actions

Summary

Lesson 19: Creating and reading your models

19.1 Building the new user form

19.2 Creating new users from a view

19.3 Reading user data with `show`

Summary

Lesson 20: Updating and deleting your models

20.1 Building the `edit` user form

20.2 Updating users from a view

20.3 Deleting users with the delete action

Summary

Lesson 21:Capstone: Adding CRUD models to Confetti Cuisine

21.1 Getting set up

21.2 Building the models

21.3 Creating the views

21.4 Structuring routes

21.5 Creating controllers

Summary

Unit 5: Authenticating user accounts

Lesson 22: Adding sessions and flash messages

22.1 Setting up flash message modules

22.2 Adding flash messages to controller actions

Summary

Lesson 23: Building a user login and hashing passwords

23.1 Implementing the user login form

23.2 Hashing passwords

23.3 Adding validation middleware with express-validator

Summary

Lesson 24: Adding user authentication

24.1 Implementing Passport.js

24.2 Modifying the create action to use passport registration

24.3 Authenticating users at login

Summary

Lesson 25: Capstone: Adding user authentication to Confetti Cuisine

25.1 Getting set up

25.2 Creating a login form

25.3 Adding encryption with Passport.js

25.4 Adding flash messaging

25.5 Adding validation middleware with express-validator

25.6 Adding authentication with Passport.js

25.7 Logging in and out

Summary

Unit 6: Building an API

Lesson 26: Adding an API to your application

26.1 Organizing your routes

26.2 Creating an API

26.3 Calling your API from the client

Summary

Lesson 27: Acccessing your API from your application

27.1 Applying an API namespace

27.2 Joining courses via modal

27.3 Creating an API endpoint to connect models

Summary

Lesson 28: Adding API security

28.1 Simple security

28.2 Adding API tokens

28.3 Using JSON web tokens

Summary

Lesson 29: Capstone: Implementing an API

29.1 Restructuring routes

29.2 Adding the courses partial

29.3 Creating the AJAX function

29.4 Adding an API endpoint

29.5 Creating an action to enroll users

Summary

Unit 7: Adding chat functionality

Lesson 30: Working with Socket.io

30.1 Using `socket.io`

30.2 Creating a chat box

30.3 Connecting the server and client

Summary

Lesson 31: Saving chat messages

31.1 Connecting messages to users

31.2 Displaying user names in chat

31.3 Creating a message model

Summary

Lesson 32: Adding a chat notification indicator

32.1 Broadcasting to all other sockets

32.2 Creating a chat indicator in navigation

Summary

Lesson 33: Capstone: Adding a chat feature to Confetti Cuisine

33.1 Installing socket.io

33.2 Setting up socket.io on the server

33.3 Setting up socket.io on the client

33.4 Creating a Message model

33.5 Loading messages on connection

33.6 Setting up the chat icon

Summary

Unit 8: Deploying and managing code in production

Lesson 34: Deploying your application

34.1 Preparing for deployment

34.2 Deploying your application

34.3 Setting up your database in production

Summary

Lesson 35: Managing in production

35.1 Loading seed data

35.2 Linting

35.3 Debugging your application

Summary

Lesson 36: Testing your application

36.1 Basic testing with core modules

36.2 Testing with `mocha` and `chai`

36.3 Testing with a database and server

Summary

Lesson 37: Capstone: Deploying Confetti Cuisine

37.1 Linting and logging

37.2 Preparing for production

37.3 Deploying to Heroku

37.4 Setting up the database

37.5 Debugging in production

Summary

Unit A: Appendixes

Appendix A: JavaScript syntax introduced in ES6

A.1 New in ES6

A.1.1 The let keyword

A.1.2 The const variable

A.1.3 String interpolation

A.1.4 Arrow functions

A.2 REPL

A.2.1 Running JavaScript in REPL

A.2.2 Using REPL in application development

Summary

Appendix B: Logging

B.1 Logging

B.2 Global objects

Overview

12 Capstone: Enhancing the Confetti Cuisine site with Express.js

This chapter walks through refactoring the Confetti Cuisine site from a hand-rolled Node.js server to an Express.js application to simplify routing, templating, and asset delivery. It preserves the home, courses, and sign-up experiences while adopting EJS with a shared layout to keep pages consistent and reduce duplication. The overall goal is to streamline development, make content easier to render, and prepare the app for growth with clearer structure and middleware support.

The build begins by initializing the project, adding a start script, and installing express, ejs, express-ejs-layouts, body-parser, and http-status-codes. A clean structure is established with controllers for route logic, views for templates, and a public directory for client assets. The main server sets the view engine to EJS, enables layout rendering, parses URL-encoded and JSON bodies, serves static files from public, and defines routes for the home, courses, and contact pages, including a POST route to process the contact form.

Dynamic content is introduced by preparing a courses list in the controller and passing it to the view, where EJS iterates and renders titles and prices, eliminating hardcoded markup. Robustness is added via centralized error handling: a 404 handler renders a friendly not-found page for unmatched URLs, and a 500 handler logs unexpected issues and responds gracefully, both registered after all other routes. The result is a maintainable Express app that keeps UI consistent through a shared layout, simplifies static asset delivery, and is ready to swap the in-memory data for a database without changing the views.

View of courses page

View of error page

Summary

Through this project, I redefined the Node.js project file structure to fit a web framework. I used npm to install three external packages. Then I rebuilt the main application file, using Express.js syntax. To create a path for specific URLs, I set up new routes, using Express.js keywords. For a consistent user interface, I used layouts with EJS. Using Express.js’ static library, I set up static assets to be served to the client through my public folder. Last, I added content to the main project application file and set up that content to be served dynamically to one of my views.

With consistent practice of these techniques and proper error handling, I can use Express.js to build future applications in a few steps. With new features such as layouts and dynamic content, I can try to send content to other views in my application or try modifying the layout as it’s used throughout the app.

In unit 3, I discuss how to organize application code around persistent data with Express.js.

FAQ

How do I initialize the Confetti Cuisine Express application?

From a new confetti_cuisine folder, run npm init and accept defaults (set main to main.js). Then add a start script in package.json: "start": "node main.js". Launch with npm start.

Which npm packages do I need and what do they do?

Install: express (web framework), ejs (view engine), express-ejs-layouts (layout support), body-parser (parse request bodies), http-status-codes (readable status constants). Command: npm install express ejs express-ejs-layouts body-parser http-status-codes --save

What directory structure should I use?

Create: views (EJS templates), controllers (route handlers), public (client assets) with public/css, public/js, public/images. Keep main.js and package.json at the project root.

How do I set up the basic Express server and home route?

In main.js: const express = require('express'); const app = express(); app.set('port', process.env.PORT || 3000); app.get('/', (req, res) => res.send('Welcome to Confetti Cuisine!')); app.listen(app.get('port'), () => console.log(...));

How do I parse form data in Express?

Add body-parser middleware: const bodyParser = require('body-parser'); app.use(bodyParser.urlencoded({ extended: false })); app.use(bodyParser.json()); This enables parsing of URL-encoded and JSON bodies.

How do I add routes for courses and the contact form?

Create controllers/homeController.js with functions like showCourses, showSignUp, and a POST handler that renders a thank-you page. In main.js: app.get('/courses', homeController.showCourses); app.get('/contact', homeController.showSignUp); app.post('/contact', homeController.postedContactForm); Ensure the POST handler name matches your export.

How do I enable EJS and layouts?

Require express-ejs-layouts, set EJS as the view engine, and use the layouts middleware: const layouts = require('express-ejs-layouts'); app.set('view engine', 'ejs'); app.use(layouts); Create views/layout.ejs with the placeholder <%- body %> to inject page content.

How do I serve static files (CSS, JS, images)?

Add app.use(express.static('public')); After this, files under public/ are served directly (e.g., /css/confetti_cuisine.css, /images/product.jpg).

How do I pass dynamic data to views and render it?

Build data in the controller and pass it via res.render: res.render('courses', { offeredCourses: courses }); In courses.ejs, loop and print values: <% offeredCourses.forEach(course => { %>

<%= course.title %>

$ <%= course.cost %> <% }) %>

How should I handle 404 and 500 errors?

Create controllers/errorController.js with pageNotFoundError (sets 404 and renders error.ejs) and internalServerError (logs error and sends a friendly 500). In main.js, register them last: app.use(errorController.pageNotFoundError); app.use(errorController.internalServerError); Route order matters—these act as catch-alls.

pro $24.99 per month

access to all Manning books, MEAPs, liveVideos, liveProjects, and audiobooks!
choose one free eBook per month to keep
exclusive 50% discount on all purchases
renews monthly, pause or cancel renewal anytime

lite $19.99 per month

access to all Manning books, including MEAPs!

team

5, 10 or 20 seats+ for your team - learn more

eBook

pdf, ePub, online

$54.99 $27.49

you save $27.50 (50%)

pro $24.99 per month

access to all Manning books, MEAPs, liveVideos, liveProjects, and audiobooks!
choose one free eBook per month to keep
exclusive 50% discount on all purchases
renews monthly, pause or cancel renewal anytime

lite $19.99 per month

access to all Manning books, including MEAPs!

team

5, 10 or 20 seats+ for your team - learn more

eBook

$54.99 $27.49

you save $27.50 (50%)

eBook

pdf, ePub, online

$54.99 $27.49

you save $27.50 (50%)

pro $24.99 per month

access to all Manning books, MEAPs, liveVideos, liveProjects, and audiobooks!
choose one free eBook per month to keep
exclusive 50% discount on all purchases
renews monthly, pause or cancel renewal anytime

lite $19.99 per month

access to all Manning books, including MEAPs!

team

5, 10 or 20 seats+ for your team - learn more