Node.js, Express, MongoDB & More: The Complete Bootcamp

Kick off the Node.js bootcamp by writing Node.js code quickly, using core modules to build a small, fun project, with later sections exploring deeper concepts.

Discover what Node.js is, a JavaScript runtime built on the V8 engine for server-side use. Explore its event-driven, non-blocking I/O model for fast, scalable APIs and back-end apps with MongoDB.

Learn to run JavaScript outside the browser by using Node.js in the terminal, start the Node REPL, and explore ES6 syntax, Node modules, and handy REPL shortcuts in VS Code.

Learn to run your first Node.js script, require core modules like fs, and explore Node.js documentation to read files from disk using read file sync in future lessons.

Learn to read from input.txt and write to output.txt in node.js using the fs module, with readFileSync and writeFileSync, utf8 encoding, and template strings.

Create a simple web server in Node.js using the http module's createServer, handling requests and sending responses with res.end, and listen on port 8000.

Create a custom node module by exporting a function with module.exports in modules/replaceTemplate.js, then import it in index.js with require, demonstrating that Node.js treats each file as a module.

Learn to distinguish regular dependencies and development dependencies, install them locally or globally with npm, use npm scripts, and see how nodemon and slugify populate package.json and enable global tools.

Learn how to require third-party modules from the npm registry, install and use slugify to generate url slugs, and integrate a new package as a project dependency.

Master semantic versioning in npm, including major, minor, and patch changes and their backward compatibility. Learn to update, install, and uninstall packages, and share code with package.json and package-lock.json.

Review the section's progress by recalling file operations, module imports, and building a web server with routing and templating; look ahead to backend theory, Node.js internals, and Express next.

Explore front-end and back-end distinctions in web development and the client-server workflow. See how HTML, CSS, and JavaScript power the front end, while Node.js and MongoDB drive the back end.

Clarify static versus dynamic websites and API-powered sites, contrast server-side rendering with client-side rendering, and show how Node.js powers APIs delivering JSON data across clients.

Explore how Node.js works behind the scenes, covering architecture, event loop, streams, and modules. Apply theory with code to gain a competitive edge as a Node developer.

Explore Node architecture by examining core dependencies such as the V8 engine and libuv, and how C++ and JavaScript enable the event loop and thread pool for server-side code.

Explore how Node runs on a single thread and how the libuv provided thread pool offloads heavy tasks—files, cryptography, compression, and DNS lookups—keeping the event loop responsive.

The event loop is the heart of the Node.js architecture, orchestrating callback-driven work and offloading tasks to the thread pool. It manages timers, I/O, and microtask queues to prevent blocking.

Explore the event loop in practice by coding setTimeout, setImmediate, and file I/O to observe execution order, process.nextTick, microtasks, and thread-pool effects.

Explore Node.js event-driven architecture with event emitters and listeners, using the HTTP module to handle requests, and apply the observer pattern for decoupled, multi-listener reactions.

Explore how streams process data in chunks to improve memory and speed, covering readable, writable, duplex, and transform streams, with practical piping and event handling in Node.js.

Explore how Node.js resolves and loads modules using core, developer, and npm modules, and how require wraps, exports, and caches module code.

Explore how Node.js wraps module code in a wrapper function, export and import patterns using module.exports and exports, and how caching affects repeated requires.

Explore how excessive callbacks lead to callback hell in Node.js, illustrated by nested readfile and http requests. Learn how promises and async/await improve readability and maintainability.

Learn to escape callback hell by using promises with the super agent library get method. Understand pending, fulfilled, and rejected states, and master then and catch for clean, chained code.

Learn how to promisify read file and write file, return promises, and chain then and catch to manage async flow with ES6 promises.

Explore how async functions return promises, how to retrieve their values with await or then, and improve error handling using try/catch and IIFE patterns in Node.js.

Learn to run multiple promises in parallel with Promise.all to fetch three random dog images, map responses to messages, and assemble a final output.

Start building your API with Express in Node.js, the popular framework that speeds development and simplifies writing Node.js code for your complete bootcamp project.

Explore Express, a minimal node.js framework built on top of node.js, offering complex routing, request and response handling, middleware, server-side rendering, and MVC-friendly structure to speed up node.js development.

Install Postman to test APIs and explore http methods like get, post, put, and patch. Save requests, create collections, run tests, and manage environments for api development.

Set up express and create a simple server to learn basic routing for the natours project, using app.get and post, with json responses and rest-style api testing.

