1. Introduction FREE CHAPTER

• Introduction
• What is Node.js?
• Installing Node.js and Creating your First App
• Understanding the Role and Usage of Node.js
• Course Outline
• How to Get the Most Out of the Course?
• Working with the Read-Eval-Print Loop (REPL) vs Using Files

2. Optional: JavaScript - A Quick Refresher

• Module Introduction
• JavaScript in a Nutshell
• Refreshing the Core Syntax
• Let and Const
• Understanding Arrow Functions
• Working with Objects, Properties, and Methods
• Arrays and Array Methods
• Arrays, Objects, and Reference Types
• Understanding Spread and Rest Operators
• Destructuring
• Async Code and Promises
• Wrap up

3. Understanding the Basics

• Module Introduction
• How the Web Works?
• Creating a Node Server
• The Node Lifecycle and Event Loop
• Understanding Requests
• Sending Responses
• Routing Requests
• Redirecting Requests
• Parsing Request Bodies
• Understanding Event Driven Code Execution
• Blocking and Non-Blocking Code
• Node.js - Looking Behind the Scenes
• Using the Node Modules System
• Wrap Up

4. Improved Development Workflow and Debugging

• Module Introduction
• Understanding Node Package Manager (NPM) Scripts
• Installing Third Party Packages
• Using Nodemon for Auto Restarts
• Understanding Different Error Types
• Finding and Fixing Syntax Errors
• Dealing with Runtime Errors
• Logical Errors
• Using the Debugger
• Restarting the Debugger Automatically After Editing your App
• Changing Variables in the Debug Console
• Wrap Up

5. Working with Express.js

• Module Introduction
• What is Express.js?
• Installing Express.js
• Adding Middleware
• How Middleware Works?
• Express.js - Looking Behind the Scenes
• Handling Different Routes
• Parsing Incoming Requests
• Limiting Middleware Execution to POST Requests
• Using Express Router
• Adding a 404 Error Page
• Filtering Paths
• Creating HTML Pages
• Serving HTML Pages
• Returning a 404 Page
• Using a Helper Function for Navigation
• Styling your Pages
• Serving Files Statically
• Wrap Up

6. Working with Dynamic Content and Adding Templating Engines

• Module Introduction
• Sharing Data across Requests and Users
• Templating Engines - An Overview
• Installing and Implementing Pug
• Outputting Dynamic Content
• Converting HTML Files to Pug
• Adding a Layout
• Finishing the Pug Template
• Working with Handlebars
• Converting your Project to Handlebars
• Adding a Layout to Handlebars
• Working with Embedded JavaScript Templating (EJS)
• Working on the Layout with Partials
• Wrap Up

7. The Model View Controller (MVC)

• Module Introduction
• What is Model View Controller (MVC)?
• Adding Controllers
• Finishing the Controllers
• Adding a Product Model
• Storing Data in Files through the Model
• Fetching Data from Files through the Model
• Refactoring the File Storage Code
• Wrap Up

8. Optional: Enhancing the App

• Module Introduction
• Creating the Shop Structure
• Working of the Navigation System
• Registering the Routes
• Storing Product Data
• Displaying Product Data
• Editing and Deleting Products
• Adding Another Item

9. Dynamic Routes and Advanced Models

• Module Introduction
• Preparations
• Adding the Product ID to the Path
• Extracting Dynamic Params
• Loading Product Detail Data
• Rendering the Product Detail View
• Passing Data with POST Requests
• Adding a Cart Model
• Using queryParams
• Pre-Populating the Edit Product Page with Data
• Linking to the Edit Page
• Editing the Product Data
• Adding the Delete Functionality for a Product
• Deleting Cart Items
• Displaying Cart Items on the Cart Page
• Deleting Cart Items
• Fixing a Delete Product Bug
• Wrap Up

10. SQL Introduction

