Node.js and Express REST API with Real World Projects

Explore how web apis work by outlining general principles and the three data patterns: communication, storage, and presentation.

Understand how web APIs use HTTP to handle client requests, fetch data from storage, convert it to JSON or XML, and respond with verbs like GET, POST, PUT, and DELETE.

Explore data storage patterns, distinguishing static and dynamic data, and learn how databases and object-relational mapping enable querying with SQL and ORM tools like Hibernate and Eloquent.

Explore the data presentation pattern for a REST API by understanding how serialization converts data models into standard formats such as JSON, XML, and Excel, and back.

Explore the three core web app patterns—data communication, data storage, and data presentation—and see how they drive how web apps work.

Get set to implement a REST API with Node.js and Express. The section outlines an MVC-based approach, covering models, controllers, storage, and serializers.

Explore the mvc pattern, its three components—model, view, and controller—and how they interact to separate data, presentation, and logic, enabling modular development and testable code.

Implement the mvc pattern in Node.js and Express for a rest api, using a serializer instead of a view, and leverage middleware to process requests and responses.

Build a basic node web api using express by initializing a project with npm, installing express, creating a simple app file, and running with node on the local host.

Learn how Sequelize models map database tables to JavaScript objects in a Node.js and Express app, using attributes and associations to represent data types such as integer, string, and boolean.

Learn how to choose a database and use Sequelize as an object-relational mapper with Node and Express to model data as JavaScript objects and perform safe, complex queries.

Explore how controllers in Node.js and Express handle requests with JavaScript functions, producing responses and performing data fetches and updates.

Learn how serialization works in Node.js and Express, with json as the default response format, and install npm serializers to output csv or xml data for your api.

Explore how urls map to controllers in Node.js and Express, define routes, register them, and handle requests with controller functions to access web API resources.

Explore how to structure a Node.js and Express REST API using the MVC pattern to build scalable, maintainable applications, with models and controllers guiding a real-world project.

Review the mvc pattern and implement it in Node.js with Express for a rest api. Explore working with models, storage, controllers, and serializers in a large-scale rest project.

Outline the nine lectures that guide you through building a Node.js and Express REST API for a note-taking app, covering models, migrations, controllers, Swagger, and testing with UI and Postman.

Set up a real-world Node.js and Express REST API project by creating a template-based app, connecting it to source control, installing packages, and running the server.

Set up the notely api project by creating a big bucket repository, linking it to the local project, and installing sequelize and sequelize cli for a REST API.

Review the Notley rest api requirements by outlining endpoints for creating, listing, retrieving, updating, and deleting notes, and show how the front end consumes these endpoints from a react project.

Create the notes model with id, subject, detail, created, last modified, and is deleted; initialize equalize, and generate models, migrations, and seeds for a node.js rest api.

Create a note model in a Node.js Express REST API using the command line interface, defining subject, detail, and deleted, with automatic id and created and last modified dates.

learn how to create and run database migrations alongside your models, using migration files to map properties to tables and apply changes to the database.

Create the controller file and implement controller functions to handle http requests for notes, including get all notes, create note, get a specific note, and delete note, returning appropriate responses.

Implement the notes controller to fetch all non-deleted notes with findAll and handle create, update, and delete operations using the ORM, returning structured 200 responses.

Map incoming requests to the correct controller functions using an express router, and register routes to define clear url patterns for a rest api.

Create and register the app's router and url patterns by importing middleware, composing functions with the use method, and piping requests through a modular Express app.

Install and configure Swagger in a Node.js and Express REST API, create an API definition file, and register it to generate interactive documentation for testing with Swagger UI and Postman.

Test the Node.js and Express REST API with swagger UI, exercising create, read, update, and delete endpoints for nodes, while debugging migrations and ensuring full node details appear in responses.

Test the rest api for notes using postman, exercising get all, get by id, create, update, and delete operations against the backend database.

Set up the Notley API project, build notes model and migration, and create the API controller. Generate API documentation and test the API with Postman to complete the section.

Explore what JavaScript is and its use in front-end and back-end development, in this crash course, covering variables, statements, expressions, data types, operators, functions, arrays, objects, and promises.

Explore JavaScript expressions and statements, including arithmetic, string, logical, and assignment expressions that return values. Study declaration, comment, conditional, iteration, and function statements with practical examples.

Explore declaring and assigning JavaScript variables, understand global versus local scope, see undefined when uninitialized, and learn two assignment methods with camel case naming.

Explore JavaScript data types, including primitive and non-primitive values, and learn how numbers, booleans, undefined, null, and objects support operations and properties.

Explore the concept of JavaScript operators, covering arithmetic, assignment, comparison, logical, and conditional operators, with real-life examples in a hands-on session.

Master JavaScript functions by declaring and calling them, exploring function name, parameters, and the body. Understand declaration methods—function declaration and function expression—and how parameters and arguments define a function's task.

Explore JavaScript objects, their properties and methods, and create them with object literal or constructor. Access color and size and call methods like inflate.

Explore how JavaScript arrays store multiple values, initialize them with literals or constructors, access elements by index, and use methods like push, pop, join, splice, filter, every, and forEach.

Explore JavaScript promises: create, resolve, reject, and consume them with then and catch, and manage future events like a book delivery through real-world scenarios.

Learn how to define and export JavaScript modules, import them into other files, and organize large-scale applications into maintainable, modular components for reusable features.

Explore JavaScript fundamentals from statements and expressions to variables, data types, operators, functions, objects, arrays, and modules, plus promises and zero-based indexing.

Gain a big-picture view of the building materials business and its e-commerce application, and learn the four-step path: understand, define, specify, and create.

