Top 8 Recommended GraphQL Self-Study Materials! [November 2024]

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

Just FULLY updated and re-recorded with all new React features (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. 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

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

Note: This course assumes you are familiar with React!

If you're tired of spinning your wheels trying to figure out what type of backend server to use, this is the course for you.

Authentication? You will learn it.  Apollo Data? Included.  Integration with React? Of course!

This course will get you up and running with GraphQL quickly, and teach you the core knowledge you need to deeply understand and build React applications quickly.

Both OSX and Windows supported.

We'll start by mastering the fundamentals of GraphQL, including data types, schemas, and integration with Express and React. Source code is provided for each lecture, so you will always stay up-to-date with the course pacing.  Special attention has been paid to creating code that you'll be able to make use of on your own fantastic projects.

If you are new to GraphQL, or if you've been working to learn it but sometimes feel like you still don't quite 'get it', this is the GraphQL course for you! To learn GraphQL you have to understand it.

• Learn how to use GraphQL's schema to define relations between your data objects
• Learn the process of combining a backend server with a front end React
• Master the process of thinking about your applications data in terms of a graph structure
• Grasp the difference between GraphQL, Apollo, and Relay, and when to use each
• Develop apps that are unique, fun, and responsive.
• Build servers that can be used with both React and React Native applications
• Master handling authentication with GraphQL
• Learn the core principles of navigation with React Router and GraphQL

I've built the course that I would have wanted to take when I was learning GraphQL. A course that explains the concepts and how they're implemented in the best order for you to learn and deeply understand them.

1. Why GraphQL?
2. Introduction
3. Join Our Community!
4. A REST-ful Routing Primer
5. Review of REST-ful Routing
6. Shortcomings of RESTful Routing
7. On To GraphQL
8. What is GraphQL?
9. Working with GraphQL
10. TypeError: expressGraphQL is not a function
11. Registering GraphQL with Express
12. GraphQL Schemas
13. Writing a GraphQL Schema
14. Root Queries
15. Resolving with Data
16. The GraphiQL Tool
17. A Realistic Data Source
18. Async Resolve Functions
19. Nodemon Hookup
20. Company Definitions
21. Fetching Data with Queries
22. Nested Queries
23. More on Nested Queries
24. A Quick Breather
25. Multiple RootQuery Entry Points
26. Bidirectional Relations
27. More on Bidirectional Relations
28. Resolving Circular References
29. Query Fragments
30. Introduction to Mutations
31. NonNull Fields and Mutations
32. Do It Yourself - Delete Mutation!
33. Do It Yourself - Edit Mutation!
34. The GraphQL Ecosystem
35. GraphQL Clients - Apollo vs Relay
36. Sidenote - Apollo Server vs GraphQL Server
37. Clientside GraphQL
38. The Next App
39. Starter Pack Walkthrough
40. MongoDB Atlas Setup and Configuration
41. MongoLab Setup
42. Working Through the Schema
43. Apollo Client Setup
44. React Component Design
45. GQL Queries in React
46. Bonding Queries with Components
47. Gotchas with Queries in React
48. Handling Pending Queries
49. Fixing Key Warnings
50. Architecture Review
51. Adding React Router
52. Creating a Song
53. Frontend Mutations
54. Mutations in React
55. Query Params
56. Defining Query Variables in React
57. Navigating on Successful Mutation
58. Troubleshooting List Fetching
59. Refetching Queries
60. Deletion by Mutation
61. Associating Mutations with a Component
62. Invoking Delete Mutations
63. Automatic Data Caching
64. Refetching a Query
65. A Quick CSS Breather
66. Showing a Particular Song
67. Fetching Individual Records
68. React Router + GraphQL
69. Integrating React Router with GraphQL
70. Watching for Data
71. Navigating Between Screens
72. Lyric Creation Form
73. The CreateLyric Mutation
74. Submitting Mutations
75. Showing a List of Lyrics
76. Enhancing Queries
77. Identifying Records
78. Caching with DataIdFromObject
79. Thumbs Up Icon
80. More on Client Side Mutations
81. The Like Mutation
82. Showing Likes with Lyrics
83. Fetching Likes
84. Optimistic UI Updates
85. Handling Optimistic Responses
86. A Quick Bugfix
87. Application Wrapup
88. Building From (Mostly) Scratch
89. App Overview
90. App Challenges
91. Boilerplate Setup
92. Authentication Approach
93. MLab Setup
94. The User Type
95. The Signup Mutation
96. Delegating to the Auth Service
97. Testing Signup
98. The Logout Mutation
99. The Login Mutation
100. Checking Authentication Status
101. Moving to Client Side
102. Client Side Setup
103. Root Routes with React Router
104. Figuring Out the Current User
105. Including Cookies with GraphQL Requests
106. Authentication State
107. Login and Logout Buttons
108. Handling the Logout Mutation
109. Automatic Component Rerenders
110. Login Form Design
111. The Auth Form
112. Importing the Login Mutation
113. Submitting the Auth Form
114. Refreshing the Current User
115. Error Handling with GraphQL
116. More on Error Handling
117. The Signup Mutation
118. More on the Signup Mutation
119. Handling Errors Gracefully
120. Handling Errors Around Signup
121. Race Conditions - A Big Gotcha
122. Finalized Auth Flow
123. Fixing the Login Process
124. Fix Signup Too!
125. The Dashboard Route
126. The Need for a HOC
127. Getting Started with RequireAuth
128. Applying RequireAuth
129. Fixing RequireAuth
130. Extras
131. Bonus!

Welcome to the best resource online for learning GraphQL with Python!

In this course you will learn how to build GraphQL APIs to replace standard REST APIs and their limitations. In addition, you will learn about features like authentication, object-relational mapping, version control, and deployment, which go hand in hand with modern application development of GraphQL APIs.

Today GraphQL is used by teams of all sizes in many different environments and languages to power mobile apps, websites, and APIs. From Airbnb and Atlassian to Audi and GitHub, companies the world over are using GraphQL APIs in production. GraphQL has gained significant traction in recent years because it offers a more flexible and efficient approach to data retrieval that addresses over-fetching and under-fetching issues that are common with REST APIs.

This course is for anyone looking to learn GraphQL with Python. It is designed to teach you everything you need to know to build production-ready GraphQL APIs with Python.

In the first 2 hours you will learn the basics of GraphQL, how to build a GraphQL server with Python, and how to expose a web API to interact with it.

This introduction will give you a solid foundation of the core GraphQL concepts like schemas, types, queries, mutations, variables, fragments, directives and more. We will be working with a live GraphQL API, as we explore these concepts through a graphical in-browser IDE, constructing queries and mutations, and exploring result sets in real time.

In the second part of the course we'll delve into more advanced topics, as we integrate our GraphQL applications with cloud-hosted SQL databases, and in the process also gain a practical understanding of the widely-popular SQLAlchemy ORM. We'll define advanced mutations and query capabilities, before we shift our attention to authentication and authorization flows, where we will use JSON web tokens to implement a role-based permissioning system. In the end we will deploy our application as a serverless function to the cloud, for free.

Throughout the course you’ll learn how to:

•     Model your application data using schemas and entities

•     Create queries allowing clients to access data in the database through GraphQL

•     Create mutations allowing clients to create and change data in the database

•     Query and change your data from the browser by making requests with graphical, in-browser IDEs

•     Work with the SQLAlchemy ORM (v2) to communicate with your database

•     Secure your application data with JWT-based authentication and authorization system

•     Deploy your GraphQL applications as serverless functions, for free   

This course assumes you're somewhat familiar with python, but if you're not or haven't programmed in python for a while, there is a full length introduction to the python programming language included as an appendix.

I'm excited to be your instructor. See you inside!

1. A Very Short Introduction
2. GraphQL In 5 Mins
3. Before You Begin
4. Querying A GraphQL API
5. Introduction
6. First GraphQL Query
7. Some GraphiQL Features
8. Selection Sets
9. Arguments
10. Variables
11. Fragments
12. Directives
13. Challenge
14. Solution
15. Setting Up A GraphQL Server With Python
16. Introduction
17. Design Decisions
18. Code-First With Graphene
19. Setting Up
20. Hello, World!
21. Types And Fields
22. Root Values
23. List-Type Field And Resolver
24. Mutations
25. That Was Odd!
26. Updates
27. Challenge
28. Solution
29. Building A GraphQL API
30. Introduction
31. Setting Up
32. The API Backbone
33. POST-ing Via HTTP Client
34. Exposing A Graphical Interface
35. Some Entities
36. Defining A Query Class
37. Field-Level Resolvers
38. Quiz
39. GraphQL Integration With Databases
40. Introduction
41. SQLAlchemy
42. Note: An Alternative Provider
43. Creating A Free Cloud-Based Postgres Database
44. Engines And Connections
45. Tables And Metadata
46. Relationships
47. Sessions
48. Recreate Schema On Startup
49. Code Organization
50. Code Organization II
51. Executing Queries
52. Challenge
53. Solution
54. Parameterized Mutations
55. Introduction
56. Adding New Jobs
57. Updating An Existing Job
58. SQLAlchemy ORM Global Joined Load
59. Get Job By Id
60. Deleting With SQLAlchemy
61. New Employers
62. Code Organization
63. Challenge - Employer By Id
64. Solution
65. Challenge - Update Employer
66. Solution
67. Challenge - Delete Employer
68. Solution
69. The User Entity
70. Challenge - Job Applications
71. Solution
72. Querying Applications From Users And Jobs
73. Implementing JWT-Based Auth Workflows
74. Introduction
75. Authentication vs Authorization
76. User Login
77. Password Hashing
78. Integrating Argon2
79. JSON Web Tokens
80. Generating Tokens On Login
81. Refactoring To utils.py
82. The get_authd_user Helper
83. Circular Import Fix
84. Challenge - User Registration
85. Solution
86. Challenge - Administrator Privileges
87. Solution
88. Decorating @admin_user
89. Decorating Job And Employer Mutations
90. Challenge - ApplyToJob Mutation
91. Solution
92. Challenge - Logged In User
93. Solution
94. Challenge - Logged In As
95. Solution
96. Extra - Generalizing Error Messages
97. Deploying GraphQL Python APIs
98. Introduction
99. Application Files
100. Cloud Options
101. Refactoring Our Config
102. Quick Bug Fix
103. Slight Refactor
104. Git Ignore
105. Creating The Git Repository
106. Uploading To GitHub
107. Deployment
108. New Commits
109. Thank You!
110. Appendix A - Python Programming Crash Course
111. Section Resources
112. Data Types
113. Variables
114. Arithmetic And Augmented Assignment Operators
115. Ints And Floats
116. Booleans And Comparison Operators
117. Strings
118. Methods
119. Containers I - Lists
120. Lists vs Strings
121. List Methods And Functions
122. Containers II - Tuples
123. Containers III - Sets
124. Containers IV - Dictionaries
125. Dictionary Keys And Values
126. Membership Operators
127. Controlling Flow - if, else, And elif
128. Truth Value Of Non-Booleans
129. For Loops
130. The range() Immutable Sequence
131. While Loops
132. Break And Continue
133. Zipping Iterables
134. List Comprehensions
135. Defining Functions
136. Function Arguments - Positional vs Keyword
137. Lambdas
138. Importing Modules