Learn RESTful API design by structuring resources, using resource-based URLs, and applying HTTP methods (GET, POST, PUT, PATCH, DELETE) for CRUD, with JSON and JSEND, in stateless APIs.

Start building the API by creating a GET endpoint for tours, reading data from a json file, and returning a JSend-formatted response with data and results.

Implement a post route with express.json middleware to parse req.body, create a new id from last tour via Object.assign, merge it with body, and save to json file with 201.

Learn how to define route parameters in Express URLs, read them with req.params, and return a single tour by id or a 404 error when the id is invalid.

Explore handling patch requests in an Express app to update only changed fields via api/v1/tours/:id, compare patch with put, and return appropriate 200, 404 responses.

install and configure morgan, a popular logging middleware, to log request data in the console using the dev preset, and add it as the first middleware in express.

Learn to create and mount multiple express routers, separating routes and handlers into resource-specific files, and attach tour and user routers as middleware.

Refactor your Node.js app by modularizing routers and controllers, embrace the model-view-controller pattern, and wire routers via app.js, then start the server with server.js and npm start.

Explore param middleware that runs for a specific url parameter, add a checkID middleware to validate ids, and streamline routes by placing validation in the Express middleware stack.

Chain multiple middleware functions for a route by adding a checkBody middleware before createTour to validate name and price; return 400 bad request if missing, otherwise proceed to createTour.

Learn to serve static files with express using the express.static middleware and a public folder, enabling access to overview.html, images, css, and javascript via the browser.

Explore how environment variables define development and production contexts, configure via .env and dotenv, and control behavior such as login, debugging, and database selection in node.js and express apps.

Learn to set up eslint and prettier in VS Code to improve code quality, integrate the Airbnb style guide, and configure plugins and rules for Node.js and Express.

Explore MongoDB, a NoSQL document database that offers scalability and flexibility, storing data in collections of JSON-like documents with embedded data and de-normalization, contrasting with relational databases.

Install MongoDB on macOS by downloading and extracting the community server, copying binaries to /usr/local/bin, starting mongod, and connecting with the mongo shell, noting Atlas cloud options.

Learn how to install MongoDB on Windows, including the MongoDB Community Server. Install MongoDB Compass, create data and db directories, run mongod, and add MongoDB to the system path.

Create your first local MongoDB database with the Mongo Shell, switch databases with use, and insert documents into a tours collection using insertOne or insertMany.

Learn how to create multiple MongoDB documents with insertMany, adding fields like name, price, rating, and optional difficulty, and verify with find in the tours collection.

Update documents in MongoDB using updateOne and updateMany by applying a filter and the $set operator to adjust fields like price and add a premium flag.

Learn how to delete documents in MongoDB using deleteOne and deleteMany, including deleting by a rating condition and the need for backups before deleting all documents with an empty query.

Connect a remote Atlas cluster to Compass and the Mongo shell, whitelisting your IP and creating a user, then verify natours and tours with the connection string.

Connect a MongoDB database with our application using Mongoose, enabling real data from a real database. We'll explore data models, API features, data validation, and the advanced aggregation pipeline.

Mongoose provides schemas, validation, a simple query API, and middleware as an object data modeling library for MongoDB and Node.js, simplifying data modeling and document operations.

Create a simple Mongoose schema and model to manage tour documents, including required name and price, default rating, and basic schema type options for validation.

Explore the model-view-controller architecture with model, view, and controller layers, distinguish business logic from application logic, and learn how routers, controllers, and models create modular, scalable back-end applications.

Learn to read documents with Mongoose by fetching all tours with find and fetching a single tour with findById via req.params.id, using async/await and try/catch for error handling.

Update documents with mongoose by finding by id and applying changes from the request body via a patch update, returning the updated document with new: true and runValidators: true.

Delete documents using findByIdAndDelete in a RESTful API, returning a 204 no-content status, and practice this CRUD operation alongside update in Node.js, Express, and MongoDB.

Create a standalone Node.js script to import tour data from a JSON file into MongoDB using mongoose, and support command-line options to import or delete data, exiting cleanly.

Implement advanced filtering by supporting greater than, greater or equal than, less than, and less or equal than operators, converting them to MongoDB dollar operators for precise filtering.

Learn to implement api sorting by price, ascending or descending, using the query string and Mongoose, with multi-field support (price, ratings average) and a default sort by created at descending.

