W3docs
es
Iniciar sesión

NodeJS - The Complete Guide (incl. Deno.js, REST APIs, GraphQL)

Master Node JS, build REST APIs with Node.js, GraphQL APIs, add Authentication, use MongoDB, SQL & much more!

Start course

---

This course was updated to also include sections on Deno.js.

---

Node.js is probably THE most popular and modern server-side programming language you can dive into these days!

Node.js developers are in high demand and the language is used for everything from traditional web apps with server-side rendered views over REST APIs all the way up to GraphQL APIs and real-time web services. Not to mention its applications in build workflows for projects of all sizes.

This course will teach you all of that! From scratch with zero prior knowledge assumed. Though if you do bring some knowledge, you'll of course be able to quickly jump into the course modules that are most interesting to you.

Here's what you'll learn in this course:

  • Node.js Basics & Basic Core Modules
  • Parsing Requests & Sending Responses
  • Rendering HTML Dynamically (on the Server)
  • Using Express.js
  • Working with Files and generating PDFs on the Server (on-the-fly)
  • File Up- and Download
  • Using the Model-View-Controller (MVC) Pattern
  • Using Node.js with SQL (MySQL) and Sequelize
  • Using Node.js with NoSQL (MongoDB) and Mongoose
  • Working with Sessions & Cookies
  • User Authentication and Authorization
  • Sending E-Mails
  • Validating User Input
  • Data Pagination
  • Handling Payments with Stripe.js
  • Building REST APIs
  • Authentication in REST APIs
  • File Upload in REST APIs
  • Building GraphQL APIs
  • Authentication in GraphQL APIs
  • File Upload in GraphQL APIs
  • Building a Realtime Node.js App with Websockets
  • Automated Testing (Unit Tests)
  • Deploying a Node.js Application
  • And Way More!

Does this look like a lot of content? It certainly is!

This is not a short course but it is the "Complete Guide" on Node.js after all. We'll dive into a lot of topics and we'll not just scratch the surface.

We'll also not just walk through boring theory and some slides. Instead, we'll build two major projects: An online shop (including checkout + payments) and a blog.

All topics and features of the course will be shown and used in these projects and you'll therefore learn about them in a realistic environment.

Is this course for you?

If you got no Node.js experience, you'll love this course because it starts with zero knowledge assumed. It's the perfect course to become a Node.js developer.

If you got basic Node.js experience, this course is also a perfect match because you can go through the basic modules quickly and you'll benefit from all the deep dives and advanced topics the course covers.

Are you an advanced Node.js user ? Check the curriculum then. Maybe you found no other course that shows how to use SQL with Node.js. Or you're interested in GraphQL. Chances are, that you'll get a lot of value out of this course, too!

Course content

Section 1Getting Started

  • Introduction
    1:55
  • What is Node.js?
    4:42
  • Installing Node.js and Creating our First App
    7:41
  • Join our Online Learning Community
    1:00
  • Understanding the Role & Usage of Node.js
    7:32
  • Course Outline
    7:31
  • How To Get The Most Out Of The Course
    3:54
  • Working with the REPL vs Using FIles
    2:58
  • Using the Attached Source Code
    1:00

Section 2Optional: JavaScript - A Quick Refresher

  • Module IntroductionPremium
    1:36
  • JavaScript in a NutshellPremium
    2:35
  • Refreshing the Core SyntaxPremium
    4:34
  • let & constPremium
    2:27
  • Understanding Arrow FunctionsPremium
    5:17
  • Working with Objects, Properties & MethodsPremium
    3:19
  • Arrays & Array MethodsPremium
    4:16
  • Arrays, Objects & Reference TypesPremium
    2:13
  • Understanding Spread & Rest OperatorsPremium
    6:40
  • DestructuringPremium
    5:37
  • Async Code & PromisesPremium
    10:28
  • Template LiteralsPremium
    1:00
  • Wrap UpPremium
    0:50
  • Useful Resources & LinksPremium
    1:00

