Top 8 Recommended GraphQL Self-Study Materials! [December 2023]

Join the most comprehensive Node.js course on Udemy and learn Node in both a practical and a theory-based way!

-

Node.js is probably THE most popular and modern server-side programming language you can learn 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

• Using TypeScript with Node.js

• Exploring Deno.js

• 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!

Prerequisites

• NO Node.js knowledge is required at all!

• NO other programming language knowledge (besides JavaScript, see next point) is required

• Basic JavaScript knowledge is assumed though - you should at least be willing to pick it up whilst going through the course. A JS refresher module exists to bring you up to the latest syntax quickly

• Basic HTML + CSS knowledge helps but is NOT required

1. Introduction
2. Introduction
3. What is Node.js?
4. Join our Online Learning Community
5. Installing Node.js and Creating our First App
6. Understanding the Role & Usage of Node.js
7. Course Outline
8. How To Get The Most Out Of The Course
9. Working with the REPL vs Using Files
10. Using the Attached Source Code
11. Optional: JavaScript - A Quick Refresher
12. Module Introduction
13. JavaScript in a Nutshell
14. Refreshing the Core Syntax
15. let & const
16. Understanding Arrow Functions
17. Working with Objects, Properties & Methods
18. Arrays & Array Methods
19. Arrays, Objects & Reference Types
20. Understanding Spread & Rest Operators
21. Destructuring
22. Async Code & Promises
23. Template Literals
24. Wrap Up
25. Useful Resources & Links
26. Understanding the Basics
27. Module Introduction
28. How The Web Works
29. Creating a Node Server
30. The Node Lifecycle & Event Loop
31. Controlling the Node.js Process
32. Understanding Requests
33. Sending Responses
34. Request & Response Headers
35. Routing Requests
36. Redirecting Requests
37. Parsing Request Bodies
38. Understanding Event Driven Code Execution
39. Blocking and Non-Blocking Code
40. Node.js - Looking Behind the Scenes
41. Using the Node Modules System
42. Wrap Up
43. Time to Practice - The Basics
44. Useful Resources & Links
45. Improved Development Workflow and Debugging
46. Module Introduction
47. Understanding NPM Scripts
48. Installing 3rd Party Packages
49. Global Features vs Core Modules vs Third-Party Modules
50. Using Nodemon for Autorestarts
51. Global & Local npm Packages
52. Understanding different Error Types
53. Finding & Fixing Syntax Errors
54. Dealing with Runtime Errors
55. Logical Errors
56. Using the Debugger
57. Restarting the Debugger Automatically After Editing our App
58. Debugging Node.js in Visual Studio Code
59. Changing Variables in the Debug Console
60. Wrap Up
61. Useful Resources & Links
62. Working with Express.js
63. Module Introduction
64. What is Express.js?
65. Installing Express.js
66. Adding Middleware
67. How Middleware Works
68. Express.js - Looking Behind the Scenes
69. Handling Different Routes
70. Time to Practice - Express.js
71. Parsing Incoming Requests
72. Limiting Middleware Execution to POST Requests
73. Using Express Router
74. Adding a 404 Error Page
75. Filtering Paths
76. Creating HTML Pages
77. Serving HTML Pages
78. Returning a 404 Page
79. A Hint!
80. Using a Helper Function for Navigation
81. Styling our Pages
82. Serving Files Statically
83. Time to Practice - Navigation
84. Wrap Up
85. Useful Resources & Links
86. Working with Dynamic Content & Adding Templating Engines
87. Module Introduction
88. Sharing Data Across Requests & Users
89. Templating Engines - An Overview
90. Installing & Implementing Pug
91. Outputting Dynamic Content
92. Official Pug Docs
93. Converting HTML Files to Pug
94. Adding a Layout
95. Finishing the Pug Template
96. Avoiding an Error
97. Working with Handlebars
98. Converting our Project to Handlebars
99. Adding the Layout to Handlebars
100. Working with EJS
101. Working on the Layout with Partials
102. Wrap Up
103. Time to Practice - Templating Engines
104. [OPTIONAL] Assignment Solution
105. Useful Resources & Links
106. The Model View Controller (MVC)
107. Module Introduction
108. What is the MVC?
109. Adding Controllers
110. Finishing the Controllers
111. Adding a Product Model
112. Storing Data in Files Via the Model
113. Fetching Data from Files Via the Model
114. Refactoring the File Storage Code
115. Wrap Up
116. Useful Resources & Links
117. Optional: Enhancing the App
118. Module Introduction
119. Creating the Shop Structure
120. Working on the Navigation
121. Registering the Routes
122. Storing Product Data
123. Displaying Product Data
124. Editing & Deleting Products
125. Adding Another Item
126. Useful Resources & Links
127. Dynamic Routes & Advanced Models
128. Module Introduction
129. Preparations
130. Applied Changes
131. Adding the Product ID to the Path
132. Extracting Dynamic Params
133. Loading Product Detail Data
134. Rendering the Product Detail View
135. Passing Data with POST Requests
136. Adding a Cart Model
137. Using Query Params
138. Pre-Populating the Edit Product Page with Data
139. Linking to the Edit Page
140. Editing the Product Data
141. Adding the Product-Delete Functionality
142. Deleting Cart Items
143. Displaying Cart Items on the Cart Page
144. Deleting Cart Items
145. Fixing a Delete Product Bug
146. Wrap Up
147. Useful Resources & Links
148. SQL Introduction
149. Module Introduction
150. Choosing a Database
151. NoSQL Introduction
152. Comparing SQL and NoSQL
153. Setting Up MySQL
154. Connecting our App to the SQL Database
155. Basic SQL & Creating a Table
156. Retrieving Data
157. Fetching Products
158. Fetching Products - Time to Practice
159. Inserting Data Into the Database
160. Fetching a Single Product with the "where" Condition
161. Wrap Up
162. Useful Resources & Links
163. Understanding Sequelize
164. Module Introduction
165. What is Sequelize?
166. Connecting to the Database
167. Defining a Model
168. Syncing JS Definitions to the Database
169. Inserting Data & Creating a Product
170. MUST READ: findById() in Sequelize 5
171. Retrieving Data & Finding Products
172. Getting a Single Product with the "where" Condition
173. Fetching Admin Products
174. Updating Products
175. Deleting Products
176. Creating a User Model
177. Adding a One-To-Many Relationship
178. Creating & Managing a Dummy User
179. Using Magic Association Methods
180. Fetching Related Products
181. One-To-Many & Many-To-Many Relations
182. Creating & Fetching a Cart
183. Adding New Products to the Cart
184. Adding Existing Products & Retrieving Cart Items
185. Deleting Related Items & Deleting Cart Products
186. Adding an Order Model
187. Storing Cartitems as Orderitems
188. Resetting the Cart & Fetching and Outputting Orders
189. Wrap Up
190. Useful Resources & Links
191. Working with NoSQL & Using MongoDB
192. Module Introduction
193. What is MongoDB?
194. Relations in NoSQL
195. Setting Up MongoDB
196. Installing the MongoDB Driver
197. Creating the Database Connection
198. Finishing the Database Connection
199. Using the Database Connection
200. Creating Products

