Modern GraphQL with Node – Complete Developers Guide

Course Curriculum

Chapter 1: Introduction to GraphQL

Lecture 1: What is GraphQL

Lecture 2: GraphQL Prevents Over-Fetching

Lecture 3: GraphQL Prevents Under-Fetching

Lecture 4: How Data is Organized

Chapter 2: Queries and Schemas

Lecture 1: Local Environment Setup

Lecture 2: Setting up a GraphQL Server

Lecture 3: GraphQL Scalar Types

Lecture 4: GraphQL Array Types

Lecture 5: Nodemon for Hot Reloading

Lecture 6: GraphQL Object Types

Lecture 7: Querying an Array of Objects

Lecture 8: Querying One Object with Variables

Lecture 9: Queries for Categories

Lecture 10: Relating Data (One to Many)

Lecture 11: Relating Data (Many to One)

Lecture 12: Reorganizing for a Better File Structure

Lecture 13: The Context Param

Lecture 14: Adding the Ability to Query for Reviews

Lecture 15: Filtering and Input Type

Lecture 16: Filter by Average Rating

Chapter 3: Mutations

Lecture 1: Intro to Mutations

Lecture 2: Creating Data – Part I

Lecture 3: Creating Data – Part II

Lecture 4: Deleting Data (with Set Null) – Part I

Lecture 5: Deleting Data (with Delete Cascade) – Part II

Lecture 6: Deleting Data – Part III

Lecture 7: Updating Data – Part I

Lecture 8: Updating Data – Part II

Chapter 4: 15 Rules of GraphQL Design

Lecture 1: Introduction to GraphQL Design

Lecture 2: A Naive Implementation

Lecture 3: Rule 1 – Start with a High Level View of the Objects and Their Relationships

Lecture 4: Rule 2 – Never Expose Implementation Details

Lecture 5: Rule 3 – Design your API Around your Business Domain

Lecture 6: Rule 4 – It's Easier to Add Fields than to Remove Them

Lecture 7: Rule 5 – Group Closely-Related Fields Together into Sub-Objects

Lecture 8: Rule 6 – Always Check if a List Should be Paginated

Lecture 9: Rule 7 – Always use Object References Instead of ID Fields

Lecture 10: Rule 8 – Choose Field Names Based on What Makes Sense, Not the Implementation

Lecture 11: Rule 9 – Use Enums for Fields that can Only Take a Specific Set of Values

Lecture 12: Rule 10 – Your API Should Provide Business Logic, Not Just Data

Lecture 13: Rule 11 – Write Separate Mutations for Separate Logical Actions on a Resource

Lecture 14: Rule 12 – For Relationship Mutations Consider Operating on Multiple Elements

Lecture 15: Rule 13 – Prefix Mutation Names with the Object for Alphabetical Grouping

Lecture 16: Rule 14 – Structure Mutation Inputs to Reduce Duplication

Lecture 17: Rule 15 – Mutations Should Provide User/Business Level Errors

Chapter 5: New Project Setup (Social Media App)

Lecture 1: A New Project

Lecture 2: A Little About TypeScript

Lecture 3: Setting up TypeScript

Lecture 4: Setting up an Apollo Server

Chapter 6: Database Storage with Prisma v3

Lecture 1: A Little About SQL Databases

Lecture 2: Spinning up a Postgres Instance

Lecture 3: Connecting to Our Database with Prisma

Lecture 4: Creating a Database Schema

Lecture 5: Adding Entity Relationships

Lecture 6: Defining Our GraphQL Schema

Lecture 7: Creating Data with Prisma

Lecture 8: Retrieving Data with Prisma

Lecture 9: Updating Data with Prisma

Lecture 10: Deleting Data with Prisma

Chapter 7: Authentication and Authorization

Lecture 1: What is Authentication & Authorization

Lecture 2: A Naive Signup Implementation

Lecture 3: Validating the Inputs

Lecture 4: Password Hashing

Lecture 5: Json Web Tokens

Lecture 6: Creating a User Profile

Lecture 7: Adding the Sign In Mutation

Lecture 8: Identifying Users with JWT

Lecture 9: Authorizing Users with JWT

Lecture 10: Adding Publish/Unpublish Logic

Chapter 8: Adding Data Relationships

Lecture 1: The Me Query

Lecture 2: The Profile Query

Lecture 3: Relational Post Queries

Chapter 9: Dataloaders and the N + 1 Problem

Lecture 1: The N + 1 Problem

Lecture 2: Batching and Catching Queries

Lecture 3: Adding a DataLoader to Improve Performace

Chapter 10: Connecting to the Frontend

Lecture 1: Introduction to Client Connect

Lecture 2: Connect the Client to GraphQL with Apollo Client

Lecture 3: Querying From the Frontend

Lecture 4: Querying with Variables

Lecture 5: Conditional Rendering Based on Authentication Status

Lecture 6: Passing the Auth Token From the Frontend

Lecture 7: Executing Mutations From the Frontend

Lecture 8: Adding Signin/Signup Logic

Lecture 9: Adding Logic to Create a Post

Lecture 10: The Last Steps