Section 3Understanding the Basics

  • Module IntroductionPremium
    1:50
  • How The Web Works
    4:11
  • Creating a Node Server
    13:22
  • The Node Lifecycle & Event Loop
    4:53
  • Understanding RequestsPremium
    3:10
  • Sending ResponsesPremium
    5:37
  • Controlling the Node.js ProcessPremium
    1:00
  • Routing RequestsPremium
    5:48
  • Redirecting RequestsPremium
    4:10
  • Parsing Request BodiesPremium
    11:12
  • Understanding Event Driven Code ExecutionPremium
    6:00
  • Blocking and Non-Blocking CodePremium
    5:04
  • Node.js - Looking Behind the ScenesPremium
    12:01
  • Using the Node Modules SystemPremium
    10:05
  • Wrap UpPremium
    5:15
  • Assignment - Basics (Problem)Premium
    2:32
  • Assignment - Basics (Solution)Premium
    11:32
  • Useful Resources & LinksPremium
    1:00

Section 4Improved Development Workflow and Debugging

  • Module IntroductionPremium
    0:40
  • Understanding NPM ScriptsPremium
    7:03
  • Installing 3rd Party PackagesPremium
    8:20
  • Global Features vs Core Modules vs Third-Party ModulesPremium
    1:00
  • Using Nodemon for AutorestartsPremium
    1:36
  • Global & Local npmPackagesPremium
    1:00
  • Understanding different Error TypesPremium
    1:49
  • Finding & Fixing Syntax ErrorsPremium
    3:10
  • Dealing with Runtime ErrorsPremium
    2:47
  • Logical ErrorsPremium
    6:32
  • Using the DebuggerPremium
    3:10
  • Restarting the Debugger Automatically After Editing our AppPremium
    6:21
  • Changing Variables in the Debug ConsolePremium
    1:26
  • Wrap UpPremium
    3:14
  • Useful Resources & LinksPremium
    1:00

Section 5Working with Express.js

  • Module IntroductionPremium
    2:15
  • What is Express.js?Premium
    3:43
  • Installing Express.jsPremium
    3:47
  • Adding MiddlewarePremium
    5:13
  • How Middleware WorksPremium
    2:58
  • Express.js - Looking Behind the ScenesPremium
    3:42
  • Handling Different RoutesPremium
    4:59
  • Assignment - Express.js (Problem)Premium
    1:52
  • Assignment - Express.js (Solution)Premium
    6:21
  • Parsing Incoming RequestsPremium
    8:00
  • Limiting Middleware Execution to POST RequestsPremium
    1:48
  • Using Express RouterPremium
    8:04
  • Adding a 404 Error PagePremium
    2:30
  • Filtering PathsPremium
    3:38
  • Creating HTML PagesPremium
    5:09
  • Serving HTML PagesPremium
    7:19
  • Returning a 404 PagePremium
    2:00
  • Using a Helper Function for NavigationPremium
    3:37
  • Styling our PagesPremium
    13:58
  • Serving Files StaticallyPremium
    7:49
  • Assignment - Navigation (Problem)Premium
    1:11
  • Assignment - Navigation (Solution)Premium
    8:32
  • Wrap UpPremium
    3:36
  • Useful Resources & LinksPremium
    1:00

Section 6Working with Dynamic Content & Adding Templating Engines

  • Module IntroductionPremium
    2:31
  • Sharing Data Across Requests & UsersPremium
    8:05
  • Templating Engines - An OverviewPremium
    4:40
  • Installing & Implementing PugPremium
    11:04
  • Outputting Dynamic ContentPremium
    11:02
  • Converting HTML Files to PugPremium
    5:55
  • Adding a LayoutPremium
    5:35
  • Finishing the Pug TemplatePremium
    5:50
  • Working with HandlebarsPremium
    5:08
  • Converting our Project to HandlebarsPremium
    7:41
  • Adding the Layout to HandlebarsPremium
    8:41
  • Working with EJSPremium
    8:19
  • Working on the Layout with PartialsPremium
    9:33
  • Wrap UpPremium
    3:46
  • Assignment - Templating Engines (Problem)Premium
    1:36
  • Assignment - Templating Engines (Solution)Premium
    25:02
  • Useful Resources & LinksPremium
    1:00