Just FULLY updated and re-recorded with all new React features for 2023 (React v18)! Join a live online community of over 900,000+ developers and a course taught by industry experts that have actually worked both in Silicon Valley and Toronto with React.js.

Using the latest version of React (React 18), this course is focused on efficiency. Never spend time on confusing, out of date, incomplete tutorials anymore. Graduates of Andrei’s courses are now working at Google, Tesla, Amazon, Apple, IBM, JP Morgan, Meta, + other top tech companies.

We guarantee you this is the most comprehensive online resource on React. This project based course will introduce you to all of the modern toolchain of a React developer in 2023. Along the way, we will build a massive e-commerce application similar to Shopify using React, Redux, React Hooks, React Suspense, React Router, GraphQL, Context API, Firebase, Redux-Saga, Stripe + more. This is going to be a full stack app (MERN stack), using Firebase.

The curriculum is going to be very hands on as we walk you from start to finish of releasing a professional React project all the way into production. We will start from the very beginning by teaching you React Basics and then going into advanced topics so you can make good decisions on architecture and tools on any of your future ReactJS projects.

All code is going to be provided step by step and even if you don’t like to code along, you will get access to the the full master project code so anyone signed up for the course will have their own project to put on their portfolio right away.

The topics covered will be:

- React Basics

- React Router

- Redux

- Redux Saga

- Asynchronous Redux

- React Hooks

- Context API

- React Suspense + React Lazy

- Firebase

- Stripe API

- Styled-Components

- GraphQL

- Apollo

- PWAs

- React Performance

- React Design Patterns

- Testing with Jest and Snapshot testing

- React Best Practices

- Persistance + Session Storage

- State Normalization

+ more

Wait wait… I know what you’re thinking. Why aren’t we building 10+ projects? Well, here’s the truth: Most courses teach you React and do just that. They show you how to get started, build 10 projects that are simple and easy to build in a day, and just add some CSS to make them look fancy. In real life though, you’re not building silly applications. When you apply to jobs, nobody is going to care that you built a really pretty To Do app. Employers want to see you build large apps that can scale, that have good architecture, and that can be deployed to production.

Let me tell you 3 reasons why this course is different from any other React tutorial online:

1. You will build the biggest project you will see in any course. This type of project would take you months to implement yourself.

2. This course is taught by 2 instructors that have actually worked for some of the biggest tech firms using React in production. Yihua has been working on some of the biggest e-commerce websites that you have definitely heard of and probably have shopped at. Andrei has worked on enterprise level React applications for large IPOed tech firms in Silicon Valley as well as Toronto. By having both of them teach, you get to see different perspective and learn from 2 senior developers as if you are working at a company together.

3. We learn principles that are important beyond just what you learn as a beginner. Using the instructor's experiences you learn about design patterns, how to architect your app, organize your code, structure your folders, and how to think about performance. Let’s just say we don’t shy away from the advanced topics.

This course is not about making you just code along without understanding the principles so that when you are done with the course you don’t know what to do other than watch another tutorial. No! This course will push you and challenge you to go from an absolute beginner in React to someone that is in the top 10% of React developers. 

Taught By:

Andrei Neagoie is the instructor of the highest rated Development courses on Udemy as well as one of the fastest growing. His graduates have moved on to work for some of the biggest tech companies around the world like Apple, Google, Amazon, JP Morgan, IBM, UNIQLO etc... He has been working as a senior software developer in Silicon Valley and Toronto for many years, and is now taking all that he has learned, to teach programming skills and to help you discover the amazing career opportunities that being a developer allows in life. 

Having been a self taught programmer, he understands that there is an overwhelming number of online courses, tutorials and books that are overly verbose and inadequate at teaching proper skills. Most people feel paralyzed and don't know where to start when learning a complex subject matter, or even worse, most people don't have $20,000 to spend on a coding bootcamp. Programming skills should be affordable and open to all. An education material should teach real life skills that are current and they should not waste a student's valuable time.   Having learned important lessons from working for Fortune 500 companies, tech startups, to even founding his own business, he is now dedicating 100% of his time to teaching others valuable software development skills in order to take control of their life and work in an exciting industry with infinite possibilities. 

Andrei promises you that there are no other courses out there as comprehensive and as well explained. He believes that in order to learn anything of value, you need to start with the foundation and develop the roots of the tree. Only from there will you be able to learn concepts and specific skills(leaves) that connect to the foundation. Learning becomes exponential when structured in this way. 

Taking his experience in educational psychology and coding, Andrei's courses will take you on an understanding of complex subjects that you never thought would be possible.  

See you inside the courses!

--------

