Mastering Node.js Web Development

Cover
Copyright Page
Contributors
Table of Contents
Part I - Putting Node.js in Context
Chapter 1: Getting Ready
	What do you need to know?
	How do you set up your development environment?
	Are there lots of examples?
	Where can you get the example code?
	What if you have problems following the examples?
	What if you find an error in the book?
	How do you contact the author?
	What if you really enjoyed this book?
	What if this book has made you angry?
Chapter 2: Working with the Node.js Tools
	Getting ready
		Installing Git
		Selecting a code editor
	Using Node.js
	Understanding the npm tool
		Initializing a project
		Managing packages
			Installing development packages
			Listing packages
			Checking for package security vulnerabilities
		Executing packages
			Using the npx command
		Using script commands
			Defining custom commands
	Summary
Chapter 3: JavaScript and TypeScript Primer
	Preparing for this chapter
	Understanding JavaScript confusion
		Using the JavaScript features to express type expectations
		Using JavaScript to check type expectations
			Using a type union
	Understanding the basic TypeScript/JavaScript features
		Defining variables and constants
		Dealing with unassigned and null values
		Using the JavaScript primitive types
			Working with booleans
			Working with strings
			Using template strings
			Working with numbers
			Working with null and undefined values
		Using the JavaScript operators
			Using conditional statements
			The equality operator vs. the identity operator
			Using the null and nullish coalescing operators
			Using the optional chaining operator
	Defining and using functions
		Defining optional function parameters
		Defining default parameter values
		Defining rest parameters
		Defining functions that return results
		Using functions as arguments to other functions
			Defining functions using the arrow syntax
			Understanding value closure
	Working with arrays
		Reading and modifying the contents of an array
		Enumerating the contents of an array
		Using the spread operator
	Working with objects
		Understanding literal object types
			Defining optional properties in a type annotation
		Defining classes
			Adding methods to a class
			Access controls and simplified constructors
			Using class inheritance
		Checking object types
	Working with JavaScript modules
		Creating and using modules
		Consolidating module contents
	Summary
Chapter 4: Understanding Node.js Concurrency
	Preparing for this chapter
		Creating a simple web application
	Understanding (simplified) server code execution
		Understanding multi-threaded execution
			Understanding blocking and non-blocking operations
		Understanding JavaScript code execution
		Understanding Node.js code execution
	Using the Node.js API
		Handling events
		Working with promises
		Wrapping callbacks and unwrapping promises
	Executing custom code
		Yielding control of the main thread
		Using worker threads
			Writing the worker code
			Creating a worker thread
		Packaging worker threads into a callback
		Packaging worker threads into a promise
	Summary
Chapter 5: Handling HTTP Requests
	Preparing for this chapter
	Listening for HTTP requests
		Understanding the Server configuration object
	Understanding HTTP requests
		Parsing URLs
	Understanding HTTP responses
	Supporting HTTPS requests
		Creating the self-signed certificate
		Handling HTTPS requests
		Detecting HTTPS requests
		Redirecting insecure requests
	Using third-party enhancements
		Using the Express router
		Using the request and response enhancements
		Using Express route parameters
	Summary
Chapter 6: Using Node.js Streams
	Preparing for this chapter
	Understanding streams
	Using Node.js streams
		Writing data to a stream
			Understanding stream enhancements
			Avoiding excessive data buffering
		Reading data from a stream
			Understanding the Readable class
			Reading data with events
			Reading data with an iterator
			Piping data to a writable stream
	Transforming data
		Using object mode
	Using third-party enhancements
		Working with files
			Serving files from client-side packages
			Sending and downloading files
		Automatically decoding and encoding JSON
	Summary
Chapter 7: Using Bundles and Content Security
	Preparing for this chapter
	Packaging client files
		Creating stand-alone bundles
		Using the webpack development server
			Using a different request URL
			Forwarding requests from webpack to the backend server
			Forwarding requests from the backend server to webpack
	Using a content security policy
		Injecting malicious content
		Defining a content security policy
		Using a package to set the policy header
	Summary
Chapter 8: Unit Testing and Debugging
	Preparing for this chapter
	Unit testing Node.js applications
		Writing unit tests
			Arranging a test
			Performing a test
			Asserting test results
		Testing asynchronous code
			Testing promises
		Creating subtests
	Debugging javascript code
		Adding code breakpoints
		Using Visual Studio Code for debugging
		Using the remote Node.js debugger
	Summary
Part II - Node.js in Detail
Chapter 9: Creating the Example Project
	Understanding the project
	Creating the project
		Installing the application packages
		Installing the development tool packages
		Installing the type packages
	Creating the configuration files
	Creating the backend server
	Creating the HTML and client-side JavaScript code
	Running the example application
	Summary
Chapter 10: Using HTML Templates
	Preparing for this chapter
	Using server-side HTML templates
		Creating a simple template engine
			Creating the custom template engine
			Setting up the custom template engine
		Evaluating expressions in templates
		Adding template features
			Mapping expressions to features
		Using templates to create a simple round-trip application
	Using client-side HTML templates
	Using a template package
		Using a package for server-side templates
			Defining the templates
		Using a package for client-side templates
	Summary
