Schema linting in GraphQL - Step-by-Step Execution

Concept Flow - Schema linting

Start: Load GraphQL schema

↓

Parse schema syntax

↓

Check for linting rules violations

↓

Report errors

↓

Fix errors and re-lint

↓

End

The schema linting process loads the GraphQL schema, parses it, checks for rule violations, reports errors if any, and repeats until the schema is clean.

Execution Sample

GraphQL

type Query {
  user(id: ID!): User
}

type User {
  id: ID!
  name: String
  age: Int
}

This schema defines a Query type with a user field and a User type with id, name, and age fields.

Execution Table

Step	Action	Evaluation	Result
1	Load schema text	Schema text loaded	Schema text ready for parsing
2	Parse schema syntax	Syntax valid	AST (Abstract Syntax Tree) created
3	Check lint rule: Field names lowercase	user, id, name, age all lowercase	No violation
4	Check lint rule: Required fields have !	id has !, user id argument has !	No violation
5	Check lint rule: Types defined	User type defined	No violation
6	Check lint rule: No duplicate type names	Only Query and User types	No violation
7	All lint rules passed?	Yes	Schema is clean
8	End	No errors found	Linting complete

💡 All linting rules passed, schema is clean and valid

Variable Tracker

Variable	Start	After Step 2	After Step 7	Final
schema_text	empty	loaded	loaded	loaded
AST	none	created	created	created
lint_errors	none	none	none	none

Key Moments - 3 Insights

Why does linting check if field names are lowercase?

Because GraphQL best practices recommend lowercase field names for consistency and readability, as shown in execution_table step 3 where all field names are checked.

What happens if a required field is missing the '!' mark?

Linting will report an error because required fields must have '!' to indicate non-nullability, as checked in execution_table step 4.

Why is it important to check for duplicate type names?

Duplicate type names cause conflicts in the schema, so linting ensures uniqueness as in execution_table step 6.

Visual Quiz - 3 Questions

Look at the execution table, at which step is the schema parsed into an AST?

A Step 2

B Step 1

C Step 3

D Step 4

💡 Hint

Refer to execution_table row with 'Parse schema syntax' action

According to variable_tracker, what is the state of lint_errors after step 7?

A not checked yet

B none

C some errors

D cleared

💡 Hint

Check lint_errors row in variable_tracker after 'After Step 7' column

If the schema had a duplicate type name, which step in the execution_table would report it?

A Step 3

B Step 4

C Step 6

D Step 7

💡 Hint

Look for the step checking duplicate type names in execution_table

Concept Snapshot

Schema linting checks a GraphQL schema for style and correctness.
Load schema -> Parse syntax -> Check rules (field names, required fields, duplicates) -> Report errors.
Repeat until no errors.
Ensures clean, consistent, and valid schema.

Full Transcript

Schema linting is the process of checking a GraphQL schema for errors and style issues. First, the schema text is loaded. Then it is parsed into an abstract syntax tree (AST). Next, linting rules are applied, such as verifying field names are lowercase, required fields have the '!' mark, and type names are unique. If any errors are found, they are reported so the developer can fix them. This process repeats until the schema passes all checks and is clean. This ensures the schema is consistent, readable, and valid for use in GraphQL APIs.