Yihua Zhang is one of the Instructors of Zero To Mastery, one of the highest rated and fastest growing Web Development academies on Udemy. He has been working as a software developer for numerous years in Toronto for some of the largest tech companies in the world. He has also been working as an instructor for more than a decade. He is focused on bringing everything he has learned to help you achieve a new career as a developer, but also give you all the fundamental skills required to flourish in this incredible industry.

Yihua is a self taught developer, so he fully understands the challenges and mindset of coming into this industry from various other backgrounds. He has been on both sides of the table, as both an instructor and student numerous times so he can empathize with the difficulty of learning something new and challenging. Learning itself is a skill that needs to be practiced and improved upon, and he is dedicated to helping you improve and master that skill for yourself. Courses need to be practical, you need to be able to understand why you are learning the things that you are being taught. You need to understand the problem before you know the solution, and he prides himself on teaching you how to build professional, real world applications so you truly understand why you are doing things a specific way. He will teach you the mindset and skillset required to grow as a developer as fast as possible, so you can have the rich and fulfilling life that comes with this career.

Yihua's courses will guide you to build beautifully written and richly featured applications, while truly understanding all the complex concepts you will encounter along the way.

1. Introduction
2. Course Outline
3. Join Our Online Classroom!
4. Exercise: Meet Your Classmates & Instructor
5. ZTM Resources
6. Monthly Coding Challenges, Free Resources and Guides
7. React Key Concepts
8. React Concepts
9. The Birth of React.js
10. Declarative vs Imperative
11. Component Architecture
12. One Way Data Flow
13. UI Library
14. How To Be A Great React Developer
15. Web Developer Monthly
16. React Basics
17. Section Overview
18. Course Guideline + Code
19. Environment Setup for Mac
20. Environment Setup For Windows
21. NPM vs YARN
22. Yihua's VSCode font and settings
23. VSCode settings update
24. Create React App - NPX
25. Create React App - React-Scripts 1
26. Create React App - React-Scripts 2
27. Create React App - Everything Else
28. Don't Eject
29. Hooks vs Classes
30. Quick note: React 18 Strict Mode
31. Monsters Rolodex - Class Components
32. Monsters Rolodex - Component State
33. Monsters Rolodex - setState
34. Monsters Rolodex - States and Shallow Merge
35. Monsters Rolodex - setState and Secondary Callback
36. Monsters Rolodex - Mapping Arrays to Elements
37. Optional: map() + key attribute
38. Monsters Rolodex - Keys for Mapping
39. Monsters Rolodex - Single Page Applications (SPAs)
40. Monsters Rolodex - Lifecycle Method: componentDidMount
41. Optional: Promises
42. Monsters Rolodex - Renders & Re-renders in React
43. Monsters Rolodex - Input Search Box Component
44. Monsters Rolodex - Searching & Filtering
45. Optional: filter(), includes()
46. Monsters Rolodex - Storing Original Data
47. Monsters Rolodex - Optimizations
48. Monsters Rolodex - Understanding Components
49. Monsters Rolodex - CardList Component
50. Monsters Rolodex - Component Props
51. Monsters Rolodex - Rendering and Re-rendering part 2
52. Monsters Rolodex - SearchBox Component
53. Monsters Rolodex - CSS in React
54. Monsters Rolodex - CardList Component
55. Quick note on quotes for string interpolation
56. Monsters Rolodex - Finishing Touches
57. Functional vs Class Components
58. Class Component Lifecycle Methods Breakdown
59. Monsters Rolodex - Functional Component Intro
60. Pure & Impure Functions
61. Monsters Rolodex - Hooks: useState
62. Monsters Rolodex - Functional Component Re-rendering
63. Monsters Rolodex - Infinite Re-rendering
64. Monsters Rolodex - Hooks: useEffect
65. Monsters Rolodex - Remaining Components
66. React v18: Migrating from React v17 + ReactDOM v18 Changes
67. React v18: Strict Mode Changes
68. DOM and Virtual DOM
69. React and ReactDOM
70. React and ReactDOM part 2
71. ReactDOM v18 Changes
72. DOM Paint Flashing
73. Optional: Git + Github
74. Optional: Connecting With SSH To Github
75. Capstone Project: Intro + Setup
76. Endorsements On LinkedIN
77. Github Strategy
78. The Long Road Ahead
79. Project Overview
80. Scaffolding Our Capstone Project
81. Setting Up Our Categories
82. Adding Sass
83. Category Item Component
84. Directory Component
85. Adding Fonts
86. Routing + React-Router
87. Routing
88. Updating/Upgrading Libraries
89. Setting Up Our Homepage
90. React Router Outlet
91. Navigation Bar Component
92. React Router Link
93. Styling for Navigation + Logo
94. Authentication + Firebase
95. Setting Up Firebase
96. Authentication Flow
97. Optional: Async Await
98. Optional: How to fix 403: restricted_client error
99. Authenticating With Firebase
100. Introducing Firestore Data Models
101. Setting Up User Documents
102. Finish Creating User Documents
103. Sign In With Redirect
104. Sign Up Form Pt.1
105. Sign Up Form Pt.2
106. Sign Up With Email + Password
107. Generalizing Form Input Component
108. Custom Button Component
109. Sign In Form
110. Finishing Authentication Page
111. React Context For State Management
112. Need For Context
113. User Context
114. Re-rendering From Context
115. Signing Out
116. Exercise: Imposter Syndrome
117. Observer Pattern
118. Observer: onAuthStateChange
119. Finalizing Auth Listener
120. Observer Pattern
121. React Context Continued
122. New Shop Page
123. Products Context
124. Product Card Component
125. Cart Icon & Dropdown
126. Toggle Cart Open
127. Add To Cart Pt.1
128. Add To Cart Pt.2
129. Optional: reduce()
130. Cart Item Designs
131. Creating Checkout Page
132. Checkout Item Pt. 1
133. Checkout Item Pt.2
134. Checkout Item Pt.3
135. Cart Total
136. Firebase Database Storage
137. Firestore DB No-SQL
138. addCollectionAndDocuments Pt.1
139. addCollectionAndDocuments Pt.2
140. Get Products + Categories From Firestore
141. Optional: Hash Tables vs Arrays
142. Using Our CategoriesMap
143. Category Preview Component
144. Nested Routes in Shop
145. Category Page
146. CSS-In-JS + Styled-Components
147. Fixing Clashing Styles
148. Introducing Styled-Components
149. Styled-Components - Button
150. Styled-Component - Cart Dropdown
151. Styled-Component - Directory Item & Cart Icon
152. Styled-Component - Form Input Component
153. Last Touches
154. Deploying With Netlify
155. Deploying On Netlify
156. Adding Redirects For Netlify
157. Reducers
158. Reducers explained
159. User Reducer
160. Cart Reducer Pt. 1
161. Cart Reducer Pt. 2
162. Cart Reducer Pt. 3
163. Redux
164. Redux Toolkit Aside
165. Redux vs Context: Access
166. Redux vs Context: Data Flow
167. React-Redux: Installation
168. React-Redux: Setting Up Our Store
169. React-Redux: Creating User Reducer
170. React-Redux: Selectors
171. Categories Reducer
172. Categories Selectors
173. Business Logic in Our Selectors
174. What Triggers useSelector
175. Demystifying Middleware
176. Redux Triggers Extra Re-renders
177. Optional: Memoization
178. Reselect Library
179. Migrating Cart Context to Redux Pt. 1
180. Migrating Cart Context to Redux Pt. 2
181. Migrating Cart Context to Redux Pt. 3
182. Migrate Cart Context to Redux Pt. 4
183. Redux Extended Tools
184. Redux-Persist
185. Redux-Devtools
186. Asynchronous Redux: Redux-Thunk
187. Asynchronous Redux: Redux-Thunk
188. Redux-Thunk Pt. 2
189. Redux-Thunk Pt. 3
190. Asynchronous Redux: Redux-Saga
191. Asynchronous Redux: Redux-Saga
192. Generator Functions
193. Redux-Saga: fetchCategoriesAsync Thunk to Saga
194. Redux-Saga: Converting onAuthStateChanged Listener to Promise
195. Redux-Saga: Check User Session Saga Pt. 1
196. Redux-Saga: Check User Session Saga Pt. 2
197. Redux-Saga: Sign in Sagas
198. Redux-Saga: Sign up Sagas
199. Redux-Saga: Sign Out Sagas
200. Redux Toolkit