Navigate the building materials business by examining B2C and B2B models and hybrid operations, then map core components like inventory management, accounting, logistics, and customer service to your app.

Define the problem by examining Building Materials Incorporated's need for a backend REST API to digitalize records and support online sales across web, mobile, and desktop platforms.

Define design criteria for software projects by detailing architecture, rest API, scalability, maintainability, reliability, and availability, while mapping business analysis to software requirements.

Design the solution from the design criteria, map it to a software requirements specification using the MVC pattern and a robust REST API, and host on Azure or Google Cloud.

We covered four lectures in this section, including understanding the building material business, fighting the problem, the design criteria, and creating the solution.

Review the requirements and set up the project for the Node.js and Express REST API, covering product catalogue, cart, checkout, customer registration, customer authentication, payment, and building material administration specifications.

Explore the product catalog api specification, detailing endpoints to save a new product, retrieve by id, modify, and fetch products by filter parameters across product, brand, and category catalogs.

Explore the Node.js and Express rest api shopping cart specifications, including endpoints to add items, remove items, view the current cart, and checkout in an e-commerce workflow.

Explore the checkout API specification for the cart, and understand the endpoint that enables users to check out items, pay, and finalize purchases.

Register and manage customer credentials through an API, generating usernames and passwords, and securely store addresses and payment details with password reset capabilities.

Explore customer authentication specifications, including sign up with email and password, login and logout, and password reset, and distinguish authentication from authorization in the custom authentication APIs.

Explore BMES administration specifications for building a Node.js and Express REST API to register products, brands, and categories; manage inventory, orders, and users; and enable customer service workflows.

Set up a Node.js Express REST API project in Visual Studio, run and test it, install required packages, and connect to a Bitbucket source control repository.

Install four key npm packages—sequelize, sequelize-cli, a database package, and a swagger documentation package—using the command-line interface, then create a code repository in big bucket and finalize the project setup.

Explore eight lecture topics covering product catalog specification, Supreme Court API specification, customer registration and authentication specifications, payment system specifications, business administration specifications, and setting up the business project.

Implement the product catalog across admin and customer sites, enabling create and delete operations for products, categories, and brands, including a linking model, migrations, services, and API tests.

Structure a large Node.js and Express app by organizing folders, configuring an ORM, migrations, and seeds, focusing on the catalog path, Swagger setup, and environment changes for SQLite.

Create the product catalog models—product, category, and brand—and their linking models, define one-to-many relationships, and prepare migrations for database setup in a rest api project.

Execute database migrations to align product catalogue models, update brand, category, and product statuses with defaults, and establish many-to-many relations via linking tables, then verify tables in the database.

Build catalog services in a Node.js and Express REST API by implementing brand, category, and product services with create, get, update, and soft delete using isDeleted.

Develop category and product catalogue services by creating category and product models, and wiring associations between brand, category, product, and product brand to support create, fetch, update, and delete operations.

Learn to implement the fetch products function in a Node.js and Express REST API, handling category and brand filters, pagination, and non-deleted products with include relations.

Create, edit, retrieve, and soft-delete products using a comprehensive product service, with automatic id assignment, default migration values, and the isDeleted flag filtering; these operations are wired through the controller.

Implement product catalog controllers in a Node.js and Express REST API, wiring product, brand, and category controllers to services, with pagination and promise-based error handling.

Create, retrieve, edit, and delete products via the product service with promise handling and response composition, and apply the same pattern to brand and category controllers.

Map the product catalog routes in Express by creating brand, category, and product endpoints and wiring them to their controller functions, using a shared register to compose URL patterns.

Learn to generate API documentation with Swagger in a Node.js Express REST API by installing Swagger, registering it with a defined API document, and viewing the docs endpoint.

Learn to generate API documentation using Swagger while building and wiring product, brand, and category controllers in a Node.js and Express REST API, including create, get, edit, and delete operations.

Test product, brand, and category endpoints using Postman, verify backend responses with empty brand and category lists, and outline future data loading and pagination tests.

build the product catalog in a node.js and express rest api by modeling product category and brand, executing database migrations, then test endpoints with postman and generate swagger documentation.

Administer the application and learn to load product category and brand data into the database using CSV files to populate the product catalog tables for real world projects.

Load and link brand, category, and product data into a real-world Node.js and Express REST API, import scripts, and test data retrieval with pagination and filters.

We loaded data into the database, ran the API again, and tested it with postmarks to confirm everything works.

Implement shopping cart functionalities for the Node.js and Express REST API, covering cart modules, database migrations for cart models, service, controllers, routes, and URL patterns, with Postman testing.

Structure the shopping cart section in the REST API of the project, implementing cart functionalities and performing housekeeping tasks in the models to ensure everything works.

Create robust shopping cart models in a Node.js and Express REST API by defining the cart and cart-item models, establishing a one-to-many relationship, and setting up migrations with product associations.

Execute and verify database migrations for shopping cart models by running the migration command and confirming carts and cart items tables are created.

Learn how to implement a cart service in a Node.js and Express REST API, including get cart, add item, and remove item functions, with session-based tracking.

Implement a cart service with add, remove, and get all cart items, including product details, and compute the total item count and price for checkout.

Implement the cart controller by wiring get cart, add to cart, and remove from cart functions to the cart service, with promise-based responses and error handling.

Implement the cart router in express with get, post, and delete routes using a cart controller, and register it under the cart path following the URL patterns.

Test the cart endpoints with postman by running the app, debugging issues like undefined values, and iteratively adding and removing items to the cart.

Cover seven lectures that build the shopping cart feature, including modeling carts, migrating cart models, implementing the cart service, controller, and routes, and testing the endpoint with Postman.