Section 7The Model View Controller (MVC)

  • Module IntroductionPremium
    0:52
  • What is the MVC?Premium
    2:48
  • Adding ControllersPremium
    9:20
  • Finishing the ControllersPremium
    2:37
  • Adding a Product ModelPremium
    8:05
  • Storing Data in Files Via the ModelPremium
    9:39
  • Fetching Data from Files Via the ModelPremium
    3:55
  • Refactoring the File Storage CodePremium
    4:25
  • Wrap UpPremium
    2:15
  • Useful Resources & LinksPremium
    1:00

Section 8Optional: Enhancing the App

  • Module IntroductionPremium
    1:21
  • Creating the Shop StructurePremium
    5:34
  • Working on the NavigationPremium
    2:49
  • Registering the RoutesPremium
    11:04
  • Storing Product DataPremium
    5:15
  • Displaying Product DataPremium
    3:02
  • Editing & Deleting ProductsPremium
    4:47
  • Adding Another ItemPremium
    2:08
  • Useful Resources & LinksPremium
    1:00

Section 9Dynamic Routes & Advanced Models

  • Module IntroductionPremium
    1:07
  • PreparationsPremium
    1:23
  • Adding the Product ID to the PathPremium
    4:34
  • Extracting Dynamic ParamsPremium
    4:32
  • Loading Product Detail DataPremium
    4:52
  • Rendering the Product Detail ViewPremium
    5:26
  • Passing Data with POST RequestsPremium
    7:19
  • Adding a Cart ModelPremium
    12:29
  • Using Query ParamsPremium
    7:54
  • Pre-Populating the Edit Product Page with DataPremium
    6:46
  • Linking to the Edit PagePremium
    2:20
  • Editing the Product DataPremium
    8:58
  • Adding the Product-Delete FunctionalityPremium
    5:34
  • Deleting Cart ItemsPremium
    8:11
  • Displaying Cart Items on the Cart PagePremium
    8:45
  • Deleting Cart ItemsPremium
    5:24
  • Fixing a Delete Product BugPremium
    1:31
  • Wrap UpPremium
    1:46
  • Useful Resources & LinksPremium
    1:00

Section 10SQL Introduction

  • Module IntroductionPremium
    1:33
  • Choosing a DatabasePremium
    4:17
  • NoSQL IntroductionPremium
    4:20
  • Comparing SQL and NoSQLPremium
    5:06
  • Setting Up MySQLPremium
    7:16
  • Connecting our App to the SQL DatabasePremium
    6:50
  • Basic SQL & Creating a TablePremium
    4:07
  • Retrieving DataPremium
    3:00
  • Fetching ProductsPremium
    6:30
  • Fetching Products - Time to PracticePremium
    1:04
  • Inserting Data Into the DatabasePremium
    4:12
  • Fetching a Single Product with the "where" ConditionPremium
    2:57
  • Wrap UpPremium
    1:24
  • Useful Resources & LinksPremium
    1:00

Section 11Understanding Sequelize

  • Module IntroductionPremium
    1:26
  • What is Sequelize?Premium
    2:35
  • Connecting to the DatabasePremium
    3:57
  • Defining a ModelPremium
    5:47
  • Syncing JS Definitions to the DatabasePremium
    4:29
  • Inserting Data & Creating a ProductPremium
    4:49
  • Retrieving Data & Finding ProductsPremium
    3:01
  • Getting a Single Product with the "where" ConditionPremium
    4:30
  • Fetching Admin ProductsPremium
    1:25
  • Updating ProductsPremium
    5:18
  • Deleting ProductsPremium
    2:48
  • Creating a User ModelPremium
    2:48
  • Adding a One-To-Many RelationshipPremium
    5:54
  • Creating & Managing a Dummy UserPremium
    6:01
  • Using Magic Association MethodsPremium
    3:42
  • Fetching Related ProductsPremium
    2:46
  • One-To-Many & Many-To-Many RelationsPremium
    6:03
  • Creating & Fetching a CartPremium
    5:45
  • Adding New Products to the CartPremium
    6:42
  • Adding Existing Products & Retrieving Cart ItemsPremium
    4:55
  • Deleting Related Items & Deleting Cart ProductsPremium
    2:24
  • Adding an Order ModelPremium
    4:19
  • Storing Cartitems as OrderitemsPremium
    8:19
  • Resetting the Cart & Fetching and Outputting OrdersPremium
    9:53
  • Wrap UpPremium
    1:49
  • Useful Resources & LinksPremium
    1:00