Just released with all new NodeJS best practices and trends for 2023! Join a live online community of over 900,000+ developers and a course taught by industry experts that have actually worked both in Silicon Valley and Toronto with Node.js.

Using the latest version of Node, this course is focused on efficiency and turning you into a Back End or Fullstack developer. Never spend time on confusing, out of date, incomplete tutorials anymore! Graduates of Andrei’s courses are now working at Google, Tesla, Amazon, Apple, IBM, JP Morgan, Facebook, + other top tech companies for a reason.

We guarantee you this is the most comprehensive online resource on NodeJS. This project based course will introduce you to all of the modern toolchain of a Node JS developer in 2023. Along the way, we will build a massive NASA Space launch application using Node.js, Express Framework, RESTful APIs, GraphQL, and much more! This is going to be a Fullstack MERN app. We will also build many other mini projects along the way so you feel confident deploying any Node.js project to production in the future by yourself!

All code is going to be provided step by step and even if you don’t like to code along, you will get access to all the code from the projects we build so anyone signed up for the course will have their own project to put on their portfolio right away.

The curriculum is going to be very hands on as we walk you from start to finish of releasing a professional (performant and secure) Node.js project all the way into production. We will start from the very beginning by teaching you Node basics and then going into advanced topics so you can make good decisions on architecture and tools on any of your future NodeJS projects. The goal is to turn you into a senior backend developer!

Finally, this course will be constantly evolving and updating as the landscape changes. Just as the Node ecosystem evolves, we want this course to be constantly updated with lectures and resource for you to come back to, in order to find the latest Node best practices anytime in the future.

Here is what the course will cover:

1. Foundations

• Focus on Node internals

• Libuv, threads, processes, event loop

• Asynchronous programming

• Node vs PHP vs Python

• Observer Design Pattern

• Event Emitters

  
  

2. Module System

• The require Function

• Creating Your Own Modules

• CommonJS vs ECMAScript (ES6) modules

• Module Caching

• Using index.js

  
  

3. Package Management

• NPM: The Node Package Manager

• Creating Your Own Packages

• Package And the NPM Registry

• Third Party Modules

• The node_modules Folder

• Semantic Versioning

• package-lock.json And Versioning

• Vulnerabilities in Dependencies

4. File I/O: Planets Project

• Exploring Exoplanets With Node

• Exploring Kepler Space Telescope Data

• Working With Streams

• Streaming Large Data Files

• Parsing Our Planets Data

• Working With CSV Files

• Finding Habitable Planets

5. Web Servers

• What is a Web Server?

• HTTP Responses and Requests

• HTTP APIs and Routing, Parameterized URLs

• Same Origin Policy, CORS

• Requests and Responses as Streams

6. Express.js

• Express vs Next.js vs Koa

• Route Parameters

• Model View Controller (MVC) pattern

• Postman and Insomnia

• Development Dependencies

• Middleware

• Logging Middleware Example / Writing Our Own Middleware

• POST Requests in Express

• MVC In Express

• Express Routers

• RESTful APIs

• CRUD

• Sending Files

• Serving Websites With Node

• Templating Engines

7. NodeJS NASA Project

• Architecture diagrams on LucidChart

• GET, POST, DELETE routes.

• Serving React.js Applications in Express

• CORS middleware

• Models vs Controllers vs Routers

• Loading Data On Startup

• Automating Full Stack Applications With NPM

• Serving React Front End (in Production)

• Logging Requests with Morgan

• Serving Applications With Client Side Routing

• Building A Data Access Layer

• Integrating with Frontend, Top Down Approach, Bottom Up Approach

• Updating Our Architecture

8. Testing APIs

