NodeJS made easy for MEAN or MERN Stack

Explore how Node.js enables server-side JavaScript, connects frontend frameworks like Angular and React with databases, and powers backend logic with Express.

Explore why big companies rely on Node, and learn how its single-threaded, non-blocking model and npm enable building entire web apps in JavaScript—from front end to back end.

Learn how npm powers node applications by installing and managing modules like express and mongoose, pulling dependencies, and publishing reusable packages to the npm repository for MEAN or MERN stack.

Install node and Visual Studio Code to set up your development environment. Verify versions with node -v and npm -v, then enable the Docker extension for future container work.

Create a simple node application by initializing a new folder as a node package with npm init, configuring package.json fields like name, version, description, and entry point index.js.

Explore the Node.js os module by creating an inbuilt packages project, importing os with require, and printing platform, architecture, total memory, free memory, and CPU information to the console.

Learn to use the Node.js fs module to create files both synchronously and asynchronously, illustrating blocking behavior with writeFileSync and non-blocking execution with a callback. The lecture covers handling errors via an error parameter and shows how the async flow allows subsequent code to run while the file writes.

Learn how to replace separate functions with inline and arrow functions in NodeJS, handle file write errors, and use arrow syntax to simplify file system callbacks.

Learn to read a file with fs.readFile and handle its data via a callback, specify encoding (utf-8 or ascii), and delete files with unlink, including error handling.

Learn to use the inbuilt http module to handle incoming requests and send responses with http.createServer, processing request and response objects, and start a server on a port like 5000.

Learn to create data.json with employee data (id, name, salary) and return it via an http response by reading the file with the fs module in utf-8.

Install nodemon globally and run your app with nodemon to automatically restart on changes. Nodemon watches project files and reloads automatically during development.

Configure and use the npm scripts block in package.json to create key-value command aliases, and run npm run dev with nodemon for hot loading.

Explore how Express is a lightweight, non opinionated web framework for building RESTful APIs with middleware, routing, and body parser integration in Node.

Explore rest principles and http methods that enable create, read, update, and delete operations on resources via uniform interfaces, resource URIs, and formats such as json and xml.

Set up a new node project named crud API, initialize npm, and install express to add it as a dependency, then configure package.json and gitignore for node_modules.

Learn to handle get, post, put, delete methods by returning json data from the /products endpoint, using a static products array and simple callbacks, with Postman for testing.

Learn to use the express router to organize product APIs, create a product router and controller, and mount it in api.js under the product API.

Add a new customer controller and router in Express to expose a restful customer API, returning a JSON array of customers or a single customer.

Install the MongoDB community edition from the download center, choose the current version for your os, install, then start the server with mongod and access the client with mongo.

Mongo shell basics: create and switch databases, create collections by inserting documents, and use commands like show dbs, show collections, and find.

Learn to connect an Express app to a MongoDB database, perform CRUD operations on a products collection using MongoClient and body-parser, and replace static data with dynamic API calls.

Connect to MongoDB by installing the mongodb dependency, importing MongoClient, and establishing a URL-based connection; select the products database and expose a global db object for find, insert, update, delete.

Implement a dynamic rest api method that returns all products from the database using collection.find and converts the results to a json array, with error handling.

Implement a get method to return a single product by id through an express route, converting the id to an object id and querying the product collection with findOne.

Learn how the body-parser package turns json or form URL encoded data into a JavaScript object for Express, via middleware, accessible as request.body.

Create product via a post endpoint by inserting a new document into the products collection using db.collection.insert, with body parser handling JSON data, returning a product created response.

Learn to implement the put method to update a product using db.collection.update with $set, filtering by id, and return the update result to the client via Postman.

Handle the delete operation to remove a single product by id via an HTTP delete request to the same URL, using db.collection.remove, and return the server response.

Discover how Mongoose provides an object document mapping for MongoDB by defining schemas and models, enabling CRUD operations, data types, and validations with JavaScript objects.

Connect to MongoDB using Mongoose by defining a product schema and model to perform CRUD operations, then set up Express with body-parser and add integration tests with Mocha and Chai.

Create a mongoose demo project in a node environment, initialize package.json with npm init, install express, mongoose, and body-parser, and prepare dependencies for a MongoDB-driven app.

Create the server.js file for a NodeJS API using express, instantiate the app, and start listening on port 8000; configure npm scripts for start and dev with nodemon.