Section 12Working with NoSQL & Using MongoDB

  • Module IntroductionPremium
    1:17
  • What is MongoDB?Premium
    3:57
  • Relations in NoSQLPremium
    3:58
  • Setting Up MongoDBPremium
    4:28
  • Installing the MongoDB DriverPremium
    7:01
  • Creating the Database ConnectionPremium
    3:25
  • Finishing the Database ConnectionPremium
    4:21
  • Using the Database ConnectionPremium
    5:14
  • Creating ProductsPremium
    2:08
  • Understanding the MongoDB CompassPremium
    2:38
  • Fetching All ProductsPremium
    4:34
  • Fetching a Single ProductPremium
    7:45
  • Making the "Edit" & "Delete" Buttons Work AgainPremium
    2:21
  • Working on the Product Model to Edit our ProductPremium
    7:14
  • Finishing the "Update Product" CodePremium
    3:57
  • One Note About Updating ProductsPremium
    1:46
  • Deleting ProductsPremium
    3:30
  • Fixing the "Add Product" FunctionalityPremium
    1:28
  • Creating New UsersPremium
    7:00
  • Storing the User in our DatabasePremium
    5:40
  • Working on Cart Items & OrdersPremium
    7:13
  • Adding the "Add to Cart" FunctionalityPremium
    6:14
  • Storing Multiple Products in the CartPremium
    7:01
  • Displaying the Cart ItemsPremium
    9:20
  • Fixing a BugPremium
    1:02
  • Deleting Cart ItemsPremium
    4:02
  • Adding an OrderPremium
    4:36
  • Adding Relational Order DataPremium
    6:21
  • Getting OrdersPremium
    3:20
  • Removing Deleted Items From the CartPremium
    2:58
  • Wrap UpPremium
    2:19
  • Useful Resources & LinksPremium
    1:00

Section 13Working with Mongoose

  • Module IntroductionPremium
    1:23
  • What is Mongoose?Premium
    2:04
  • Connecting to the MongoDB Server with MongoosePremium
    4:47
  • Creating the Product SchemaPremium
    4:21
  • Saving Data Through MongoosePremium
    6:10
  • Fetching All ProductsPremium
    2:27
  • Fetching a Single ProductPremium
    1:24
  • Updating ProductsPremium
    4:14
  • Deleting ProductsPremium
    1:19
  • Adding and Using a User ModelPremium
    6:36
  • Using Relations in MongoosePremium
    3:44
  • One Important Thing About Fetching RelationsPremium
    3:53
  • Working on the Shopping CartPremium
    5:25
  • Loading the CartPremium
    5:12
  • Deleting Cart ItemsPremium
    2:45
  • Creating & Getting OrdersPremium
    9:56
  • Storing All Order Related DataPremium
    1:52
  • Clearing the Cart After Storing an OrderPremium
    1:59
  • Getting & Displaying the OrdersPremium
    3:40
  • Wrap UpPremium
    1:37
  • Useful Resources & LinksPremium
    1:00

Section 14Sessions & Cookies

  • Module IntroductionPremium
    0:45
  • What is a Cookie?Premium
    1:58
  • The Current Project StatusPremium
    2:18
  • Optional: Creating the Login FormPremium
    6:22
  • Adding the Request Driven Login SolutionPremium
    7:40
  • Setting a CookiePremium
    5:55
  • Manipulating CookiesPremium
    1:58
  • Configuring CookiesPremium
    5:43
  • What is a Session?Premium
    2:58
  • Initializing the Session MiddlewarePremium
    2:43
  • Using the Session MiddlewarePremium
    4:14
  • Using MongoDB to Store SessionsPremium
    5:59
  • Sessions & Cookies - A Short SummaryPremium
    1:53
  • Assignment - Sessions & Cookies (Problem)Premium
    1:37
  • Assignment - Sessions & Cookies (Solution)Premium
    7:24
  • Deleting a CookiePremium
    4:35
  • Fixing Some Minor BugsPremium
    4:27
  • Making "Add to Cart" Work AgainPremium
    6:45
  • Two Tiny ImprovementsPremium
    3:11
  • Wrap UpPremium
    3:43
  • Useful Resources & LinksPremium
    1:00