• Unit tests vs API tests vs UI tests

• Testing Node APIs with Jest and Supertest

9. Improving Node Performance

• Example app which blocks event loop + real life blocking functions

• Node Cluster Module theory + in action

• Clustering in the real world

• Load balancing

• PM2 theory + in action

• Managing Live Clusters with PM2

• Zero Downtime Restarts

• Improving Performance of NASA Project

• Stateless APIs

• Node Worker Threads

10. Databases

• Using MongoDB to add persistence to NASA Project

• Big focus on NoSQL vs SQL, PostgreSQL vs MongoDB, when to use both including Trends, Object-Relational Mismatch, ACID, References, Schemas. Schema-less vs Schemas

• MongoDB Atlas

• Horizontally Scaling Databases

• Mongoose

• Mongoose Models vs MVC Models

• ObjectIDs in MongoDB

• Pagination

• Choosing A Database For Our NASA API

11. Working With REST APIs

• Demonstrate integrating with a REST API by working with SpaceX API

• Versioning REST APIs

• Running Search Queries

• SpaceX Launch Data

• Mapping API Data to Our Database

• Using Paginated APIs

• Adding Pagination To Our API

12. Authentication

• Focus on Security first principles with JWT, cookies, CSRF

• Servers with HTTPS and SSL / TLS

• Helmet.js

• Working With Auth0

13. Deployment and CI/CD

• Focus on building out a simple CI pipeline for NASA Project on GitHub

• What is CI vs CD?

• Automated tests

• Dynamic configuration with secrets

14. Node Production and the Cloud (AWS)

• Deploy to production with Docker to Amazon EC2

• Virtual Machines

• Serverless vs Containers

• Docker files

• Managing Docker Containers and Images

• Working With SSH

• Production Deployment with PM2 and Mongo Atlas

15. GraphQL

• GraphQL vs REST

• Building a GraphQL API

16. Sockets (WebSockets, Socket io)

• Sockets overview

• Sockets vs polling

• WebSockets (vs Socket io)

• Socket io Client and Server APIs

• Broadcasting Events

• Build out Full Stack Multiplayer Pong with Sockets

• Implementing Pong Game Logic

• Using Socket io With Express.js

• Namespaces and Rooms

17~20.  Bonus Sections on Deno, Advanced Asynchronous JavaScript, SQL, and TypeScript!

This course is not about making you just code along without understanding the principles so that when you are done with the course you don’t know what to do other than watch another tutorial. No! This course will push you and challenge you to go from an absolute beginner in NodeJS to someone that is in the top 10% of NodeJS backend developers. 

We guarantee you this is the most comprehensive online course on Node.js! Have a look at the course outline video to see all the topics we are going to cover, all the projects we’re going to build, and all the techniques you’re going to learn to become a top Node developer!

See you inside!


------------

Taught By:

Andrei Neagoie is the instructor of the highest rated Development courses on Udemy as well as one of the fastest growing. His graduates have moved on to work for some of the biggest tech companies around the world like Apple, Google, Amazon, JP Morgan, IBM, UNIQLO etc... He has been working as a senior software developer in Silicon Valley and Toronto for many years, and is now taking all that he has learned, to teach programming skills and to help you discover the amazing career opportunities that being a developer allows in life. 

Having been a self taught programmer, he understands that there is an overwhelming number of online courses, tutorials and books that are overly verbose and inadequate at teaching proper skills. Most people feel paralyzed and don't know where to start when learning a complex subject matter, or even worse, most people don't have $20,000 to spend on a coding bootcamp. Programming skills should be affordable and open to all. An education material should teach real life skills that are current and they should not waste a student's valuable time.   Having learned important lessons from working for Fortune 500 companies, tech startups, to even founding his own business, he is now dedicating 100% of his time to teaching others valuable software development skills in order to take control of their life and work in an exciting industry with infinite possibilities. 

Andrei promises you that there are no other courses out there as comprehensive and as well explained. He believes that in order to learn anything of value, you need to start with the foundation and develop the roots of the tree. Only from there will you be able to learn concepts and specific skills(leaves) that connect to the foundation. Learning becomes exponential when structured in this way. 

Taking his experience in educational psychology and coding, Andrei's courses will take you on an understanding of complex subjects that you never thought would be possible.  

--------

Adam is one of the instructors at Zero To Mastery, one of the highest rated and fastest growing software development academies on Udemy. He has been working as a senior software developer for many years and has worked for some of the top companies in the world with revenues exceeding $50 billion. Now, Adam aims to instil his students with his love for learning and development, while helping them achieve real world success that extends far beyond the completion of his courses.

Adam walks the walk when it comes to building applications that are secure, scalable, and performant and he is going to share his expertise with you to show you how real world systems are built. He understands what it’s like to go from “hello world” to large scale production deployments and promises to take you on that very same journey. Courses should teach practical skills that are current and should lay a foundation for a future in this incredible and exciting industry. And, having started as a self-taught developer, Adam knows the overwhelming feeling of not knowing where to begin, and the importance of learning from the best available sources.

Drawing from his deep experience, Adam’s courses will show you that you don’t need to spend tens of thousands of dollars to take your flourishing skills into the real world and make a difference.

See you inside the course!

