Node.js and Beyond: The Complete Developer Bootcamp

Explore core modules that come pre-installed with Node.js, providing file system operations, networking, and other foundational tools to streamline web development.

Explore the node.js file system module (fs) for creating, writing, reading, and deleting files with callbacks, using writeFile, readFile, and unlink, and learn encoding and error handling.

Explore the Node.js path module, learn to join path segments, generate absolute and relative paths, extract base names and directory names, and parse paths across operating systems, including Windows.

Create and export custom modules in Node.js to log messages to app.log using default and named exports. Import the logger across files and use a config object with fs.appendFile asynchronously.

Explore npm, the node package manager, and learn to initialize a Node.js project with npm init, create a package.json, set the entry point (app.js), manage scripts, and run tests.

Install and use external modules from the npm registry, including colors and moment for date formatting, in Node.js projects. Manage dependencies with package.json and node_modules, and require packages.

Download the provided project, install dependencies with npm install to populate node_modules and run the app. Manage versions by uninstalling and reinstalling colors and moment and checking with npm outdated.

Learn how to distinguish dependencies from dev dependencies in Node.js, manage them with package.json, and install production-only packages using npm install, --production, or --omit=dev.

Define npm scripts in package.json to automate tasks such as testing and starting the app. Use nodemon for automatic restarts in development and manage commands with start and start-dev scripts.

Learn how callbacks work in JavaScript by passing a function to another function. Simulate asynchronous data fetch with setTimeout and continue execution when the callback runs.

Learn to use promises to handle asynchronous operations in JavaScript. Create promise instances with the promise constructor, use resolve and reject, chain then calls, and handle errors with catch.

Learn to use async/await to handle promises more cleanly. Apply an async function and await to pause execution until a promise resolves, with try/catch for errors during data fetch.

Explore how the web works with a client-server model, HTTP, and REST, and see how APIs connect Node.js tools. Learn endpoints, methods, and data formats for building APIs.

Set up a new node project, install nodemon, and build a simple http server with the core http module listening on port 3000 and responding with hello NodeJS Http server.

Explore how http headers drive client-server communication by configuring response and request headers, setting content-type, and using status codes to shape browser behavior.

Learn to handle http get requests in a node server by listening for request events, checking req.method, and returning a hello message or a 405 error.

Learn to return json responses and create routes that serve a products array as json, handling get requests to /products and 404 not found errors.

Handle post requests by serving an html form at the root to add new products, create a product object from form data, and push it into products array at /products.

Parse urlencoded post data from the request body to create a new product using a promise-based parse function. Return the updated products array to the client.

Learn to implement middlewares in a Node.js API, using prepend listener to inspect requests and share data via the rack object, while handling errors with 400 status.

Explore Express.js, a robust Node.js framework that simplifies building APIs and web apps with routing, middleware, and streamlined HTTP requests.

Install express as a dependency, create an express app, define routes and middleware, and start the server on port 3000 to build a readable Node.js API.

Learn to use Express app.use middlewares to intercept every request, access req and res, and pass control with next to build scalable APIs.

Explore how Express middlewares sit between requests and responses, using next to pass control, how app.use defines their order, and how the Rest object's send method returns a response.

Explore how Express.js uses middleware and routes to handle HTTP methods and URLs, filter requests, and parse JSON bodies, with post and get examples in a shopping API.

Learn to parse incoming request bodies in Express using json and urlencoded middleware, handling both json and HTML form data before your route handlers.

Learn to structure express routes by creating admin.js and shop.js, export routers with module.exports, and attach them in index.js via app.use on the Express router.

Learn to filter express route paths with admin and shop prefixes to differentiate routes, prevent unauthorized access, and improve maintainability of your Node.js API.

Create a product model as a class with a constructor for name, price, and id, and implement async save method that writes to a json database using fs and path.

Create a new product via the product model using name and price from the request, save it to the fake database, and respond in json with proper http status codes.