Section 15Adding Authentication

  • Module IntroductionPremium
    1:22
  • What is Authentication?Premium
    2:25
  • How is Authentication Implemented?Premium
    2:05
  • Our Updated Project StatusPremium
    2:25
  • Implementing an Authentication FlowPremium
    7:34
  • Encrypting PasswordsPremium
    4:36
  • Adding a Tiny Code ImprovementPremium
    1:21
  • Adding the Signin FunctionalityPremium
    6:21
  • Working on Route ProtectionPremium
    2:12
  • Using Middleware to Protect RoutesPremium
    4:38
  • Understanding CSRF AttacksPremium
    3:23
  • Using a CSRF TokenPremium
    6:56
  • Adding CSRF ProtectionPremium
    4:23
  • Fixing the Order ButtonPremium
    1:16
  • Providing User FeedbackPremium
    7:10
  • Optional: Styling Error MessagesPremium
    3:32
  • Finishing the Flash MessagesPremium
    2:20
  • Adding Additional Flash MessagesPremium
    2:20
  • Wrap UpPremium
    2:32
  • Useful Resources & LinksPremium
    1:00

Section 16Sending Emails

  • Module IntroductionPremium
    0:46
  • How Does Sending Emails Work?Premium
    1:33
  • Using SendGridPremium
    1:24
  • Using Nodemailer to Send an EmailPremium
    5:09
  • Potential Limitation for Large Scale AppsPremium
    1:29
  • Useful Resources & LinksPremium
    1:00

Section 17Advanced Authentication

  • Module IntroductionPremium
    0:42
  • Resetting PasswordsPremium
    3:03
  • Implementing the Token LogicPremium
    7:41
  • Creating the TokenPremium
    1:27
  • Creating the Reset Password FormPremium
    5:27
  • Adding Logic to Update the PasswordPremium
    6:35
  • Why we Need AuthorizationPremium
    1:58
  • Adding AuthorizationPremium
    2:07
  • Adding Protection to Post ActionsPremium
    3:43
  • Why Editing FailsPremium
    1:06
  • Wrap UpPremium
    1:44
  • Useful Resources & LinksPremium
    1:00

Section 18Understanding Validation

  • Module IntroductionPremium
    1:03
  • Why Should We Use Validation?Premium
    2:28
  • How to Validate Input?Premium
    4:04
  • Setup & Basic ValidationPremium
    10:44
  • Using Validation Error MessagesPremium
    2:11
  • Built-In & Custom ValidatorsPremium
    3:55
  • More ValidatorsPremium
    4:26
  • Checking For Field EqualityPremium
    3:14
  • Adding Async ValidationPremium
    4:46
  • Assignment - Validation (Problem)Premium
    1:18
  • Assignment - Validation (Solution)Premium
    6:25
  • Keeping User InputPremium
    4:11
  • Adding Conditional CSS ClassesPremium
    5:29
  • Adding Validation to LoginPremium
    5:36
  • Sanitizing DataPremium
    3:41
  • Validating Product AdditionPremium
    11:40
  • Validating Product EditingPremium
    6:57
  • Wrap UpPremium
    1:23
  • Useful Resources & LinksPremium
    1:00

Section 19Error Handling

  • Module IntroductionPremium
    0:45
  • Types of Errors & Error HandlingPremium
    5:14
  • Analyzing the Error Handling in the Current ProjectPremium
    2:22
  • Errors - Some TheoryPremium
    6:43
  • Throwing Errors in CodePremium
    2:42
  • Returning Error PagesPremium
    6:54
  • Using the Express.js Error Handling MiddlewarePremium
    5:47
  • Updating the AppPremium
    3:09
  • Using the Error Handling Middleware CorrectlyPremium
    4:54
  • Status CodesPremium
    5:57
  • Wrap UpPremium
    2:21
  • Useful Resources & LinksPremium
    1:00