Create and configure the product controller and route using express router, export the router, and wire it in server.js with app.use('/product api', productRouter). Verify by visiting localhost:8000/product api.

Connect to a MongoDB database with Mongoose, define a product schema with name and price fields, and create a model that maps to the products collection.

Implement a create product route using router.post and a mongoose schema to model it. Parse json and urlencoded bodies with body-parser, save product, and handle success or error via promises.

Test and flow demonstrate how Postman posts to localhost:8000 product API/products to create a product, while MongoDB and Mongoose auto-create the database and collection via the app.

Implements get routes to retrieve all products or a single product using mongoose find and findById. Utilizes router.get, optional query, and promise syntax (then/catch) for responses.

Implement the put method to update product details by finding one and updating the product by id from the URI and name and price from the request body.

Install and use axios to make asynchronous RESTful calls to a Node and Express backend, enabling front-end apps (Angular, React) to perform get, post, put, and delete operations.

Install and configure axios to build a restful client component, then perform get, post, put, and delete operations using a restful url in React and Angular projects.

Create the rest client for a node project by initializing npm, adding a crud client file, and configuring axios to perform restful API calls.

Make a restful get call in a NodeJS project using axios to retrieve all products. Handle the response with response.data and catch errors with console logs.

Learn to fetch a single product and delete it with axios in a node crud client by using the product id in the url and handling responses.

Mocha and Chai complement each other to write unit and integration tests in JavaScript, using given when then syntax with describe, it, and expect.

Learn to write integration tests with Chai and Mocha, install chai-http, configure a test folder, and run tests with npm run test for get and post product calls.

Install dependencies for integration testing in the mongoose demo: npm i chai chai-http mocha, create a Test folder in VS Code, and add a product controller test js.

Master writing and running mocha and chai tests, using chai-http to test get all products and http 200 responses.

Learn how to handle test failures in Mocha and Chai by returning promises instead of using done, and by asserting the expected versus actual status codes.

Test product creation and retrieval in Node.js by posting JSON product data and fetching all or a single product, using Postman and npm test.

Explore Mocha life-cycle methods, including before, after, before each, and after each, to initialize and clean up resources before and after tests.

Componentize your Node.js project by separating model, dao, controller, and routes for a maintainable mean/mern stack. Learn ES6 imports, babel, and moving configuration and db settings to a source folder.

Break down the product controller into modular components by defining a product schema, exporting the schema for the dao, and implementing CRUD methods on the model.

Move database connectivity into its own component, extract the port to a config properties file, and wire a mongoose MongoDB connection in a dedicated DB module used by server.js.

Discover how Mongoose static methods on schemas let you perform create, find, get, update, and delete operations via a DAO without instantiating objects.

Define the product schema and create the model in a products folder, then implement a product DAO with get, create, update, and delete methods using mongoose.

Develop a refined product controller in nodejs that uses the product DAO to get all, create, update, and delete products, with decoupled routing and clear request handling.

Test the Node project by verifying the server responds, retrieving and posting products via the product API, and confirming routes, controllers, DAO, and model handle requests correctly.

Move all source code into a src folder and all tests into a test folder; place config, products, and server.js under src, created via Angular CLI or React CLI.

Configure babel to enable ES6 syntax by installing core, node, and preset-env, and create a .babelrc with presets; switch from require to import and update npm scripts to babel-node.

Develop a node api for patient clinical data with patient and clinical models, a one-to-many relationship via mongoose references, and rest endpoints for patient crud and clinical data.

Create a new folder named clinical API, initialize npm, and generate a package.json. Install express, mongoose, and body-parser, configure .babelrc with @babel/preset-env, and create a src folder.

Create a Config folder with properties.js and db.js to establish a mongoose database connection, then boot server.js using express and body-parser to listen on the configured port.

Define the patient dao in a new patient dao.js by importing mongoose and the patient schema, and export a patient model with get, create, update, and delete crud functions.

Create and configure routes for a Node.js app by mapping CRUD operations to a patient controller and wiring the route setup into server.js under the clinicals API path.

builds the clinicals dao and controller, configures routes, and handles getting all clinical data for a patient and creating clinical entries via the clinical schema and model using mongoose.

Launch the app, fix route typos, and test APIs with Postman by creating patients and clinical data and validating responses.

Fix bug and test shows how a spelling error in component value mapping in model prevented saving to MongoDB, then re-tests with Postman to verify heart rate and BP retrieved.