Retrieve all products from the database by using a static findAll method, read the product db with fs readFileSync, parse JSON, and return the products at /products.

Learn to implement robust error handling in an Express API using promises and async/await, convert routes to controllers, and safely return 500 errors with meaningful messages.

Implement a static async delete one method on the product model to remove a product by id from the fake database, using fs readFile, filter, and writeFile with JSON.stringify.

Implement a delete one route in express.js using url params to obtain id, convert it to a number, handle errors with try/catch, and return the result with 200 status.

Build a blog post API with Node.js and Express.js, adding posts, comments, image uploads, pagination, security, and an ebook marketplace to explore data management and databases.

Explore how databases organize, store, and retrieve data for web apps. Compare relational SQL databases with NoSQL document stores like MongoDB, using JSON-like documents and keys to manage data efficiently.

Set up a MongoDB atlas cloud database, create a free cluster on EOS AWS, configure a database user and network access, and obtain the MongoDB Uri for a NodeJS app.

Compare mongoose with the MongoDB driver to choose the right tool for your node app, as mongoose offers a higher level ODM with schema, middleware, validation, and simplified queries.

Connect a Node.js app to MongoDB with mongoose, install and require it, configure the Uri and password, and verify the connection via npm run dev.

Define a post model with a mongoose schema by specifying title, body, and excerpt as required strings. Export the model to enable posts collection usage in MongoDB.

Develop the create route for blog posts using the post model, implement CRUD create logic, structure code in a separate file, and handle validation with async save and error responses.

Implement and test the create post route in index.js using app.use for post endpoints, then test API with postman on localhost:3000 and verify _id and __v in MongoDB Atlas database.

Create an Express GET route to retrieve all blog posts from the database using Post.find({}). Return the posts as JSON and handle errors with a 500 status.

Define a get one route in the read module to fetch a single blog post by id, using url params and mongoose findById, with error handling and correct route ordering.

Fix catch block errors by returning after sending a response to prevent 'headers already sent' in Express, and ensure MongoDB queries use ObjectId across all routes.

update a blog post by id using an express router and mongoose post model, validating title, content, and excerpt, and returning the updated document with new: true.

Create an Express delete route to remove a blog post by id using find one and delete, validate the param, handle errors, and verify by fetching all posts.

Implement a single error handler middleware with app.use, placed after routes, to centralize internal and custom errors with status properties, and add a 404 not found route.

Learn how to enable automatic created and updated timestamps in MongoDB documents with Mongoose, customize their field names, and verify results via a post route test.

Build the comment model with mongoose, including a required content string and timestamps, export the model, and establish its relation to the post document to enable database relations.

Explore database relations that link data across tables or MongoDB collections, covering 1-to-1, 1-to-many, and many-to-many structures for powerful queries.

Implement a one-to-many relationship by using id references in mongoose, adding a required post property of type mongoose.ObjectId and an href to link Comment to the Post model.

Learn to implement a comment feature by wiring create, read, update, and delete routes under /comment, linking comments to posts with mongoose and express, and implementing error handling.

Fetches all comments for a specific blog post by using a get route, querying the comment collection by the post ID, and returning the results as a comments array.

Define a get route to fetch a comment by id with express and mongoose, using findById and populate to include the related post, and handle errors for missing ids.

Update a comment via a post to /update/:commentId, validating the id and updating content using the comment model; return the updated document with new: true.

Implement a delete route to remove a comment by id, return a 400 error if missing, perform find by id and delete, and respond with a { success: true }.

Learn to implement authentication in a Node.js API by verifying user identities, securing applications, and building a user model with routes for creating users and validating credentials.

Build a robust user model with Mongoose by defining username, email, and password fields, enabling user registration, login, and timestamped records.

Create a signup route with express to store new users in the database. Validate required fields, save the user document, and return the user data for frontend use.

Create a sign-in route using post at /sign in, extracting email and password to authenticate the user and return 400, 401, or 200 with error handling.

Explore how tokens authenticate users and protect routes from non-authenticated access, using jwt (json web tokens) and other token types to authorize access in modern APIs.