Section 20File Upload & Download

  • Module IntroductionPremium
    0:54
  • Adding a File Picker to the FrontendPremium
    3:06
  • Handling Multipart Form DataPremium
    5:15
  • Handling File Uploads with MulterPremium
    4:51
  • Configuring Multer to Adjust Filename & FilepathPremium
    4:29
  • Filtering Files by MimetypePremium
    2:28
  • Storing File Data in the DatabasePremium
    7:42
  • Serving Images StaticallyPremium
    4:25
  • Downloading Files with AuthenticationPremium
    7:33
  • Setting File Type HeadersPremium
    2:35
  • Restricting File AccessPremium
    3:19
  • Streaming Data vs Preloading DataPremium
    3:20
  • Using PDFKit for .pdf GenerationPremium
    5:32
  • Generating .pdf Files with Order DataPremium
    6:50
  • Deleting FilesPremium
    5:57
  • Fixing Invoice LinksPremium
    0:35
  • Wrap UpPremium
    1:31
  • Useful Resources & LinksPremium
    1:00

Section 21Adding Pagination

  • Module IntroductionPremium
    0:48
  • Adding Pagination LinksPremium
    4:08
  • Retrieving a Chunk of DataPremium
    3:47
  • Preparing Pagination Data on the ServerPremium
    3:52
  • Adding Dynamic Pagination ButtonsPremium
    8:07
  • Re-Using the Pagination Logic & ControlsPremium
    3:41
  • Wrap UpPremium
    1:02
  • Useful Resources & LinksPremium
    1:00

Section 22Understanding Async Requests

  • Module IntroductionPremium
    0:49
  • What are Async Requests?Premium
    2:07
  • Adding Client Side JS CodePremium
    7:24
  • Sending & Handling Background RequestsPremium
    9:26
  • Manipulating the DOMPremium
    3:01
  • Useful Resources & LinksPremium
    1:00

Section 23Adding Payments

  • Module IntroductionPremium
    0:58
  • How Payments WorkPremium
    2:04
  • Adding a Checkout PagePremium
    6:00
  • Using Stripe in Your AppPremium
    19:23
  • Useful Resources & LinksPremium
    1:00

Section 24Working with REST APIs - The Basics

  • Module IntroductionPremium
    1:25
  • What are REST APIs and why do we use Them?Premium
    7:01
  • Accessing Data with REST APIsPremium
    5:41
  • Understanding Routing & HTTP MethodsPremium
    5:25
  • REST APIs - The Core PrinciplesPremium
    4:09
  • Creating our REST API Project & Implementing the Route SetupPremium
    6:41
  • Sending Requests & Responses and Working with PostmanPremium
    13:28
  • REST APIs, Clients & CORS ErrorsPremium
    10:33
  • Sending POST RequestsPremium
    6:32
  • Wrap UpPremium
    2:14
  • Useful Resources & LinksPremium
    1:00

Section 25Working with REST APIs - The Practical Application

  • Module IntroductionPremium
    1:10
  • REST APIs & The Rest Of The CoursePremium
    3:59
  • Understanding the Frontend SetupPremium
    4:18
  • Planning the APIPremium
    3:02
  • Fetching Lists of PostsPremium
    6:19
  • Adding a Create Post EndpointPremium
    7:36
  • Adding Server Side ValidationPremium
    6:19
  • Setting Up a Post ModelPremium
    5:14
  • Storing Posts in the DatabasePremium
    3:32
  • Static Images & Error HandlingPremium
    6:53
  • Fetching a Single PostPremium
    7:48
  • Uploading ImagesPremium
    8:56
  • Updating PostsPremium
    14:02
  • Deleting PostsPremium
    4:17
  • Adding PaginationPremium
    6:20
  • Adding a User ModelPremium
    4:08
  • Adding User Signup ValidationPremium
    6:29
  • Signing Users UpPremium
    7:24
  • How Does Authentication Work?Premium
    3:10
  • Starting with User LoginPremium
    3:51
  • Logging In & Creating JSON Web Tokens (JWTs)Premium
    7:53
  • Using & Validating the TokenPremium
    9:43
  • Adding Auth Middleware to All RoutesPremium
    1:52
  • Connecting Posts & UsersPremium
    6:13
  • Adding Authorization ChecksPremium
    3:50
  • Clearing Post-User RelationsPremium
    2:54
  • Assignment - REST API (Problem)Premium
    0:59
  • Assignment - REST API (Solution)Premium
    8:16
  • Wrap UpPremium
    2:28
  • Useful Resources & LinksPremium
    1:00