• Module Introduction
• Choosing a Database
• NoSQL Introduction
• Comparing SQL and NoSQL
• Setting up MySQL
• Connecting the App to the SQL Database
• Basic SQL and Creating a Table
• Retrieving Data
• Fetching Products
• Fetching Products - Time to Practice
• Inserting Data into the Database
• Fetching a Single Product with the "WHERE" Clause
• Wrap Up

11. Understanding Sequelize

• Module Introduction
• What is Sequelize?
• Connecting to the Database
• Defining a Model
• Syncing JavaScript Definitions to the Database
• Inserting Data and Creating a Product
• Retrieving Data and Finding Products
• Fetching a Single Product with the "WHERE" clause
• Fetching Admin Products
• Updating Products
• Deleting Products
• Creating a User Model
• Adding a One-To-Many Relationship
• Creating and Managing a Dummy User
• Using Magic Association Methods
• Fetching Related Products
• One-To-Many and Many-To-Many Relations
• Creating and Fetching a Cart
• Adding New Products to the Cart
• Adding Existing Products and Retrieving Cart Items
• Deleting Related Items and Deleting Cart Products
• Adding an Order Model
• Storing Cart items as Order items
• Resetting the Cart and Fetching and Outputting Orders
• Wrap Up

12. Working with NoSQL and Using MongoDB

• Module Introduction
• What is MongoDB?
• Relations in NoSQL
• Setting up MongoDB
• Installing the MongoDB Driver
• Creating the Database Connection
• Finishing the Database Connection
• Using the Database Connection
• Creating Products
• Understanding the MongoDB Compass
• Fetching All Products
• Fetching a Single Product
• Making the "Edit" & "Delete" Buttons Work Again
• Working on the Product Model to Edit the Product
• Finishing the "Update Product" Code
• Important Note on Updating Products
• Deleting Products
• Fixing the "Add Product" Functionality
• Creating New Users
• Storing the User in the Database
• Working on Cart Items and Orders
• Adding the "Add to Cart" Functionality
• Storing Multiple Products in the Cart
• Displaying the Cart Items
• Fixing a Bug
• Deleting Cart Items
• Adding an Order
• Adding Relational Order Data
• Getting Orders
• Removing Deleted Items from the Cart
• Wrap Up

13. Working with Mongoose

• Module Introduction
• What is Mongoose?
• Connecting to the MongoDB Server with Mongoose
• Creating the Product Schema
• Saving Data through Mongoose
• Fetching all Products
• Fetching a Single Product
• Updating Products
• Deleting Products
• Adding and Using a User Model
• Using Relations in Mongoose
• Important Thing about Fetching Relations
• Working on the Shopping Cart
• Loading the Cart
• Deleting Cart Items
• Creating and Getting Orders
• Storing all Order Related Data
• Clearing the Cart after Storing an Order
• Getting and Displaying the Orders
• Wrap Up

14. Sessions and Cookies

• Module Introduction
• What is a Cookie?
• The Current Project Status
• Optional: Creating the Login Form
• Adding a Request-Driven Login Solution
• Setting a Cookie
• Manipulating Cookies
• Configuring Cookies
• What is a Session?
• Initializing the Session Middleware
• Using the Session Middleware
• Using MongoDB to Store Sessions
• Sessions and Cookies - A Short Summary
• Deleting a Cookie
• Fixing Some Minor Bugs
• Making "Add to Cart" Work Again
• Two Tiny Improvements
• Wrap Up

15. Adding Authentication

• Module Introduction
• What is Authentication?
• How is Authentication Implemented?
• Updated Project Status
• Implementing an Authentication Flow
• Encrypting Passwords
• Adding a Tiny Code Improvement
• Adding the Sign in Functionality
• Working on Route Protection
• Using Middleware to Protect Routes
• Understanding Cross-Site Request Forgery (CSRF) Attacks
• Using a Cross-Site Request Forgery (CSRF) Token
• Adding Cross-Site Request Forgery (CSRF) Protection
• Fixing the Order Button
• Providing User Feedback
• Optional: Styling Error Messages
• Finishing the Flash Messages
• Adding Additional Flash Messages
• Wrap Up

