Build fullstack app with Node.Js, Loopback4, React and Hooks

Learn to use npm as the node package manager to install external libraries, configure scripts and dependencies in package.json, and run and debug a Node.js app.

Install external dependencies such as Lodish, learn to require and load packages, explore dev dependencies with -D and an auto reloader for automatic restarts, and optimize production deployment.

learn how to manage project dependencies with npm, specify scripts and exact package versions in package.json, and exclude node_modules with .gitignore for efficient installs.

Explain semantic versioning with major, minor, and patch releases, showing how breaking changes affect backward compatibility, and how new functionalities, bug fixes, and API stability are reflected in versions.

Explore semantic versioning and use npm list to inspect the dependency tree, identify lodash version 4.17.20, and view package details with npm view, including dependencies and available versions.

Upgrade local packages by installing Lodish and a utility package, then use npm update and npm check updates to manage versions, including global installs when needed.

Publish your own npm module by creating an account, logging in, and publishing your package to the npm registry. Install and use your library in other node projects.

See how to upgrade an existing module by adding a new method and feature, manage a minor release, and publish a new version without overwriting earlier versions (for example 1.1.0).

Switch from a basic node server to the express framework for building web applications, avoiding boilerplate code. The next video will start teaching express.js.

Discover how REST API enables communication with web services using HTTP methods like GET, POST, PUT, and DELETE to fetch, create, update, or delete data via endpoints.

Create a web server with express by initializing a node project, installing express, and defining routes. Run on port 3000 and expose endpoints to fetch and manage products.

Learn the best practice for configuring the port with environment variables instead of hardcoding. Use process.env.PORT, set a default if empty, and verify the app runs on 4000.

Explore route parameters and query handling in a fullstack Node.js app, showing how to define endpoints like /api/products, access id from request, and use response to return dynamic results.

Implement a get API endpoint to fetch a product by id, return the product or a 404 not found response, and test all products with Postman.

Implement a post /api/product endpoint to create a new product, validate the name property, and push the product to the list, then return the newly created product in the response.

Develop a delete endpoint by locating a product by index, deleting it, and returning a confirmation message; verify behavior with valid and non-existent ids.

Implement the update endpoint with the put method to update a product by id, optionally update only the name, return 404 if not found, and return the updated record.

Discover the basics of TypeScript, a typed superset of JavaScript that compiles to plain JavaScript, and learn to define types, interfaces, and classes for robust web apps.

Explore the TypeScript type system, learn how values map to built-in types like string, boolean, null, undefined, and any, and define custom types such as arrays, classes, and interfaces.

Explore variables and constants in TypeScript, and define types for strings, numbers, and booleans. Master arrays, tuples, enums, unknown, never, null and undefined, objects, void, and basic functions.

Learn TypeScript operators, including arithmetic, logical, relational, assignment, primary, string and type operators, then explore decision making with if and switch, plus for, while and do-while loops with factorial examples.

Master the basics of functions for building fullstack apps, including defining, calling, and returning values, with parameters, default values, rest parameters, and both anonymous and arrow function styles.

Explore how interfaces define contracts for objects and functions, including properties, methods, union types, and optional members, with implementations left to classes.

Explore TypeScript classes as blueprints for objects, covering constructors, this, instantiation, methods, inheritance, static members, encapsulation with public/private/protected, and interface implementation.

Learn how to modularize an application by splitting code into modules, using export and import keywords, and sharing classes, calculator interface, and circle components across files.

Explore generics in TypeScript to build reusable components with well-defined APIs. Create generic identity functions, set type parameters like T, and apply string, boolean, object, and interface types.

Delve into generics in depth by building a generic class and interface, defining type parameters, constraints, and multi-type methods to enforce type safety in TypeScript.

Explore generics, a code concept that lets components work with multiple types. Learn to specify type parameters in functions, interfaces, and classes, with examples like an identity function.