Section 26Understanding Async Await in Node.js

  • Module IntroductionPremium
    0:58
  • What is Async Await All About?Premium
    4:08
  • Transforming "Then Catch" to "Async Await"Premium
    4:26
  • Assignment - Async Await (Problem)Premium
    0:39
  • Assignment - Async Await (Solution)Premium
    9:56
  • Wrap UpPremium
    3:03
  • Useful Resources & LinksPremium
    1:00

Section 27Understanding Websockets & Socket.io

  • Module IntroductionPremium
    0:55
  • What Are Websockets & Why Would You Use Them?Premium
    4:17
  • Websocket Solutions - An OverviewPremium
    1:35
  • Setting Up Socket.io on the ServerPremium
    3:56
  • Establishing a Connection From the ClientPremium
    2:27
  • Identifying Realtime PotentialPremium
    2:42
  • Sharing the IO Instance Across FilesPremium
    2:46
  • Synchronizing POST AdditionsPremium
    7:14
  • Fixing a Bug - The Missing UsernamePremium
    1:44
  • Updating Posts On All Connected ClientsPremium
    3:58
  • Sorting CorrectlyPremium
    0:59
  • Deleting Posts Across ClientsPremium
    2:31
  • Wrap UpPremium
    1:48
  • Useful Resources & LinksPremium
    1:00

Section 28Working with GraphQL

  • Module IntroductionPremium
    0:57
  • What is GraphQL?Premium
    9:17
  • Understanding the Setup & Writing our First QueryPremium
    11:15
  • Defining a Mutation SchemaPremium
    5:42
  • Adding a Mutation Resolver & GraphiQLPremium
    9:42
  • Adding Input ValidationPremium
    4:19
  • Handling ErrorsPremium
    3:45
  • Connecting the Frontend to the GraphQL APIPremium
    6:49
  • Adding a Login Query & a ResolverPremium
    6:20
  • Adding Login FunctionalityPremium
    4:57
  • Adding a Create Post MutationPremium
    7:23
  • Extracting User Data From the Auth TokenPremium
    5:48
  • Sending the "Create Post" QueryPremium
    4:46
  • Fixing a Bug & Adding New Posts CorrectlyPremium
    2:53
  • Adding a "Get Post" Query & ResolverPremium
    4:53
  • Sending "Create Post" and "Get Post" QueriesPremium
    5:13
  • Adding PaginationPremium
    4:28
  • Uploading ImagesPremium
    10:26
  • Viewing a Single PostPremium
    6:07
  • Updating PostsPremium
    9:32
  • Deleting PostsPremium
    9:25
  • Managing the User StatusPremium
    9:17
  • Using VariablesPremium
    16:06
  • Fixing a Pagination BugPremium
    2:48
  • Wrap UpPremium
    3:36
  • Useful Resources & LinksPremium
    1:00

Section 29Deploying our App

  • Module IntroductionPremium
    1:16
  • Deploying Different Kinds of AppsPremium
    1:39
  • Deployment PreparationsPremium
    4:52
  • Using Environment VariablesPremium
    11:12
  • Using Production API KeysPremium
    1:19
  • Setting Secure Response Headers with HelmetPremium
    2:40
  • Compressing AssetsPremium
    2:33
  • Setting Up Request LoggingPremium
    3:34
  • Setting Up a SSL ServerPremium
    9:55
  • Using a Hosting ProviderPremium
    4:25
  • Understanding the Project & the Git SetupPremium
    4:03
  • A Deployment Example with HerokuPremium
    10:26
  • Deploying APIsPremium
    2:52
  • Useful Resources & LinksPremium
    1:00

Section 30Testing Node.js Applications

  • Module IntroductionPremium
    0:43
  • What is Testing?Premium
    2:42
  • Why & How?Premium
    3:25
  • Setup and Writing a First TestPremium
    9:40
  • Testing the Auth MiddlewarePremium
    12:33
  • Organizing Multiple TestsPremium
    4:12
  • What Not To Test!Premium
    8:02
  • Using StubsPremium
    8:38
  • Testing ControllersPremium
    8:03
  • Testing Asynchronous CodePremium
    5:53
  • Setting up a Testing DatabasePremium
    6:33
  • Testing Code With An Active DatabasePremium
    6:33
  • Cleaning UpPremium
    3:29
  • HooksPremium
    4:34
  • Testing Code That Requires AuthenticationPremium
    12:37
  • Wrap Up & Mastering TestsPremium
    4:22
  • Useful Resources & LinksPremium
    1:00
  • New LecturePremium
    1:00