16. Sending Emails

• Module Introduction
• How Does Sending Emails Work?
• Using SendGrid
• Using Nodemailer to Send an Email
• Potential Limitation for Large Scale Apps

17. Advanced Authentication

• Module Introduction
• Resetting Passwords
• Implementing the Token Logic
• Creating the Token
• Creating the Reset Password Form
• Adding Logic to Update the Password
• Why we Need Authorization?
• Adding Authorization
• Adding Protection to Post Actions
• Why Editing Fails?
• Wrap Up

18. Understanding Validation

• Module Introduction
• Why Should we use Validation?
• How to Validate Input?
• Setup Basic Validation
• Using Validation Error Messages
• Built-In Custom Validators
• More Validators
• Checking for Field Equality
• Adding Async Validation
• Keeping User Input
• Adding Conditional CSS Classes
• Adding Validation to Login
• Sanitizing Data
• Validating Product Addition
• Validating Product Editing
• Wrap Up

19. Error Handling

• Module Introduction
• Types of Errors and Error Handling
• Analyzing Error Handling in the Current Project
• Errors - Some Theory
• Throwing Errors in Code
• Returning Error Pages
• Using the Express.js Error Handling Middleware
• Updating the App
• Using the Error Handling Middleware Correctly
• Status Codes
• Wrap Up

20. File Upload and Download

• Module Introduction
• Adding a File Picker to the Frontend
• Handling Multipart Form Data
• Handling File Uploads with Multer
• Configuring Multer to Adjust Filename and File Path
• Filtering Files by MIME type
• Storing File Data in the Database
• Serving Images Statically
• Downloading Files with Authentication
• Setting Up File Type Headers
• Restricting File Access
• Streaming Data vs Preloading Data
• Using PDFKit for .pdf Generation
• Generating .pdf Files with Order Data
• Deleting Files
• Fixing Invoice Links
• Wrap Up

21. Adding Pagination

• Module Introduction
• Adding Pagination Links
• Retrieving a Chunk of Data
• Preparing Pagination Data on the Server
• Adding Dynamic Pagination Buttons
• Re-using the Pagination Logic and Controls
• Wrap Up

22. Understanding Async Requests

• Module Introduction
• What are Async Requests?
• Adding Client Side JavaScript Code
• Sending and Handling Background Requests
• Manipulating the Document Object Model (DOM)

23. Adding Payments

• Module Introduction
• How Payments Work?
• Adding a Checkout Page
• Using Stripe in Your App

24. Working with REST APIs - The Basics

• Module Introduction
• What Are REST APIs and Why Do We Use Them?
• Accessing Data with REST APIs
• Understanding Routing and HTTP Methods
• REST APIs - The Core Principles
• Creating our REST API Project and Implementing the Route Setup
• Sending Requests and Responses and Working with Postman
• REST APIs, Clients, and Cross-Origin Resource Sharing (CORS) Errors
• Sending POST Requests
• Wrap Up

25. Working with REST APIs - The Practical Application

• Module Introduction
• REST APIs and the Rest of the Course
• Understanding the Frontend Setup
• Planning the API
• Fetching Lists of Posts
• Adding a Create Post Endpoint
• Adding Server-Side Validation
• Setting up a Post Model
• Storing Posts in the Database
• Static Images and Error Handling
• Fetching a Single Post
• Uploading Images
• Updating Posts
• Deleting Posts
• Adding Pagination
• Adding a User Model
• Adding User Signup Validation
• Signing Users up
• How Does Authentication Work?
• Starting with User Login
• Log in and Creating JSON Web Tokens (JWTs)
• Using and Validating the Token
• Adding Auth Middleware to all Routes
• Connecting Posts and Users
• Adding Authorization Checks
• Clearing Post-User Relations
• Wrap Up

26. Understanding Async/Await in Node.js

• Module Introduction
• What is Async/Await all About?
• Transforming "Then/Catch" to "Async/Await"
• Wrap Up

27. Understanding WebSocket & Socket.io

