CF

Modern GraphQL with Node - Complete Developers Guide

10h 41m 32s
English
Paid

Unlock the full potential of modern GraphQL with Node.js through this comprehensive course. Whether you're a seasoned developer or just starting out, this course will equip you with the skills to build a robust GraphQL API from the ground up. Taught by an experienced developer with over three years of real-world GraphQL experience in enterprise settings, you'll finish this crash course knowing more than most GraphQL hobbyists. Not only will you learn GraphQL, but you'll also master its implementation in real-world applications. Get ready for an engaging learning journey!

Course Overview

This course is designed for beginners, so no prior GraphQL knowledge is required. However, as we will be using JavaScript as our primary programming language, a basic understanding of JavaScript is recommended. Additionally, we will connect our server to the frontend using React; hence, familiarity with frontend frameworks is beneficial but not essential.

What You'll Learn

  • Introduction to GraphQL: Understand what GraphQL is and its core benefits.
  • GraphQL Terminology: Familiarize yourself with essential GraphQL terms and concepts.
  • Building a GraphQL Server: Learn how to set up and deploy a GraphQL server.
  • Modern Design Principles: Discover contemporary design practices for building scalable applications.
  • Adding Authentication: Implement secure authentication mechanisms within your application.
  • Working with Prisma v3: Use Prisma v3 to interact seamlessly with a PostgreSQL database.
  • Client Connectivity: Link your GraphQL server with the client using React.
  • Optimizing Performance: Enhance application performance by understanding and solving the n + 1 query problem using data loaders.

About the Author: Udemy

Udemy thumbnail

Udemy is the largest open marketplace for online courses on the internet. Founded in 2010 by Eren Bali, Oktay Caglar, and Gagan Biyani and headquartered in San Francisco, the company went public on the Nasdaq in 2021 under the ticker UDMY. The platform hosts well over two hundred thousand courses across software development, IT and cloud, data science, design, business, marketing, and creative skills, taught by tens of thousands of independent instructors. Roughly seventy million learners use it worldwide, and the corporate arm — Udemy Business — supplies a curated subset of that catalog to enterprise customers.

Because Udemy is a marketplace rather than a single editorial publisher, the catalog is uneven by design. The strongest material lives in the long-form, project-based courses authored by working engineers — full-stack JavaScript, React, Node.js, Python data science, AWS, Docker and Kubernetes, mobile development with Flutter and React Native, and cloud certification preparation. The CourseFlix listing under this source is the slice of that catalog that has been mirrored here for offline-friendly viewing, organized by topic and updated as new releases land. Pricing on Udemy itself swings dramatically with the site's near-permanent sales, which is why the platform is best treated as a deep reference catalog: pick instructors with strong reviews and a track record of updating their material rather than buying on the headline price alone.

Watch Online 85 lessons

This is a demo lesson (10:00 remaining)

You can watch up to 10 minutes for free. Subscribe to unlock all 85 lessons in this course and access 10,000+ hours of premium content across all courses.