Install TypeScript globally in the terminal, create a hello world class, compile with tsc to JavaScript, and configure package.json scripts to run the app that prints 'Welcome to TypeScript'.

Create and use a generic function named logger that accepts any type parameter and returns that type, demonstrating how to call it with string, number, and other types in TypeScript.

Explore a generic function with type parameter T that accepts arrays of strings, numbers, and booleans and returns an array of T, with calls with or without a number.

Explore generic functions with multiple type variables, defining a two-type function for id and name, logging their data types, and compare with a single-type generic function.

Explore generic constraints to restrict the type parameters in functions, such as a logger that accepts only a customer type and enforces first and last name properties.

Define interfaces to describe object properties as a code contract, distinct from classes that act as blueprints, and learn generic interfaces with type parameters enforce structure among objects in TypeScript.

Create an interface to describe a generic function checker that validates an array item by index and returns a boolean, leveraging generic types and indexable interfaces.

Explore generic classes and interfaces by implementing a generic class with a zero value of type T and an add function, and a generic collection interface with add and remove.

Learn how decorators work as runtime functions, build a log decorator with target, key and descriptor, apply it to a method, and preview class, property, and constructor decorators in loopback.

Learn to use arguments inside a method decorator to intercept and modify a method's behavior. Access the descriptor, call the original method with apply, and log results for debugging.

Learn how to configure decorators with a decorator factory in a loop back project, passing arguments like title to customize the decorated function and access variables.

Explore property decorators in a model class to automate getters and setters for multiple properties, redefined on a person class, using a factory function to enable reusable, configurable attribute logic.

Explore the parameter decorator in a LoopBack 4 project, showing how to apply decorators to constructor parameters and properties, including request body decorator, with emphasis on target, key, and index.

Create and apply a class decorator for a model in the Lubeck project, mirroring the ad model. The decorator accepts a constructor and, when run, reveals the person function.

Learn how Loopback 4 enables building APIs and microservices with TypeScript, OpenAPI schemas, and async patterns, featuring database integrations with MongoDB and MySQL and ready-made projects.

Launch LoopBack 4 by creating your first project with the CLI, install dependencies, and explore generated controllers, open API specification, and endpoints in a TypeScript fullstack app.

Explore LoopBack models that describe business domain objects, including value objects without identity and entity models with an identity, and use repositories injected into controllers to perform create operations.

Create your first loopback model by defining a product model with id and required title, including an optional price, and explore model and property decorators that generate the model definition.

Create a LoopBack 4 datasource to connect to MongoDB, MySQL, MariaDB, or in-memory databases with the proper connector and dependency injection. Set up the data sources folder and repository patterns.

Create a product repository in LoopBack 4 to enable crud operations, using a default repository with the in-memory data source and dependency injection; controllers appear in a future video.

Learn how to create a REST API controller in LoopBack4 that defines endpoints for a product model, handles requests, and uses a repository for create, read, and find operations.

Run the Loopback4 project and explore the product API with the API explorer, creating, listing, retrieving by id, and patching product details like name and price.

Explore the depositary package by inspecting the default repository, model definitions, and query filters such as where and limit, and the create and find methods.

Install MySQL server, prefer version 5.7 after 8.0 errors, using macOS or Windows installers from the provided link; then set the root password and install MySQL Workbench with localhost 3306.

Connect loopback to a MySQL database by creating a MySQL datasource, defining a student model and repository, and migrating the schema to create the table.

Set the id property to auto-increment by altering the table, migrating the database, and running the app, then verify that new records auto-increment on creation.

Implement a has-many relationship between student and course models using referential integrity, create the course model with auto-incremented id and title, and configure repositories and controllers to manage related records.

Implement a belongs to relationship from student to department to enforce referential integrity with a foreign key, modeling many students belonging to a single department.

Implement a has one relationship between student and address to enforce referential integrity with a foreign key in Loopback4.