1. Introduction
2. Course Outline
3. Join Our Online Classroom!
4. Exercise: Meet Your Classmates and Instructor
5. Node.js - How We Got Here
6. Node.js Runtime
7. How To Succeed In The Course
8. Latest Version Of Node.js
9. Course Projects + Code + Resources
10. ZTM Resources
11. Node.js Fundamentals: Foundations and Environment Setup
12. OPTIONAL: Installing Node.js
13. OPTIONAL: Windows Installation Tips
14. The Node.js Release Cycle
15. The Node.js REPL
16. Web Developer Monthly
17. Setting Up Our Developer Environment
18. Our First Node.js App
19. Node.js VS JavaScript
20. The global Object
21. Introduction to Backend VS Frontend
22. Monthly Coding Challenges, Free Resources and Guides
23. Node.js Fundamentals: Internals
24. What Node.js Includes
25. Node Internals Deep Dive
26. libuv Internals Deep Dive
27. Synchronous vs Asynchronous
28. Asynchronous Callbacks
29. Non-Blocking Input & Output
30. Exercise: Is JavaScript Asynchronous?
31. Multi-Threading, Processes, and Threads
32. Is Node.js Multi-Threaded?
33. The Event Loop
34. Callback Queues
35. Phases of the Event Loop
36. Comparing Node With PHP and Python
37. What Is Node.js Best At?
38. Observer Design Pattern
39. The Node Event Emitter
40. Recommended Path: Asynchronous JavaScript
41. Node.js Fundamentals: Module System
42. The require Function
43. Making HTTP Requests
44. Why Use Modules?
45. Creating Our Own Modules
46. Exporting From Modules
47. CommonJS vs ECMAScript Modules
48. Creating Our Own ECMAScript Modules
49. Module Caching
50. Using index.js
51. Should We Use index.js?
52. Node.js Fundamentals: Package Management
53. NPM: The Node Package Manager
54. Creating Our First NPM Package
55. Packages And The NPM Registry
56. Using Third Party Modules
57. The node_modules Folder
58. Semantic Versioning
59. package-lock.json and Versioning
60. Vulnerabilities In Dependencies
61. Installing NPM Tools: nodemon
62. LinkedIn Endorsements
63. Node.js File I/O - Planets Project
64. Code For This Section
65. Exploring Planets With Node
66. Importing Kepler Space Telescope Data
67. Setting Up Our CSV Parser
68. Latest Version of CSV Parser
69. Streaming Large Data Files
70. Reading Our Planets Data
71. Parsing Our Planets Data
72. Finding Habitable Planets
73. Exploring Habitable Planets
74. Web Servers with Node.js
75. Code For This Section
76. What is a Web Server?
77. Introduction to HTTP Responses and Requests
78. HTTP Requests
79. HTTP Responses
80. Our First Webserver
81. HTTP APIs and Routing
82. Parameterized URLs
83. Same Origin Policy
84. Exercise: Same Origin Policy
85. Cross Origin Resource Sharing (CORS)
86. POSTing Data to the Server
87. Requests and Responses as Streams
88. Web Servers Recap
89. First Express.js API
90. Code For This Section
91. Why Express?
92. Introduction to Express
93. Express vs Next.js vs Koa
94. Route Parameters
95. Postman and Insomnia
96. Development Dependencies
97. Middleware
98. Writing Our Own Logging Middleware
99. POST Requests in Express
100. Model View Controller (MVC)
101. Model View Controller in Express
102. Express Routers
103. RESTful APIs
104. Create Read Update and Delete (CRUD)
105. Sending Files
106. Serving Websites With Node
107. Templating Engines
108. Layouts and Separation of Concerns
109. NASA Project
110. Code For This Section
111. Introduction & Architecture
112. NASA Dashboard Front End Setup
113. NASA Dashboard Functionality
114. What You Need To Know
115. React.js Front End Code Walkthrough
116. API Server Setup
117. Environment Variables On Windows
118. GET /planets
119. CORS Middleware
120. Models vs Controllers vs Routers
121. The Planets Model
122. Loading Data On Startup
123. Common Issues With NPM Scripts
124. Automating Full Stack Applications With NPM
125. Serving React.js Front End In Production
126. Setting BUILD_PATH On Windows
127. Logging Requests With Morgan
128. The Launches Model
129. GET /launches
130. Serving Applications With Client Side Routing
131. Working With Data Models: Building a Data Access Layer
132. POST /launches: Creating Launches 1
133. POST /launches: Creating Launches 2
134. POST /launches: Validation For POST Requests
135. Connecting POST /launches With Front End Dashboard
136. DELETE /launches: Aborting Launches 1
137. DELETE /launches: Aborting Launches 2
138. Updating Our Architecture Diagram
139. Exercise: Imposter Syndrome
140. Testing APIs
141. Testing In Node
142. Testing APIs With Jest
143. Testing API Endpoints With Supertest: GET
144. Testing API Endpoints With Supertest: POST
145. Testing API Endpoints With Supertest: Error Cases
146. Improving Node Performance
147. Code For This Section
148. Node Server Performance
149. Building A Simple Blocking Server
150. Real Life Blocking Functions
151. Running Multiple Node Processes
152. The Node Cluster Module
153. Clustering In Action
154. Maximizing Cluster Performance
155. Load Balancing
156. The PM2 Tool
157. Using PM2 To Create Clusters
158. Managing Live Clusters With PM2
159. Zero Downtime Restart
160. Improving Performance Of Our NASA Project
161. Worker Threads
162. Worker Threads In Action
163. Databases
164. Introduction to Databases
165. Recommended Path: SQL
166. Comparing SQL vs NoSQL
167. Database Schemas & Schemaless Databases
168. Choosing a Database for our NASA Project
169. SQL vs MongoDB: Trends and Object-Relational Impedance Mismatch
170. SQL vs MongoDB: Schemas, References, and ACID Transactions
171. Setting up MongoDB Atlas
172. Connecting to MongoDB
173. Connecting with the Latest Version of Mongoose
174. Mongoose
175. Creating Mongoose Schema for Launches
176. Exercise: Creating Mongoose Schema for Planets
177. Reminder: Destination Planets Dropdown
178. Creating Models From Schemas
179. Mongoose Models vs MVC Models
180. Creating and Inserting Documents
181. Finding Documents
182. The Upsert Operation
183. Exploring Data Using Atlas
184. Updating Project Architecture
185. ObjectIDs
186. Excluding Fields From The Response
187. Saving Launches
188. Listing All Launches
189. Referential Integrity
190. Auto Increment In MongoDB
191. Getting Latest Flight Number
192. Scheduling New Launches
193. Investigating A Mongoose Mystery
194. Aborting Launches
195. Aborting with the Latest MongoDB Driver
196. Updating Tests For Mongoose 1
197. Updating Tests For Mongoose 2
198. Fixing A Bug In Jest: Open Handles
199. Working With REST APIs - SpaceX Project
200. Working With SpaceX