View Pricing
0:00
/
#1: What is GraphQL
All Course Lessons (85)
#Lesson TitleDurationAccess
1
What is GraphQL Demo
03:18
2
GraphQL Prevents Over-Fetching
06:11
3
GraphQL Prevents Under-Fetching
04:04
4
How Data is Organized
03:36
5
Local Environment Setup
02:39
6
Setting up a GraphQL Server
15:25
7
GraphQL Scalar Types
08:31
8
GraphQL Array Types
04:42
9
Nodemon for Hot Reloading
02:16
10
GraphQL Object Types
06:39
11
Querying an Array of Objects
02:54
12
Querying One Object with Variables
08:32
13
Queries for Categories
11:01
14
Relating Data (One to Many)
10:13
15
Relating Data (Many to One)
06:21
16
Reorganizing for a Better File Structure
09:00
17
The Context Param
06:00
18
Adding the Ability to Query for Reviews
09:06
19
Filtering and Input Type
11:26
20
Filter by Average Rating
11:19
21
Intro to Mutations
03:13
22
Creating Data - Part I
07:16
23
Creating Data - Part II
13:23
24
Deleting Data (with Set Null) - Part I
15:41
25
Deleting Data (with Delete Cascade) - Part II
06:54
26
Deleting Data - Part III
02:27
27
Updating Data - Part I
09:16
28
Updating Data - Part II
08:19
29
Introduction to GraphQL Design
09:57
30
A Naive Implementation
08:36
31
Rule 1 - Start with a High Level View of the Objects and Their Relationships
03:11
32
Rule 2 - Never Expose Implementation Details
02:34
33
Rule 3 - Design your API Around your Business Domain
03:22
34
Rule 4 - It's Easier to Add Fields than to Remove Them
03:01
35
Rule 5 - Group Closely-Related Fields Together into Sub-Objects
02:45
36
Rule 6 - Always Check if a List Should be Paginated
03:34
37
Rule 7 - Always use Object References Instead of ID Fields
01:50
38
Rule 8 - Choose Field Names Based on What Makes Sense, Not the Implementation
01:13
39
Rule 9 - Use Enums for Fields that can Only Take a Specific Set of Values
01:45
40
Rule 10 - Your API Should Provide Business Logic, Not Just Data
03:05
41
Rule 11 - Write Separate Mutations for Separate Logical Actions on a Resource
02:19
42
Rule 12 - For Relationship Mutations Consider Operating on Multiple Elements
01:36
43
Rule 13 - Prefix Mutation Names with the Object for Alphabetical Grouping
05:34
44
Rule 14 - Structure Mutation Inputs to Reduce Duplication
04:04
45
Rule 15 - Mutations Should Provide User/Business Level Errors
03:13
46
A New Project
05:38
47
A Little About TypeScript
04:50
48
Setting up TypeScript
07:52
49
Setting up an Apollo Server
09:57
50
A Little About SQL Databases
06:41
51
Spinning up a Postgres Instance
05:14
52
Connecting to Our Database with Prisma
06:37
53
Creating a Database Schema
10:38
54
Adding Entity Relationships
09:07
55
Defining Our GraphQL Schema
21:38
56
Creating Data with Prisma
09:28
57
Retrieving Data with Prisma
05:04
58
Updating Data with Prisma
21:17
59
Deleting Data with Prisma
06:19
60
What is Authentication & Authorization
03:37
61
A Naive Signup Implementation
11:37
62
Validating the Inputs
11:36
63
Password Hashing
15:16
64
Json Web Tokens
12:36
65
Creating a User Profile
02:12
66
Adding the Sign In Mutation
12:44
67
Identifying Users with JWT
13:22
68
Authorizing Users with JWT
10:39
69
Adding Publish/Unpublish Logic
07:11
70
The Me Query
05:20
71
The Profile Query
08:49
72
Relational Post Queries
11:39
73
The N + 1 Problem
07:47
74
Batching and Catching Queries
05:55
75
Adding a DataLoader to Improve Performace
13:43
76
Introduction to Client Connect
04:25
77
Connect the Client to GraphQL with Apollo Client
05:51
78
Querying From the Frontend
11:47
79
Querying with Variables
10:47
80
Conditional Rendering Based on Authentication Status
03:21
81
Passing the Auth Token From the Frontend
06:50
82
Executing Mutations From the Frontend
13:25
83
Adding Signin/Signup Logic
17:54
84
Adding Logic to Create a Post
10:39
85
The Last Steps
00:49
Unlock unlimited learning

Get instant access to all 84 lessons in this course, plus thousands of other premium courses. One subscription, unlimited knowledge.

Learn more about subscription

Related courses

Frequently asked questions

What are the prerequisites for this course?
The course is designed for beginners with no prior GraphQL experience required. However, a basic understanding of JavaScript is recommended since it is the primary programming language used. Familiarity with frontend frameworks, such as React, is beneficial but not essential, as the course will involve connecting the GraphQL server to the frontend.
What kind of projects will I build during the course?
Throughout the course, you will build a robust GraphQL API from the ground up. This includes setting up and deploying a GraphQL server, implementing secure authentication, and interacting with a PostgreSQL database using Prisma v3. You'll also learn to define and manage a GraphQL schema and deal with various data operations such as creating, updating, and deleting data.
Who is the target audience for this course?
The course is ideal for developers who are new to GraphQL and wish to understand its core principles and applications. It caters to both beginners and seasoned developers looking to expand their knowledge of building scalable applications using modern design principles and GraphQL APIs.
How does this course compare to other GraphQL courses in terms of depth and scope?
This course offers a comprehensive introduction to GraphQL, covering key aspects such as setting up a GraphQL server, implementing authentication, and using Prisma v3 for database interactions. It provides both theoretical and practical insights into GraphQL design principles, making it suitable for those looking to gain a deep understanding of building APIs compared to more superficial introductions elsewhere.
What specific tools or platforms will I learn to use?
Students will learn to use several tools and platforms, including Node.js for building the server, React for frontend integration, Prisma v3 for database interactions, and PostgreSQL for managing data. The course also covers the use of TypeScript, Apollo Server, and various GraphQL features such as scalar and object types.
What topics are not covered in this course?
The course does not cover advanced frontend development or in-depth JavaScript programming beyond what's necessary for integrating GraphQL with React. It also does not delve deeply into other database systems or backend frameworks outside of the context of GraphQL and Prisma with PostgreSQL.
How much time should I expect to commit to this course?
The course consists of 85 lessons, each designed to guide you through different aspects of GraphQL and its implementation. While there is no specified total runtime, students should be prepared to dedicate several hours per week to fully engage with the lessons, complete exercises, and apply the learned concepts in practice projects.