apollo-tooling

Validates GraphQL client operations (queries, mutations, subscriptions) against a GraphQL schema by parsing operation documents and comparing them against schema definitions. Uses a compiler-based approach that normalizes operations into an intermediate representation, then checks field existence, argument types, fragment spreads, and return types. Integrates with Apollo Studio for schema retrieval and caching.

Generates fully-typed TypeScript interfaces and types from GraphQL operation documents by parsing operations, resolving them against a schema, and emitting TypeScript AST that maps GraphQL types to TypeScript equivalents. Handles nested fragments, unions, interfaces, and custom scalars through a multi-pass compilation pipeline. Generates both operation result types and variable input types with proper null-safety semantics.

Analyzes schema changes between versions to detect breaking changes (field removals, type changes, argument removals) and safe changes (new fields, new types). Compares old and new schemas, generates a change report categorizing each change by severity, and identifies which operations are affected by breaking changes. Integrates with Apollo Studio for schema history tracking.

Provides a configuration system for mapping GraphQL custom scalars to language-specific types (e.g., DateTime scalar to JavaScript Date or TypeScript Date type). Supports per-language scalar mappings, custom serialization/deserialization logic, and scalar validation. Enables code generators to emit correct types for custom scalars without manual post-processing.

Supports GraphQL fragments in code generation, enabling reusable type definitions across multiple operations. Fragments are compiled into language-specific types that can be composed into larger operation types. Handles fragment spreads, nested fragments, and inline fragments with proper type inference and union discrimination.

Generates Flow type annotations from GraphQL operations by compiling operations against a schema and emitting Flow-compatible type definitions. Handles Flow-specific features like exact object types, union discriminators, and opaque types. Maintains feature parity with TypeScript generation but targets Flow's type system semantics.

Generates Swift types and API client code from GraphQL operations by parsing operations, resolving against schema, and emitting Swift structs, enums, and protocol definitions. Handles Swift-specific patterns like Codable conformance, optionals, and associated types. Generates both model types and a type-safe query builder API for iOS/macOS clients.

Extracts GraphQL operation documents (queries, mutations, subscriptions) embedded in source code files (JavaScript, TypeScript, Swift) by parsing source ASTs and identifying GraphQL string literals or template literals. Supports multiple embedding patterns (gql`` template literals, graphql() function calls, string constants). Outputs extracted operations as standalone .graphql files or inline documents.

Downloads GraphQL schema from Apollo Studio or arbitrary GraphQL endpoints via introspection, with local caching and versioning. Implements HTTP-based schema fetching with authentication (API key), response caching with TTL, and schema validation. Supports both SDL and introspection JSON formats. Integrates with Apollo Studio's schema registry for version tracking.

Registers GraphQL operations with Apollo Studio's operation registry, enabling persisted queries and operation tracking. Extracts operations from codebase, generates operation IDs (hashes), and pushes operation manifests to Apollo Studio. Supports operation versioning, change detection, and conflict resolution. Integrates with CI/CD for automated operation registration on deploy.

Provides a Language Server Protocol (LSP) implementation for GraphQL that integrates with IDEs (VS Code, WebStorm, etc.) to enable real-time validation, autocomplete, and hover documentation. Watches for schema and operation changes, re-validates operations on-the-fly, and provides inline error diagnostics. Supports multiple workspace configurations and project-level schema management.

Provides a unified code generation pipeline (apollo-codegen-core) that compiles GraphQL operations into an intermediate representation, then routes to language-specific generators (TypeScript, Flow, Swift, Scala). The core compiler handles schema resolution, operation normalization, and type inference once, then each language backend emits language-specific code. Supports custom generators through plugin architecture.

Provides a configuration system (apollo.config.js/ts) that defines GraphQL projects, schema sources, operation locations, and code generation settings. Supports multiple projects in a monorepo via workspace configuration, with per-project schema and operation discovery. Configuration is loaded and validated at startup, with hot-reload support for schema changes.