Chapter 11: Handling Form Data
	Preparing for this chapter
	Receiving form data
		Receiving form data from GET requests
		Receiving form data from POST requests
			Receiving multipart data
	Sanitizing form data
	Validating form data
		Creating a custom validator
		Applying validation rules
		Validating data
	Performing client-side validation
	Using a package for validation
	Summary
Chapter 12: Using Databases
	Preparing for this chapter
	Using a database
		Installing the database package
		Creating a repository layer
		Implementing the repository
			Querying the database
			Displaying data
		Understanding SQL query parameters
		Writing to the database
	Using an ORM package
		Defining the database using JavaScript objects
			Creating the model classes
			Initializing the data model
			Configuring the model relationships
		Defining the seed data
		Converting data models to flat objects
		Implementing the repository
			Querying for data
			Writing data
			Applying the repository
	Summary
Chapter 13: Using Sessions
	Preparing for this chapter
	Correlating stateless HTTP requests
		Using cookies to correlate requests
			Receiving cookies
			Setting and reading cookies
		Signing cookies
		Using a package to manage cookies
	Using sessions
		Creating the session middleware
		Using the session feature
		Storing session data in a database
	Using a package for sessions
	Summary
Chapter 14: Creating RESTful Web Services
	Preparing for this chapter
		Preparing for a web service
	Understanding web services
	Creating a basic RESTful web service
		Getting data for the web service
		Separating the HTTP code
	Updating data
		Replacing data with PUT requests
		Modifying data with PATCH requests
			Using JSON Patch
	Validating client data
		Creating the validation infrastructure
		Defining validation for the Result API
		Performing model validation
	Using a package for web services
		Creating an adaptor for web services
	Summary
Chapter 15: Authenticating and Authorizing Requests
	Preparing for this chapter
	Understanding the end-to-end process
	Authenticating users
		Creating a credential store
		Creating the authentication workflow
	Authenticating requests
		Using the authentication data
	Authenticating web service requests
		Creating the authentication API
		Authenticating the web service client
	Authorizing requests
		Adding support for roles
		Checking authorization
		Authorizing API requests
	Using packages for authentication and authorization
		Authenticating HTML clients
	Summary
Part III - SportsStore
Chapter 16: SportsStore: A Real Application
	Understanding the project structure
	Creating the project
		Setting up the development tools
		Handling HTTP requests
		Creating a configuration system
		Adding application routes
		Adding support for HTML templates
			Creating layouts and templates
		Creating error handlers
	Starting the data model
		Implementing the repository
			Creating the repository class
		Defining the configuration settings
		Defining the seed data
		Using the catalog data
	Summary
Chapter 17: SportsStore: Navigation and Cart
	Preparing for this chapter
	Navigating the catalog
		Paginating catalog data
			Adding pagination controls
			Changing the page size
		Filtering catalog data
			Adding filtering controls
		Updating the product display
	Creating the shopping cart
		Adding configuration support for secrets
		Creating session middleware
		Defining the cart data model
		Extending the catalog repository
		Creating the HTTP routes and middleware
		Creating the templates
	Creating the cart summary
	Summary
Chapter 18: SportsStore: Orders and Validation
	Preparing for this chapter
	Handling orders
		Creating the data model
		Implementing the model classes
			Creating the order models
		Implementing the repository
	Implementing the order flow
		Validating data
			Defining validation rules
		Creating the HTTP handlers
		Creating the templates and helpers
	Fixing the return URL
	Summary
Chapter 19: SportsStore: Authentication
	Preparing for this chapter
	Understanding the OAuth authentication process
		Understanding the advantages of OAuth
		Understanding the limitations of OAuth
	Creating the Google OAuth credentials
		Publishing the app
			Creating the Client ID and Client Secret
	Getting profile details with OAuth
		Implementing the new repository features
		Setting Up OAuth authentication
		Changing the cookie configuration
		Applying authentication
	Using the OAuth profile data
		Placing a second order
	Summary
Chapter 20: SportsStore: Administration
	Preparing for this chapter
	Understanding HTML RESTful web services
	Preparing for client development
		Creating the routes and templates
		Configuring the application
	Administering the product catalog
		Starting the web service routes
		Displaying product data and deleting products
		Editing products
			Adding product data validation
			Adding the routes for editing
			Creating new products
	Administering orders
	Fixing the URLs
	Restricting access to administration features
	Summary
Chapter 21: SportsStore: Deployment
	Preparing for this chapter
	Installing Docker Desktop
	Managing the database
	Toggling the application environment
	Using a database server
	Creating the SportsStore Docker image
		Preparing the application
		Creating the SportsStore image
	Composing the application and database servers
	Setting up an HTTPS reverse proxy
		Updating the OAuth URLs
		Completing the configuration
	Summary
PacktPage
Other Books You May Enjoy
Index