• Module Introduction
• What Are WebSocket and Why Would You Use Them?
• WebSocket Solutions - An Overview
• Setting up Socket.io on the Server
• Establishing a Connection from the Client
• Identifying Realtime Potential
• Sharing the IO Instance Across Files
• Synchronizing POST Additions
• Fixing a Bug - The Missing Username
• Updating Posts on all Connected Clients
• Sorting Correctly
• Deleting Posts across Clients
• Wrap Up

28. Working with GraphQL

• Module Introduction
• What is GraphQL?
• Understanding the Setup and Writing First Query
• Defining a Mutation Schema
• Adding a Mutation Resolver and GraphQL
• Adding Input Validation
• Handling Errors
• Connecting the Frontend to the GraphQL API
• Adding a Login Query and a Resolver
• Adding Login Functionality
• Adding a "Create Post" Mutation
• Extracting User Data from the Auth Token
• Sending the "Create Post" Query
• Fixing a Bug and Adding New Posts Correctly
• Adding a "Get Post" Query and Resolver
• Sending "Create Post" and "Get Post" Queries
• Adding Pagination
• Uploading Images
• Viewing a Single Post
• Updating Posts
• Deleting Posts
• Managing the User Status
• Using Variables
• Fixing a Pagination Bug
• Wrap Up

29. Deploying the App

• Module Introduction
• Deploying Different Kinds of Apps
• Deployment Preparations
• Using Environment Variables
• Using Production API Keys
• Setting Secure Response Headers with Helmet
• Compressing Assets
• Setting up Request Logging
• Setting up a Secure Sockets Layer (SSL) Server
• Using a Hosting Provider
• Understanding the Project and the Git Setup
• A Deployment Example with Heroku
• Deploying APIs

30. Testing Node.js Applications

• Module Introduction
• What is Testing?
• Testing - Why and How?
• Setup and Writing the First Test
• Testing the Auth Middleware
• Organizing Multiple Tests
• What Not to Test!
• Using Stubs
• Testing Controllers
• Testing Asynchronous Code
• Setting up a Testing Database
• Testing Code with an Active Database
• Cleaning Up
• Hooks
• Testing Code That Requires Authentication
• Wrap up and Mastering Tests

31. Node.js as a Build Tool and Using NPM

• Module Introduction
• NPM and Node.js
• Using NPM
• What is a Build Tool?
• Using Node.js in Build Processes

32. Modern JavaScript and Node.js

• Module Introduction
• What is this Module About?
• Working with ECMAScript Modules (ES Modules) and Node
• More on ECMAScript Modules (ES Modules)
• Node Core Modules and Promises

33. Node.js and TypeScript

• Module Introduction
• TypeScript: What and Why?
• TypeScript Setup
• Assigning Types
• Type Inference and Type Casting
• Configuring TypeScript
• Working with Union Types
• Using Object and Array Types
• Working with Type Aliases and Interfaces
• Understanding Generics
• A First Summary
• Node and TypeScript: Setup
• Getting Started with Node and TypeScript
• Writing TypeScript Express.js Code
• Adding REST Routes with TypeScript
• Finishing the REST Routes
• Testing the API
• Using Type Casting
• Moving to a Better Project Structure
• Wrap Up

34. An Introduction to Deno

• Module Introduction
• What is Deno?
• Why Deno?
• Deno Setup
• Writing First Deno Code
• The Deno Runtime (Namespace) API
• Using the Runtime API
• Working with Deno Permissions
• Repeating the Example with Node
• How Deno Features Are Organized
• Using the Standard Library
• Creating a Webserver
• Using the Oak Framework with Deno
• An Example Node REST API
• Re-building the REST API with Deno
• Should You Switch from Node to Deno?

35. Deno, CRUD and Databases (MongoDB)

• Module Introduction
• App Setup
• Handling CORS Errors
• Connecting Deno to MongoDB
• Using the MongoDB Client Module
• Finishing the Deno MongoDB CRUD Operations
• Wrap Up

36. Roundup

• Course Roundup