More and more teams are choosing GraphQL instead of (or along with) REST for their web APIs. GraphQL queries give clients great flexibility in the way they request data from the server, preventing issues such overfetching or underfetching of data, and allowing multiple resources to be retrieved in a single request.

In this course you'll learn how to use GraphQL both on the server side and in client applications through practical examples in the form of full-stack JavaScript applications. You will be introduced to all the main GraphQL concepts like schema definition, Queries, Mutations, and Subscriptions, as well as to solution to common requirements such as handling authentication/authorization and client-side caching.

The examples use Apollo Server with Node.js and Express on the backend and React on the frontend, with GraphQL-Request first, then Apollo Client as GraphQL clients. GraphQL-WS is used for subscriptions.

The aim however is not just to cover specific GraphQL libraries, but to give you a more general understanding of the underlying concepts. For instance, GraphQL client libraries are introduced only after learning how to write a simple client "by hand", to make sure you understand the GraphQL over HTTP format.

This course assumes good knowledge of modern JavaScript, and ideally some familiarity with Node.js/Express and React.

1. Introduction
2. What is GraphQL
3. Required Tools
4. Course Advice
5. Fundamentals
6. Schema Definition
7. Apollo Server
8. Query Language
9. GraphQL Over HTTP
10. GraphQL Client
11. Github Repository
12. Final Code
13. Schema
14. Job Board Architecture
15. Job Board Project
16. Github Repository
17. Apollo Server with Express
18. Custom Object Types
19. Arrays and Non-Nullability
20. Database Access
21. Field Resolvers
22. Resolver Chain
23. Documentation Comments
24. Object Associations
25. Queries
26. Starting Code
27. GraphQL-Request
28. Component State in React
29. Query Arguments
30. Query Variables
31. Exercise: Company by ID
32. Bidirectional Associations
33. Recursive Queries
34. Errors
35. Starting Code
36. GraphQL Errors
37. Custom Errors
38. Request States
39. Mutations
40. Starting Code
41. Mutations
42. Input Types
43. Aside: Database Reset
44. Mutation Requests
45. Exercise: Delete Job
46. Exercise: Update Job
47. Authentication
48. Starting Code
49. Authentication Flow
50. Resolver Context
51. User-Company Association
52. Client Authentication
53. Secure Delete
54. Exercise: Secure Update
55. Where to Authenticate
56. Caching with Apollo Client
57. Starting Code
58. Apollo Client Features
59. Apollo Client Setup
60. Query Method
61. Mutate Method and Auth Link
62. Apollo Client Cache
63. Fetch Policies
64. Cache Manipulation
65. Fragments
66. Apollo React Integration
67. Starting Code
68. useQuery Hook
69. React Custom Hooks
70. Exercise: useJob and useJobs
71. useMutation Hook
72. useMutation Result
73. Exercise: useCreateJob
74. Data Loaders
75. Starting Code
76. N+1 Query Problem
77. Batching with DataLoader
78. Per-Request Cache
79. Pagination
80. Starting Code
81. Pagination Strategies
82. Ordering
83. Limit Clause
84. Offset Clause
85. Basic Pagination UI
86. Total Count
87. Full Pagination UI
88. Final Code
89. Subscriptions
90. Chat Project
91. Github Repository
92. Cache updateQuery
93. Subscription Definition
94. GraphQL-WS Server
95. Subscription Resolver
96. GraphQL-WS Client
97. useSubscription Hook
98. WebSocket Protocol
99. Connection Params
100. WebSocket Server Auth
101. Final Code
102. TypeScript Code Generation
103. Job Board TypeScript Project
104. Github Repository
105. Server Code Generator
106. Typed Resolvers
107. Typed Context
108. Watch Mode
109. Client Code Generator
110. Typed Queries
111. Final Code
112. Conclusion
113. Congratulations and Bonus

***** Some Reviews From Students *****

• best course on graphql. learned a lot.

• learning in simple words and explained very well. thanks

• A very good introductory course to learn GraphQL from scratch and implementing the backend in Java using Spring.

• Very informative. Easy concept explanations and equally well practicals.

In this course you are going to learn to GraphQL With Spring Boot and Spring Data JPA.

Now a days Spring framework is widely used among Java Developers and specifically Spring Boot is in high demand to develop REST APIs.

The problem with REST APIs is that it is giving fixed response in the format of the JSON ( JavaScript Object Notation ). So there comes GraphQL in picture. GraphQL provides flexibility that in request itself we can ask which fields we want in response and it populates only those fields.

In simple words we can say select * query in SQL database is like REST API while ability to provide columns (fields) with query and to return only those fields is GraphQL.

GraphQL boosts performance of your application and it gives consumers flexibility that which attributes they want in response. REST API has problem of under and over fetching of data because of fixed structure of response and GraphQL eliminates this by providing only those attributes which are asked in the request.

In this course you will learn GraphQL in detail with Spring Boot and Spring Data JPA using MySQL database. In this course you will learn :-

• What is GraphQL ?

• Difference between GraphQL and REST API

• What is Query in GraphQL ?

• What is Mutation in GraphQL ?

• What is Schema in GraphQL ?

• What is Resolver in GraphQL ?

• What is Edge in GraphQL ?

In this course you will learn to create GraphQL Query and Mutation with Spring Boot. You will learn to create Resolver with Edge in Spring Boot.

Project lombok is used to avoid boiler plate code in your Java Application. In this course you learn how to use Project Lombok with Spring Boot Application and you will learn -

• How to have getter methods for Java Class using @Getter Annotation.

• How to have setter methods for Java Class using @Setter Annotation.

• How to have constructor for Java Class using @NoArgsConstructor and @AllArgsConstructor Annotations.