Section 31Node.js as a Build Tool & Using npm

  • Module IntroductionPremium
    1:01
  • npm & Node.jsPremium
    1:42
  • Using npmPremium
    7:52
  • What is a Build Tool?Premium
    5:01
  • Using Node.js in Build ProcessesPremium
    5:50
  • Useful Resources & LinksPremium
    1:00

Section 32Modern JavaScript & NodeJS

  • Module IntroductionPremium
    2:28
  • What is this Module About?Premium
    2:19
  • Using ES ModulesPremium
    9:32
  • More on ES ModulesPremium
    6:26
  • Node Core Modules & PromisesPremium
    5:18
  • Module ResourcesPremium
    1:00

Section 33Bonus: Node & TypeScript

  • Module IntroductionPremium
    1:22
  • TypeScript: What & WhyPremium
    6:02
  • TypeScript SetupPremium
    4:09
  • Assigning TypesPremium
    3:29
  • Type Inference & Type CastingPremium
    6:10
  • Configuring TypeScriptPremium
    5:01
  • Working with Union TypesPremium
    4:23
  • Using Object and Array TypesPremium
    6:17
  • Type Aliases & InterfacesPremium
    3:22
  • Understanding Generic TypesPremium
    5:09
  • TypeScript: A SummaryPremium
    0:34
  • TypeScript & Node: SetupPremium
    2:14
  • Getting Started with TypeScript & NodePremium
    9:31
  • Writing TypeScript Express.js CodePremium
    3:59
  • Adding REST Routes with TSPremium
    6:42
  • Finishing the REST RoutesPremium
    5:53
  • Testing the APIPremium
    4:52
  • Using Type CastingPremium
    4:21
  • Moving to a Better Project StructurePremium
    3:44
  • Wrap UpPremium
    2:50
  • Module ResourcesPremium
    1:00

Section 34DenoJS - An Introduction

  • Module IntroductionPremium
    1:35
  • What is Deno?Premium
    3:09
  • Why Deno?Premium
    1:55
  • Deno SetupPremium
    5:50
  • Writing First Deno CodePremium
    4:18
  • The Deno Runtime (Namespace) APIPremium
    3:13
  • Using the Runtime APIPremium
    5:26
  • Working with Deno PermissionsPremium
    4:31
  • Repeating the Example with NodePremium
    4:16
  • How Deno Features Are OrganizedPremium
    4:28
  • Using the Standard Library ModulesPremium
    8:30
  • Creating a WebserverPremium
    2:54
  • Using the Oak Framework with DenoPremium
    9:48
  • More on Module URLsPremium
    1:00
  • Creating an Example Node REST APIPremium
    12:15
  • Re-building the REST API with DenoPremium
    16:18
  • Should You Switch From Node To Deno?Premium
    5:05
  • Module ResourcesPremium
    1:00

Section 35Deno & MongoDB

  • Module IntroductionPremium
    1:00
  • App SetupPremium
    4:06
  • Deno & CORSPremium
    7:16
  • Establishing a MongoDB ConnectionPremium
    8:05
  • Using the Mongo ModulePremium
    10:34
  • Finishing the CRUD OperationsPremium
    5:29
  • Wrap UpPremium
    1:10
  • Module ResourcesPremium
    1:00

Section 36Roundup

  • Course RoundupPremium
    2:40

Course instructor

Photo of Maximilian Schwarzmüller

Maximilian Schwarzmüller

As a self-taught professional I really know the hard parts and the difficult topics when learning new or improving on already-known languages. This background and experience enable me to focus on the most relevant key concepts and topics. My track record of many 5-star rated courses, more than 1,000,000 students worldwide as well as a successful YouTube channel is the best proof for that.

The most rewarding experience for me is to see how people find new, better jobs, build awesome web applications, work on amazing projects or simply enjoy their hobby with the help of my content. That's why, together with Manuel Lorenz, I founded Academind to offer the best possible learning experience and to share the pleasure of learning with our students.