Master JWT authentication in a node API by generating tokens at sign-in, sending them to clients, decoding and verifying tokens, and validating expiration with a secret key to protect resources.

Create a jwt auth middleware that decodes and verifies the bearer token from the authorization header using a secret key, then attaches the current user to the request.

Refactor the current user middleware in index.js to allow read post root and read comment root publicly, then test with postman using a JWT bearer token.

Hashing passwords with bcrypt and salt rounds strengthens sign up security by storing a hashed password and comparing hashes at login.

illustrates password hashing at signup, stores a hash, and validates sign-in by hashing the entered password and comparing it with the stored hash using bcrypt, ultimately issuing a jwt token.

Move password hashing to a Mongoose pre save hook, use this.isModified and isNew checks, bcrypt, and return a JWT token on signup instead of the hashed password.

Learn to implement authorization in an API by linking posts and comments to the user model. Ensure only the owner can modify or delete their posts using JWT authentication.

Establish a database relation by adding a required user reference to the post and comment schemas, linking each document to its author via the current user id.

Authorize post operations by verifying post existence and ownership, then delete or update using post id and current user, returning not found or not authorized as needed.

Implement authorization for delete and update comment routes by verifying document existence, filtering by id and user, handling 404 and unauthorized errors, and validating operations in MongoDB.

Explore cookie sessions to manage user sessions with HTTP cookies and client-stored tokens. Automatically attach the JWT token as a cookie to requests, removing manual bearer token setup.

Install the cookie-session package and apply its middleware after json and urlencoded to enable cookie-based sessions in the API, using signed: false, secure: false, and trust proxy for postman.

Learn how to store JWT tokens in cookie sessions to streamline sign in and sign up, attach tokens to request sessions, and test authenticated requests without manually copying tokens.

Create a signout route in the auth module using express. Remove the jwt from the request session and respond with a success object at /auth/signout.

Explore the importance of validating user data to prevent malicious input and ensure data integrity, while recognizing server side as primary defense and client side as a user experience aid.

Learn to implement data validation in an Express API using Express Validator, validate the email in the request body for signup route, and return errors before saving to the database.

Send a proper error response in the sign up route by using express validator's withMessage to attach a custom invalid email message to the MSG field.

Create a custom validator in express-validator by chaining check with withMessage and a custom function that forbids the email value test@test.com, returning true when valid and throwing an error otherwise.

Explore building robust validators for passwords and usernames, including length checks with min 6 and max 15, alphanumeric rules, and custom error messages, while organizing validators into a reusable array.

Learn to prevent duplicate signups by implementing an asynchronous validator with mongoose findOne method to check emails, using await in the callback and throwing an error when a match exists.

Validate the create post route using express-validator to ensure title, content, and excerpt are not empty, with clear error messages, boosting API reliability and user experience.

Master advanced error handling in Node.js by classifying errors into bad requests, not found, and authentication issues, and centralize the logic in a module for a dry, maintainable codebase.

Organize advanced error handling by creating an errors hub and abstract custom order template class, then implement a custom error class with guarded instantiation and a generate errors method.

Extend the custom error abstract class to create a not found error with a 404 status and a logging message, and implement a generate errors method returning an errors array.

Create a not authorized error class extending the custom error, set status 401, and return a not authorized message. Use it in middleware and routes to replace unauthorized errors.

Update the not found error class to accept a custom message in the constructor, enabling dynamic messages for not found errors like document not found or user not found.

Create a bad request error class extending the custom error with a 400 status and customizable message, used in sign-in, and plan to return all validation errors as an array.

Create a request validation error class that extends custom error and returns 400 with the express validator errors array, converting to { message, field } for signup and post routes.

Create a reusable middleware that uses validationResult from express-validator to centralize error handling, apply it after validators in signup and post routes, and test with postman for empty fields.

Implement a current user route that returns the authenticated user, using the current user middleware to extract the JWT payload and exclude the password from the response.