After finishing the course you will be able write GraphQL queries as shown in Promo video and also you will be able to deploy your GraphQL-Spring Boot Application to Heroku which is Cloud Platform.

Lets start journey of GraphQL with Spring Boot and Spring Data JPA.

Course Topics & Lectures :-

Introduction

• Introduction

• Altair GraphQL Client

Introduction To GraphQL

• What is GraphQL ?

• What is GraphQL Query ?

• What is GraphQL Mutation ?

• What is GraphQL Schema ?

• GraphQL vs REST API

Project Lombok With Spring Boot

• What is Lombok and Why We Need Lombok ?

• Spring Boot App For Lombok

• Lombok Installation

• Getters and Setters With Lombok

• Constructors With Lombok

Getting Started With GraphQL

• Spring Boot App with REST APIs

• Setting Up Spring Boot App with GraphQL

• Writing First Query with GraphQL

• Defining GraphQL Schema

• Run Query with GraphQL and Spring Boot

• Running GraphQL Query with AltAir plugin

GraphQL Query

• GraphQL with Input Data

• JSON Inputs For GraphQL Query

• Validations with GraphQL Schema

• Change URL Of Application

GraphQL Query With Spring Data JPA

• GraphQL App with Spring Data JPA

• GraphQL Query with Response Model Class

• Flexibility Of Response with GraphQL Query

• Get List Of Data with GraphQL Query

GraphQL Resolver

• What is Resolver in GraphQL ?

• Creating First Resolver with GraphQL

• Getting Data with GraphQL Resolver

• More with GraphQL Resolver

GraphQL Edges

• What is Node and Edge in GraphQL ?

• Why Need Data Filter On Edge ?

• Data Filter with GraphQL Edge

• Get Filtered Data with GraphQL Edge

• Get All Data with GraphQL Edge and Filter

GraphQL Mutation

• Create Mutation with GraphQL

• Mutation Input Schema with GraphQL

• Running First Mutation with GraphQL

More with GraphQL Query

• Enum As Input For Query

• Enum In GraphQL Schema

• Query Data By Enum

GraphQL-Spring Boot Deployment to Heroku (Cloud Platform)

• Introduction To Heroku

• Create Account On Heroku

• Verify Account On Heroku

• Download and Install Git

• Download & Install Heroku CLI

• Create Heroku Application

• Getting MySQL Database on Heroku

• Uploading data From Local MySQL to Heroku MySQL (SQL Dumping)

• Heroku CLI Login

• Deploy Spring Boot App On Heroku

• Check Logs For Heroku Application

• Heroku Application Settings

GraphQL Variable

• What is GraphQL Variable ?

• GraphQL Variable with Query

• GraphQL Variable with Mutation

• Multiple GraphQL Variables

GraphQL Client with Spring Boot

• Updating GraphQL App with Latest Versions

• Introduction To GraphQL Client

• Create GraphQL Client Spring Boot App

• GraphQL Client To Call GraphQL Query

• GraphQL Client with Variable

• GraphQL Client To Call GraphQL Mutation

1. Introduction
2. Introduction
3. Altair GraphQL Client
4. Introduction To GraphQL
5. What is GraphQL ?
6. What is GraphQL Query ?
7. What is GraphQL Mutation ?
8. What is GraphQL Schema ?
9. GraphQL vs REST API
10. Project Lombok With Spring Boot
11. What is Lombok and Why We Need Lombok ?
12. Spring Boot App For Lombok
13. Lombok Installation
14. Getters and Setters With Lombok
15. Constructors With Lombok
16. Getting Started With GraphQL
17. Spring Boot App with REST APIs
18. Setting Up Spring Boot App with GraphQL
19. Writing First Query with GraphQL
20. Defining GraphQL Schema
21. Run Query with GraphQL and Spring Boot
22. Running GraphQL Query with AltAir plugin
23. GraphQL Query
24. GraphQL with Input Data
25. JSON Inputs For GraphQL Query
26. Validations with GraphQL Schema
27. Change Default URLs Of GraphQL Application
28. GraphQL Query With Spring Data JPA
29. GraphQL App with Spring Data JPA
30. GraphQL Query with Response Model Class
31. Flexibility Of Response with GraphQL Query
32. Get List Of Data with GraphQL Query
33. GraphQL Resolver
34. What is Resolver in GraphQL ?
35. Creating First Resolver with GraphQL
36. Getting Data with GraphQL Resolver
37. More with GraphQL Resolver
38. GraphQL Edges
39. What is Node and Edge in GraphQL ?
40. Why Need Data Filter On Edge ?
41. Data Filter with GraphQL Edge
42. Get Filtered Data with GraphQL Edge
43. Get All Data with GraphQL Edge and Filter
44. GraphQL Mutation
45. Create Mutation with GraphQL
46. Mutation Input Schema with GraphQL
47. Running First Mutation with GraphQL
48. GraphQL-Spring Boot Deployment to Heroku (Cloud Platform)
49. Course Update
50. Spring Boot Version
51. Introduction To Heroku
52. Create Account On Heroku
53. Verify Account On Heroku
54. Download and Install Git
55. Download & Install Heroku CLI
56. Create Heroku Application
57. Getting MySQL Database on Heroku
58. Uploading data From Local MySQL to Heroku MySQL (SQL Dumping)
59. Heroku CLI Login
60. Deploy Spring Boot App On Heroku
61. Check Logs For Heroku Application
62. Heroku Application Settings
63. GraphQL with Postman Client
64. GraphQL Query with Postman
65. GraphQL Variable
66. What is GraphQL Variable ?
67. GraphQL Variable with Query
68. GraphQL Variable with Mutation
69. Multiple GraphQL Variables
70. GraphQL Client with Spring Boot
71. Updating GraphQL App with Latest Versions
72. Introduction To GraphQL Client
73. Create GraphQL Client Spring Boot App
74. GraphQL Client To Call GraphQL Query
75. GraphQL Client with Variable
76. GraphQL Client To Call GraphQL Mutation
77. Thank You....
78. Bonus Lecture
79. Thank You....