Limit API payloads with field limiting and projection; specify fields via a fields query (name, duration, difficulty, price) and use minus to exclude others; hide sensitive data in schema.

Implement pagination in your API with page and limit, compute skip as page minus one times limit, apply Mongoose skip and limit, and validate with countDocuments to handle unavailable pages.

Refactor API features into a reusable APIFeatures class to clean up code and enable modular, chainable operations (filter, sort, limit, paginate). Move to a utilities module for cross-resource reuse.

Explore the MongoDB aggregation pipeline, a multi-stage framework to transform documents through match and group stages to compute ratings average, average price, min and max prices across tours.

Master the aggregation pipeline to unwind start dates, group by month, project results, and build a get monthly plan function to identify the busiest month of a year.

Define Mongoose virtual properties to derive fields like duration weeks from days on the tour schema, using a getter. Enable virtuals in JSON outputs; they are not persisted or queryable.

Learn document middleware in mongoose, a pre and post hook around save and create, including slug generation, with limits like not triggering on insertMany or findByIdAndUpdate, and query middleware.

Learn aggregation middleware in Node.js with MongoDB, using the aggregate hook to modify the pipeline by unshifting a match stage that excludes secretTour true, ensuring only non-secret tours are aggregated.

Learn to debug Node.js with the ndb tool, install and run it, set breakpoints, inspect variables, and fix issues in an Express app.

Explore the distinction between operational and programming errors in Express, and implement a global error handling middleware to centralize error responses.

Implement a global error handling middleware in Express with an error-first function of four arguments. Read error status and message, default to 500, and centralize responses for 404 errors.

Refactor async error handling by introducing a catchAsync wrapper that returns a function accepting (req, res, next), removing per-function try-catch blocks, and routing errors to global middleware.

Distinguish development vs production error handling in a node app by exposing detailed errors in development and sending safe messages in production, using operational errors and a centralized error controller.

Learn to turn Mongoose errors into operational ones by handling CastError, duplicate key, and ValidationError, creating friendly AppError messages and producing meaningful 400 responses in production.

Handle duplicate field errors in MongoDB by matching error code 11000, extracting the conflicting value with a regular expression, and responding with a clear 400 bad request via AppError.

Learn to handle Mongoose validation errors by extracting multiple field messages from error.errors, building a combined, user-friendly message, and returning a robust operational error in production.

Explore handling unhandled promise rejections outside express by using process.on('unhandledRejection') to log errors and shut down gracefully with server.close.

Discover how to catch uncaught exceptions in Node apps using the uncaughtException handler, log the full error, crash safely, and prepare automatic restarts for production.

Learn to implement authentication and authorization with JSON web tokens to protect access to app features. Build secure API interactions by verifying users as they sign up and log in.

Model a user with mongoose for authentication and authorization, including name, email, photo, password, and passwordConfirm, with email validation, uniqueness, and lowercase normalization, then export the user model.

Create new users via an auth-focused signup controller that uses the User model to create and return the user, with a post /signup route and catchAsync-based async error handling.

Explore how json web tokens enable stateless authentication for restful APIs by issuing a token at login, storing it on the client, and using it to access protected resources.

Implement a real signup with automatic login by signing and verifying json web tokens using a secret, restricting signup data to name, email, and password, and enforcing token expiration.

protect tour routes by adding a protect middleware that reads a bearer token from the authorization header, validates it, and allows access to getAllTours only for logged-in users.

Learn to send password reset emails using nodemailer by building a mail transporter, configuring options, and handling errors with async/await while testing with mailtrap.

Master the password reset flow: validate the reset token, set the new password with validators, clear reset fields, and issue a JWT while updating passwordChangedAt.

Update the currently authenticated user's data with the updateMe route, enforcing password update restrictions and using findByIdAndUpdate with a filtered body containing only name and email, protected by token-based authentication.

Learn to delete the current user by marking the user as inactive with an active boolean, using deleteMe to set active to false and return a 204 response.

Apply bcrypt-based password protection, use http-only cookies for jwt tokens, implement rate limiting and denial-of-service defenses, sanitize inputs, set secure headers, enforce https, and adopt mongoose-based NoSQL injection defenses.

Implement a rate limiting middleware with express-rate-limit to cap IP requests at 100 per hour for /api route, preventing denial of service and brute force attacks, exposing RateLimit-Limit and RateLimit-Remaining.

Learn to prevent parameter pollution in a Node.js, Express API by using the HPP middleware to eliminate duplicate query parameters, with examples on sorting and whitelisting.