Building Web APIs with GraphQL - The Complete Guide

Define an API as an application programming interface that enables communication among software components via a defined interface; show how applications expose the API for other software to access data.

Explore the four main api flavors: operating system api, library api, remote api, and web api, and learn how web api enables cross-platform communication over standard protocols.

Recognize why an API is essential for back-end software, enabling mobile apps and the user interface to access data, extend reach, and support monetization.

Design a well designed, easy to use, and consistent API to delight developers, outshine competitors, and reduce support needs by ensuring clarity and reliability.

Explore web APIs as the most popular, platform-agnostic interfaces that use http requests and responses. Compare soap, rest, GraphQL, and gRPC by their json, xml, and content formats.

Explore soap, the simple object access protocol designed in 1998 for Microsoft, an xml-based, rpc-style protocol that is outdated and mainly used with legacy soap endpoints.

Explore rest, or representational state transfer, a message-based, entity-centric web api built on http, using urls and json to perform create, read, update, and delete operations.

Explore GraphQL as the next web api type and the course’s core subject, then dive into in-depth discussions in the upcoming section.

Learn gRPC, built on HTTP/2 for bidirectional streaming and duplex messaging. It uses Protobuf for serialization across platforms and requires code generators and specialized libraries, delivering high performance.

Explains the problems of rest, its fixed entity structure and request-response only pattern, and shows how GraphQL enables querying specific fields to reduce data load and latency.

Trace the history of GraphQL, from Facebook's internal REST API replacement to the open-sourced specification and governance by the GraphQL Foundation.

GraphQL is a specification, not an implementation, that defines a JSON-based data structure and supports retrieving, mutating, and subscribing to data through a schema-based, cross-platform API.

Define the schema and its entities, then specify the queries. Add optional mutations and subscriptions, and implement the logic behind all operations to work with GraphQL.

Set up your development environment by installing the dotnet sdk, nodejs, and vscode with extensions to prepare for building web APIs with GraphQL.

Download the dotnet sdk for Windows, install dotnet 6.0 x64, then verify the installation by running dotnet --version to confirm success.

Install NodeJS by visiting nodejs.org download, run the installer for your OS, finish setup, and verify the installation with node --version in the command prompt.

Install and configure VS Code as the primary code editor for the NOP system, including Windows 64-bit installation, and add the Microsoft C# extension for dotnet development.

download and run the graphQL demo app, explore queries with the hot chocolate playground, and verify live results by editing books.json.

Explore how GraphQL defines its schema, the essential first step when working with GraphQL, and why the framework cannot work without a schema.

Learn how GraphQL schema defines the shape of data, including objects like book with fields id, name, and pages, and how it governs queries, mutations, and subscriptions with SDL.

Explore object types and fields in GraphQL, define the book type with scalar and custom fields like price and publish date, and see how the schema auto-builds from code.

Define a new GraphQL object type and add it to the model. Add an author field (id and name) to the book as optional, seed data, then query the author.

Identify non-nullable fields in GraphQL schemas marked by exclamation marks and learn to make a field optional by adding a question mark in code, then verify through a schema update.

Define a non-nullable GraphQL book genre enum with horror, fantasy, drama, thriller, and non-fiction, apply it to the book class as genre, and observe the schema and default horror value.

Explore modeling lists in graphQL by adding a review class and a book reviews list, learn non-nullable and nullable list handling, and validate queries in the playground.

Explore GraphQL interfaces by defining a reading materials interface and implementing it with book and magazine types, then query across the interface to retrieve both books and magazines.

Explain unions in GraphQL by using a marker interface to group books and magazines, then query the union named things to fetch type-specific fields.

Learn to run GraphQL queries against a built schema, explore the purpose of the schema, and master the syntax and basics of querying.

Learn the basics of GraphQL queries by selecting specific fields from books and related author objects, and by detailing which fields to retrieve for each object.

Learn how to specify operation type and name in GraphQL queries to improve clarity, debugging, and logging, by using the query keyword and named operations in the playground.

Learn how to implement GraphQL query arguments to filter books by name using a name contains argument with a default empty string and update the schema.

Use variables to pass argument values in GraphQL queries without changing the query; define a string variable and reference it in the name contains filter, set values in variables section.

Learn how aliases let you run multiple queries in a single request, avoid conflicts when the same object type appears more than once, and name results after their aliases.

Learn how GraphQL fragments define reusable field sets, use the book fields fragment, and apply it in queries to retrieve concise, consistent data.

Learn how GraphQL directives such as include and skip dynamically shape queries by using boolean variables to conditionally fetch fields, including author and genre via fragments.

Explore how inline fragments extend interface queries to fetch type-specific fields in GraphQL, using the three-dot syntax to request pages for books and issue numbers for magazines.

Learn how meta fields and introspection reveal the object type in GraphQL queries, using the type name field to identify whether results are books or magazines.

Explore GraphQL schema introspection to discover object types, fields, and descriptions, and learn to query __schema and __type to inspect a specific type like book.

Explore how GraphQL mutations change data beyond queries, and learn why mutations are the topic of this section.

Discover GraphQL mutation syntax, highlighting the three parts of a mutation request—the mutation object type, the arguments for creating or modifying objects, and the returned data and the input type.

Discover how input types pass complex data to GraphQL mutations, define them in code, and use them to create a new book with name, pages, price, publish date, and genre.

Add a GraphQL mutation by placing mutation.cs in the project; it reads books.json, creates a new book from book input, writes JSON, and updates schema to expose the mutation.

Learn to perform a GraphQL mutation with the add book operation, define a book input variable, and return the book id, name, and pages.

Explore the subscription syntax by examining the three core parts—the subscription object type, the subscription name, and the returned data—and learn to define and configure subscriptions in code.

Define a GraphQL subscription named book added, returning a book object to clients, configure the schema to use the subscription type, initialize in-memory subscriptions, and enable websockets for client–server updates.

Implement and test a GraphQL subscription that sends a book object to subscribers whenever a new book is added, using a sender and the book added event.

Develop a GraphQL based system by implementing the server and the client; the server exposes the GraphQL endpoint and returns results, while the client sends operations and handles results.

Learn the core roles of a GraphQL server, including defining the schema, exposing a single GraphQL endpoint, validating operations, routing root operations to code via resolvers, and returning GraphQL results.

Configure a GraphQL server in dotnet with Hot Chocolate, create an empty web app, add the library, wire GraphQL services, and enable the GraphQL playground.

Develop a GraphQL schema in dotnet by building a Book class, creating a query type, and implementing resolvers with Hot Chocolate to expose readable publish dates.

Develop a GraphQL server in node js using Apollo, defining a simple schema and resolvers to fetch books from a JSON database, run on localhost:4000 with the Apollo playground.

Define a Node.js field resolver for the book name to return the name in square brackets, using parent, args, context, and info in a GraphQL Apollo server.