facebook/relay

This system is the Relay compiler, a tool that processes GraphQL operations and schemas to generate type-safe client artifacts. It has been rewritten in Rust to provide a high-performance, incremental build pipeline with a native daemon, parallel processing, and precise dependency analysis. The compiler supports modern features like Relay Resolvers, deferred data delivery, and automated schema codemods, while offering a comprehensive Language Server Protocol (LSP) for IDE integration.

138 changes.

The project undertook a massive migration of the Relay compiler from JavaScript to Rust, introducing a new modular architecture with crates for parsing, schema handling, and code generation. Concurrently, the team removed all legacy Relay APIs, including the old container-based data fetching model and outdated example applications, to align with the modernized compiler infrastructure.

56 changes.

This period focused on rewriting the Relay compiler in Rust, introducing a new CLI with daemon support and a WebAssembly-based playground for browser experimentation. Significant effort was dedicated to expanding the Language Server Protocol with features like schema exploration, enhanced hover tooltips, and code actions, alongside the introduction of docblock-based resolver definitions and FlatBuffer schema serialization.

27 changes.

This period focused on expanding the Relay compiler's capabilities by introducing new crates for schema extraction, coordinate parsing, and IR diffing, alongside significant enhancements to Flow schema generation for Relay Resolvers. The work also established robust testing frameworks, including markdown-driven end-to-end tests and extensive snapshot coverage, while refactoring core components like saved state loading and resolver schema building to support base project inheritance and improved modularity.

A new Python script (generate\_flatbuffer.py) has been added to the schema-flatbuffer compiler crate to handle post-processing of code generated by the FlatBuffers compiler (flatc). This script runs flatc to generate Rust code from the GraphQL schema definition and then applies necessary patches, such as updating copyright headers to Meta, adding required derive macros (Copy, Clone) to specific structs, and cleaning up formatting, to ensure the generated code is compliant with Rust 2018 standards and project licensing requirements.

compiler/crates/schema-flatbuffer · high confidence

The graphql-cli crate now includes two example programs: print-diagnostic.rs, which demonstrates how to use the DiagnosticPrinter to format and display error messages with annotations, and print-source.rs, which demonstrates how to use the SourcePrinter to extract and display specific source code spans.

compiler/crates/graphql-cli/examples · high confidence

The connection handler in relay-runtime has been updated to support new store updater directives (@appendEdge, @prependEdge, @appendNode, @prependNode) and a plural @deleteRecord directive. This allows mutations to directly insert new edges or nodes into existing connections or delete multiple records at once, rather than requiring full connection refetches or manual client-side updates. The handler also now correctly handles multiple edges in append/prepend operations and prevents duplicate insertion of existing nodes.

packages/relay-runtime/handlers/connection · high confidence

The LSP 'Go to Definition' feature in the Relay compiler now supports navigating to definitions for GraphQL schema directives, directive arguments, and docblock annotations (such as @outputType). This change introduces new handlers in the goto\_definition module to resolve these specific language constructs, allowing developers to jump directly to the definition of directives and their arguments within schema documents, as well as to type and fragment definitions referenced in docblocks.

_compiler/crates/relay-lsp/src/goto\definition · high confidence

The schema crate now supports serializing the GraphQL schema into a FlatBuffer binary format via a new \serialize.rs\ module and a \SchemaWrapper\ in \wrapper.rs\. This change adds a new output format for the schema-extend binary, allowing consumers to receive the schema in a compact, zero-copy binary representation. The wrapper handles the deserialization of this FlatBuffer data and provides a unified interface for accessing schema types, fields, and directives, effectively bridging the internal schema representation with the FlatBuffer format.

compiler/crates/schema/src/flatbuffer · high confidence

Added a new \graphql-watchman\ crate that provides a subscription mechanism for monitoring file changes via Watchman. This component integrates with Mercurial (hg) to detect source control updates, specifically tracking base revision changes to determine when the compiler state needs to be refreshed. It exposes types for watching file modifications and handling Watchman subscription events, allowing downstream consumers to react to file system and version control changes.

compiler/crates/graphql-watchman · high confidence

A new Relay Compiler Playground has been added, allowing users to compile parts of the Rust Relay compiler to WebAssembly and interact with it via a web-based interface. The package includes a README with build instructions for generating the Wasm module using wasm-pack, an index.js entry point that exposes the compiled playground, and support for both web and Node.js testing environments.

compiler/crates/relay-compiler-playground · high confidence

The VS Code extension now launches the Relay compiler in watch mode by default (controlled by the new \relay.autoStartCompiler\ setting) and displays real-time status updates in the editor status bar via a custom LSP feature. It adds a command to copy GraphQL operations to the clipboard, supports custom root directories and config paths, and provides JSON schema validation for Relay configuration files.

vscode-extension · high confidence

The \graphql-ir\ crate is added to the compiler, providing a new Rust implementation for building, validating, and transforming the GraphQL Intermediate Representation (IR). This includes core data structures for operations and fragments, a builder for converting ASTs to typed IR, and a validation engine that enforces rules such as fragment compatibility, argument definitions, and directive usage. The crate also introduces a transform pipeline for modifying the IR and a node identifier system for efficient selection comparison, laying the groundwork for a parallelized, stable-output compiler backend.

compiler/crates/graphql-ir/src · high confidence

The \compiler/crates/common\ crate now provides the foundational types and utilities for the Relay compiler, including a structured \Diagnostic\ system (with severity levels, location tracking, and machine-readable metadata), a centralized \FeatureFlags\ configuration module for controlling compiler behavior, and core location/span types (\Location\, \Span\, \TextSource\) for accurate error reporting. It also includes a \PerfLogger\ interface for performance tracking and a \Rollout\ utility for gradual feature deployment.

compiler/crates/common · high confidence

The compiler now includes a new Rust \schema\ crate that provides the core data structures for representing GraphQL schemas (types, fields, directives, etc.) and parsing SDL documents. This change introduces an in-memory schema implementation (\InMemorySchema\) and a FlatBuffer-backed schema (\FlatBufferSchema\), along with a unified \SDLSchema\ enum to abstract over both. It also adds support for parallel schema building, compact binary serialization, and typo-tolerant type suggestions for IDEs.

compiler/crates/schema/src · high confidence

The LSP now includes a new \TypePath\ module that tracks the hierarchical path of types (operations, fragments, linked fields, and scalar fields) to accurately resolve the leaf type and current field context. This infrastructure enables the Language Server to correctly identify the target type for features like field completions and hover descriptions by traversing the schema from the root operation or fragment down to the specific field being queried.

_compiler/crates/relay-lsp/src/node\_resolution\info · high confidence

The relay-compiler-playground now exposes a WebAssembly crate that allows users to parse GraphQL documents and schemas into Abstract Syntax Trees (ASTs), Intermediate Representations (IRs), and reader or normalization ASTs directly in the browser. This new capability supports passing feature flags via JSON configuration and utilizes the parallel schema building function, enabling interactive compiler experimentation without a Node.js environment.

compiler/crates/relay-compiler-playground/src · high confidence

A new \relay-test-schema\ crate has been added to the Relay compiler toolchain, providing a centralized, lazily-initialized Rust representation of the GraphQL test schema. This library exposes pre-built schema instances (including variants with custom ID fields) and utilities for constructing schemas with extensions, replacing the previous pattern of scattering raw SDL strings and ad-hoc schema construction across individual test files.

compiler/crates/relay-test-schema · high confidence

The compiler now supports defining Relay Resolvers directly via docblock annotations, replacing the legacy verbose syntax with a new terse syntax (e.g., \@relayField ParentType.fieldName: ReturnType\). This change introduces a new parsing layer in \relay-docblock\ that interprets \@RelayResolver\, \@relayType\, and \@relayField\ tags to generate Intermediate Representation (IR) and GraphQL schema definitions. Users can now define Strong Object types (which map to server-side models) and Weak types (client-side definitions) within docblocks, enabling features like shadow resolvers, \@mayWaterfall\ directives, and resolver arguments. The compiler validates these definitions against the schema, ensuring that strong resolvers implement client-defined interfaces and that mutation resolvers return only scalar or enum types.

compiler/crates/relay-docblock/src · high confidence

A new shared crate, docblock-shared, has been added to centralize the definitions of docblock tags and SDL directives used by Relay Resolvers. This includes constants for tags like @RelayResolver, @relayType, and @relayField, as well as internal directives such as \_\RelayResolverModel and \\_relay\_shadow\_return. The crate also provides a helper function to efficiently check for resolver tags in source text and a utility for hashing resolver source code, ensuring consistent metadata handling across the compiler.

compiler/crates/docblock-shared · high confidence

The Relay LSP server has been restructured into a modular Rust crate (\compiler/crates/relay-lsp\), replacing the previous JavaScript implementation. This change introduces a new Rust-based server that provides core language support for GraphQL and Relay schemas, including code completion, hover information, go-to-definition, code actions, and diagnostics. The new architecture features a daemon for type information requests and a robust diagnostic reporter that distinguishes between quick (text-change) and regular (save) diagnostics. This modularization enables better performance, cross-platform stability (including Windows support), and a unified codebase for Relay-specific language features.

compiler/crates/relay-lsp/src · high confidence

The schema-print crate now supports printing GraphQL schemas in parallel by splitting types and fields into shards, significantly improving performance for large schemas. This change introduces new APIs (\print\_types\_directives\_as\_shards\ and \print\_types\_directives\_as\_shards\_in\_parallel\) that allow users to specify shard counts for the entire schema and individual types (e.g., sharding the \Query\ type separately). The implementation uses \rayon\ for parallel iteration and ensures stable output by sorting directives, arguments, and types within each shard before printing.

compiler/crates/schema-print/src · high confidence

The \graphql-text-printer\ crate now provides a new formatting engine that generates GraphQL SDL and executable documents (queries, mutations, fragments) in a style compatible with prettier-graphql. This replaces the previous simple AST-to-text printing with a document-based approach using the \pretty\ crate, ensuring consistent indentation, line-breaking, and argument formatting. The new printer includes specialized modules for schema definitions, executable definitions, and shared formatting utilities, and it supports options for compact output, sorted keys, and JSON formatting to improve readability and reduce lint errors in generated files.

compiler/crates/graphql-text-printer/src · high confidence

The \relay-test-utils\ package is now available, providing \createMockEnvironment\ for creating a mock Relay environment with a mocked network layer, \MockPayloadGenerator\ for generating mock GraphQL payloads based on operations and resolvers, and \testResolver\ for unit testing Relay Resolvers by mocking the \readFragment\ function. This allows developers to write tests for Relay components and resolvers without needing a real network connection or backend.

packages/relay-test-utils · high confidence

The \compiler/crates/resolution-path\ crate has been added to provide a type-safe mechanism for resolving a specific character position (Span) within a GraphQL AST to its corresponding node and parent chain. This new module introduces the \ResolutionPath\ enum and \ResolvePosition\ trait, enabling consumers to accurately identify the context of any point in the code, including complex nested structures like arguments, constant values, and schema definitions. It also includes logic to determine the logical root of arguments and constant values, as well as the parent type for selections, which is essential for accurate type checking and IDE features.

compiler/crates/resolution-path · high confidence

The \schema-documentation\ crate now provides a \SchemaDocumentation\ trait and an implementation for \SDLSchema\, enabling the system to retrieve type descriptions, field descriptions, field argument descriptions, and Hack source locations directly from the GraphQL schema definition. A \CombinedSchemaDocumentation\ wrapper allows combining multiple documentation sources, and a \SchemaDocumentationLoader\ trait standardizes how documentation is fetched by name.

compiler/crates/schema-documentation · high confidence

The new \schema-diff\ crate analyzes differences between GraphQL schemas to determine if a full rebuild is necessary or if an incremental build is safe. It classifies schema changes (such as additions, removals, or modifications to objects, interfaces, enums, unions, and input objects) into safety levels: 'Safe', 'Unsafe' (requiring a full rebuild), or 'SafeWithIncrementalBuild' (identifying specific types that need regeneration). This enables the relay compiler to skip expensive full rebuilds when schema changes are isolated to types that do not break existing operations, significantly improving build times for large codebases.

compiler/crates/schema-diff/src · high confidence

The compiler now includes a server daemon component that listens on a Unix domain socket to handle client requests for writing artifacts, checking version, and graceful shutdown. This daemon manages a persistent compiler instance, allowing clients to flush cached artifacts to disk or a custom writer while ensuring pending file changes are compiled first. It also detects when the repository is in a transient VCS state (such as a Git rebase, merge, or Mercurial/Sapling histedit) to prevent using invalid cached artifacts, and supports automatic restarts when on-disk binary or configuration drift is detected.

_compiler/crates/relay-compiler/src/server\daemon · high confidence

The Relay compiler is now implemented in Rust, replacing the previous JavaScript/Flow implementation. This new compiler introduces a native daemon with watch mode, incremental compilation, and parallelized artifact generation to improve build performance. It supports multi-project configurations, schema extensions, and integrates with Watchman for file change detection, providing a faster and more robust compilation experience for Relay applications.

compiler/crates/relay-compiler/src · high confidence

The \relay-e2e-test\ package now uses a new markdown-driven test harness that allows fixtures to be defined in self-contained \.md\ files. Each fixture specifies a GraphQL server schema (via Grats), a Relay-powered React component, and optional interaction steps; the harness extracts these code blocks, compiles them with the local Relay compiler, typechecks them with \tsc\, renders the component with React Testing Library, runs the interactions, and snapshot-tests the output. This approach enables immediate testing of Relay runtime changes without a build step and provides detailed type-error reporting within snapshots to catch regressions in generated types.

packages/relay-e2e-test · high confidence

The \graphql-syntax\ crate now includes a comprehensive set of new AST node definitions in the \node\ module, enabling the parsing and representation of GraphQL documents. This includes \Document\, \ExecutableDocument\, and \SchemaDocument\ to categorize definitions, alongside specific nodes for executable operations (\OperationDefinition\, \FragmentDefinition\) and type system definitions (\TypeSystemDefinition\ covering objects, interfaces, unions, enums, inputs, scalars, and directives, including their \Extension\ variants). The diff also introduces supporting structures for directives (\Directive\, \ConstantDirective\), values (\Value\, \ConstantValue\, \Argument\, \ConstantArgument\), type annotations (\TypeAnnotation\, \NamedTypeAnnotation\), and primitives (\Token\, \Identifier\, \List\), providing the foundational data structures for the parser's output.

compiler/crates/graphql-syntax/src/node · high confidence

The \graphql-cli\ crate now includes a new \DiagnosticPrinter\ that formats compiler diagnostics for the command line. Users will see error, warning, and hint messages color-coded (red, yellow, blue) with the file path normalized to Unix-style separators for consistent output across operating systems. The printer also displays the relevant source code snippet surrounding the issue, highlighting the specific span with a caret marker to help locate the problem quickly.

compiler/crates/graphql-cli/src · high confidence

A new command-line tool has been added to format GraphQL source files and JavaScript files containing graphql template literals using prettier-compatible printing. The tool preserves leading comments in GraphQL files and correctly formats embedded GraphQL queries within JavaScript code, providing a dedicated utility for consistent code styling.

compiler/crates/prettier-format · high confidence

The compiler now includes a new \relay-schema-generation\ crate that generates Flow type definitions for Relay Resolvers. This feature parses Flow AST to extract resolver metadata (including arguments, descriptions, deprecation, and property lookups) and maps them to GraphQL schema elements. It introduces specific error handling for resolver definitions, such as enforcing named imports, validating return types (e.g., disallowing nullable strong types or requiring \IdOf\<\>\ for strong objects), and supporting custom scalars. The implementation also handles legacy \@RelayResolver\ tags via a feature flag and integrates with the Flow parser to produce accurate type information for client-side resolvers.

compiler/crates/relay-schema-generation/src · high confidence

A new \graphql\_ir\_diff\ crate has been introduced to compare the intermediate representation (IR) of two GraphQL documents. This library determines whether one document is a subset of another by normalizing selection sets (inlining fragments, dealiasing fields, deduplicating) and performing a depth-first subtraction to identify missing selections. It provides a similarity score and a detailed report of differences, supporting type-aware comparisons via schema loading and handling complex argument subset logic (e.g., treating concrete values as subsets of variables).

compiler/crates/graphql-ir-diff · high confidence

The compiler now includes a new \persist-query\ crate that enables persisting GraphQL operations to a remote server. This feature allows users to send GraphQL documents to a configured endpoint, receiving a persisted ID back for efficient subsequent queries. The implementation handles the HTTP communication using the Hyper 1 client, manages request formatting, and provides detailed error reporting for network or parsing failures.

compiler/crates/persist-query · high confidence

A new Rust crate (js-config-loader) has been introduced to handle loading configuration files for JavaScript-based tools. It supports discovering and parsing configs from package.json, JSON files (.rc, .config.json), and JavaScript files (.js, .cjs, .mjs). JavaScript config files are executed via Node.js to support dynamic configurations, while YAML support is explicitly disabled with a specific error. The loader searches ancestor directories and provides structured error handling for parsing issues, missing Node.js, or invalid values.

compiler/crates/js-config-loader/src · high confidence

The Relay compiler now generates client-side types using a new Rust implementation located in \compiler/crates/relay-typegen\. This replaces the previous JavaScript-based typegen logic with dedicated printers for Flow (\flow.rs\), TypeScript (\typescript.rs\), and JavaScript (\javascript.rs\). The new system introduces a structured AST (\writer.rs\) to represent types, handles fragment references and data types via \visit.rs\, and manages import states and resolver metadata through \typegen\_state.rs\. This change provides a unified, language-agnostic foundation for type generation, allowing for more consistent output and easier maintenance of type definitions across different target languages.

compiler/crates/relay-typegen/src · high confidence

The Relay LSP now provides code actions to automatically generate suggested names for GraphQL operations and fragments based on the file name, and to rename fragments. This includes logic to create default names (e.g., appending Query/Mutation/Subscription suffixes), handle incremental naming for duplicates, and wrap existing names with appropriate prefixes/suffixes. A new module \create\_name\_suggestion.rs\ implements these naming strategies, enhancing the developer experience by reducing manual naming effort.

_compiler/crates/relay-lsp/src/code\action · high confidence

The \relay-codemod\ crate is introduced, providing a CLI tool to automatically apply fixes to Relay schema files. It includes specific codemods such as \MarkDangerousConditionalFragmentSpreads\ (which marks unaliased conditional fragment spreads with \@dangerously\_unaliased\_fixme\) and \RemoveUnnecessaryRequiredDirectives\ (which cleans up \@required\ directives on non-null fields). A \FixAll\ command is also available to run all compiler transforms and apply fixable diagnostics. The tool supports rollout percentages for gradual adoption and integrates with the LSP to convert diagnostics into code actions for automated application.

compiler/crates/relay-codemod · high confidence

The \compiler/crates/intern\ crate introduces a new interning library that deduplicates strings, byte slices, and other data using compact 32-bit identifiers. This library provides lock-free constant-time dereferencing of interned values and uses sharded locking to support parallel insertion, significantly reducing memory usage for frequently-used references. It includes built-in support for serialization deduplication via \serde\ and fast hashing through a custom \IdHasher\, and provides ready-to-use types for interning strings (\StringId\), paths (\PathId\), and generic keys (\StringKey\).

compiler/crates/intern · high confidence

A new \dependency-analyzer\ crate has been introduced to the compiler to support incremental builds by precisely tracking dependencies between GraphQL operations, fragments, and schema changes. This component analyzes the Abstract Syntax Tree (AST) and Intermediate Representation (IR) to build a dependency graph, allowing the compiler to identify and recompile only the definitions affected by specific changes. It includes logic to handle implicit dependencies (such as those from Relay resolvers), parallelizes the analysis of executable definitions for performance, and provides a \query-stats\ subcommand to report per-operation fragment usage statistics. Additionally, it introduces newtype wrappers for fragment and operation names to improve type safety in dependency tracking.

compiler/crates/dependency-analyzer/src · high confidence

The compiler now includes a dedicated \docblock-syntax\ crate that parses JSDoc-style comments to extract structured resolver information. This new parser handles docblock sections (key-value fields and free text), computes precise source locations for diagnostics, and generates source hashes to help detect stale artifacts during watch mode. Users benefit from more accurate error reporting and improved stability when editing code with inline resolver definitions.

compiler/crates/docblock-syntax/src · high confidence

The errors crate now exposes helper functions and macros to simplify combining multiple validation results. Users can use \try2\, \try3\, and \try4\ to aggregate up to four results, \try\_all\ and \try\_map\ to process collections of results, and \par\_try\_map\ for parallel validation. Additionally, the \validate!\ macro and \validate\_map\ function allow for concise validation logic that collects all errors rather than failing on the first one.

compiler/crates/errors · high confidence

A new Rust crate, \extract-graphql\, has been added to the compiler to extract GraphQL strings and Relay Resolver metadata from JavaScript/TypeScript source files. This component introduces a \CharReader\ to track line and column indices accurately, enabling precise error reporting and navigation. It specifically supports the extraction of \graphql\ tagged template literals (including those with whitespace or tabs between the tag and the backtick) and identifies Relay Resolver docblock tags (\@RelayResolver\, \@relayType\, \@relayField\) to provide source metadata for these features.

compiler/crates/extract-graphql/src · high confidence

A new \fixture-tests\ crate has been added to the compiler toolchain to simplify writing and maintaining integration tests for transform functions. It provides a binary (\fixture-tests-bin\) that scans directories for input/expected fixture pairs and generates Rust test files, alongside a library that handles async test execution, snapshot comparison, and diff printing. This allows developers to easily add new test cases by placing files in a \fixtures\ directory and running the generator, with support for updating snapshots via the \UPDATE\_SNAPSHOTS\ environment variable.

compiler/crates/fixture-tests/src · high confidence

A new \graphql-test-helpers\ crate has been introduced to centralize test infrastructure for the GraphQL compiler. It provides utilities to build Intermediate Representation (IR) from GraphQL schemas and ASTs, supporting features like non-overlapping abstract type spreads and fragment variable passing. The crate includes functions to apply transforms to programs and print diagnostics using a \DiagnosticPrinter\ that correctly maps error locations to source text, facilitating more accurate snapshot testing for compiler behaviors.

compiler/crates/graphql-test-helpers · high confidence

The \eslint-plugin-relay-internal\ package introduces four new linting rules for the Relay codebase: \sort-imports\ (synced from WWW) to enforce alphabetical import ordering, \no-for-of-loops\ to prevent performance-heavy iterator transformations, \esm-compatible-cjs\ to ensure CommonJS entry points are compatible with ESM named exports, and \no-mixed-import-and-require\ to maintain consistency with Flow's module configuration.

packages/eslint-plugin-relay-internal · high confidence

The \relay-test-utils-internal\ package now provides a consolidated set of internal helpers for Relay unit tests. It introduces a console interception system that mocks \console.error\ and \console.warn\ to throw on unexpected messages, requiring explicit expectations via \expectConsoleError\, \expectConsoleWarning\, and their \WillFire\ variants. New Jest matchers include \toBeDeeplyFrozen\ for immutability checks and \toWarn\ for verifying the \warning\ library. Test authoring is streamlined with \generateTestsFromFixtures\ for snapshot-driven testing of GraphQL operations, \describeWithFeatureFlags\ for running suites under different flag configurations, and \trackRetentionForEnvironment\ for precise memory retention tracking. The package also exports schema extensions for testing client-side types and interfaces, alongside utility functions like \printAST\ and \simpleClone\.

packages/relay-test-utils-internal · high confidence

The compiler now includes a new \interner\ crate that provides a global deduplication mechanism for strings, byte slices, and arbitrary custom types. This allows the compiler to store only one copy of identical values in memory, reducing overall memory usage. The crate exposes \StringKey\ and \BytesKey\ for string/byte interning, a generic \InternTable\ for custom types, and an \intern!\ macro for efficiently interning string literals at compile time.

compiler/crates/interner/src · high confidence

The Relay compiler now includes dedicated local and remote operation persisters. The local persister stores persisted queries in a JSON file on disk, supporting MD5, SHA1, and SHA256 hashing algorithms for operation IDs, and ensures the output file ends with a newline. The remote persister sends operations to a server, with a new \includeSchemaText\ configuration option that allows the project's schema to be sent alongside each persist request. It also implements concurrency limiting (defaulting to 16 concurrent requests when schema text is included) to prevent excessive memory usage during large-scale persistence.

_compiler/crates/relay-compiler/src/operation\persister · high confidence

A new \project-fixture\ crate has been introduced to provide a dependency-light format for encoding multi-file projects as single files, enabling compiler tests to use directory trees as inputs or snapshots. This crate exposes a \ProjectFixture\ struct that supports parsing and serializing file contents, updates, and deletions via a specific comment-based syntax (e.g., \//- filename\, \//-++ filename\, \//-xx filename\), and includes a \TestDir\ utility for managing temporary directories during test execution. By isolating this functionality, consumers can now depend on the fixture format without pulling in the heavier GraphQL stack required by the previous \graphql-test-helpers\.

compiler/crates/project-fixture · high confidence

The Relay compiler now includes a dedicated \relay-schema\ crate that centralizes the GraphQL schema representation and provides classification logic for resolver types. This change introduces helpers to identify \@weak\ resolver model objects, server-value objects, and abstract shadow returns, enabling the compiler to correctly route data reading (inline vs. pointer-based) for these specific resolver patterns. The crate also manages schema building with parallel extensions and defines core Relay directives such as \@refetchable\, \@inline\, and \@throwOnFieldError\ within its schema definitions.

compiler/crates/relay-schema · high confidence

The Relay LSP now exposes a new schema explorer capability, implemented in the \explore\_schema\_for\_type\ module. This adds a structured API for querying GraphQL schema details, including objects, interfaces, enums, unions, scalars, and input objects, along with their fields, arguments, and directives. This enables LSP clients to programmatically retrieve comprehensive schema metadata for features like autocomplete and documentation.

_compiler/crates/relay-lsp/src/explore\_schema\_for\type · high confidence

A new \schema-validate\ binary has been added to the compiler toolchain, allowing users to validate GraphQL schema SDL files against a comprehensive set of rules. This tool checks for structural integrity, including root type definitions, valid naming conventions, duplicate fields or arguments, and strict interface implementation compliance (such as field presence, argument matching, and type subtyping). It also detects cyclic interface inheritance and validates enum and union definitions. Validation errors are reported with precise source locations and sorted for readability, helping developers identify and fix schema issues before deployment.

compiler/crates/schema-validate/src · high confidence

Added a new \schema-coordinates\ crate that provides spec-compliant parsing and printing of GraphQL schema coordinates. It supports parsing types, members, arguments, directives, and directive arguments, and includes a best-effort parser to handle common user input patterns like \Type.field.argument\ more forgivingly.

compiler/crates/schema-coordinates · high confidence

A new \schema-extractor\ crate has been introduced to handle the extraction of type information from JavaScript definitions. This component provides core utilities for parsing Flow ASTs, including a \LocationResolver\ to translate between Flow's line/column positions and Relay's byte-offset diagnostics, and helper functions to map Flow type annotations to their ESTree names for clearer user-facing error messages. It also defines an \ExtractError\ enum to report unsupported types during schema generation.

compiler/crates/schema-extractor · high confidence

The \compiler/crates/schema-set\ crate introduces a new internal \SchemaSet\ representation for GraphQL schemas, enabling precise source-location tracking and advanced subset validation. It provides utilities to build \InMemorySchema\ and SDL documents directly from the set while preserving original source locations, and introduces \DirectivePolicies\ to define how directives may diverge between service and client schemas. The crate also includes a \find\_subset\_violations\ module to detect breaking changes when a client schema is a subset of a base schema, and handles built-in scalar management.

compiler/crates/schema-set · high confidence

A new \signedsource\ crate has been added to the compiler to embed and verify cryptographic signatures within source files. This allows the system to detect if generated code has been tampered with by replacing a specific placeholder token with an MD5 hash of the file's content, providing a mechanism to ensure the integrity of signed shards or generated outputs.

compiler/crates/signedsource · high confidence

A new \find\_field\_locations\ function has been added to the Relay LSP compiler crate, enabling the identification of specific field usages across the GraphQL program. This utility leverages the existing \FieldUsageFinder\ visitor to scan the schema and program, returning a list of locations where a specified field is used, which supports IDE features like 'find references' in the VS Code extension.

_compiler/crates/relay-lsp/src/find\_field\usages · high confidence

The \ReactRelayLocalQueryRenderer\ component is now available in the \react-relay\ package, providing a way to render data exclusively from the local Relay store without initiating network requests. This component is useful for scenarios where data is already available locally, such as after a mutation or when using client-side caching. It accepts an environment, a query, variables, and a render function, and it manages subscriptions to the store to ensure the UI updates when the local data changes.

packages/react-relay · high confidence

The main application component for the Relay Treasure Hunt example has been removed from the codebase. This deletion eliminates the user-facing game board interface, including the logic for rendering hiding spots, handling user clicks to check for treasure, and displaying game status messages such as 'You win!' or 'Game over!'.

examples/relay-treasurehunt/js/components · high confidence

The main application entry point for the Relay Treasure Hunt example (app.js) has been removed. This file previously initialized the React application using the legacy \React.render\ API and \Relay.RootContainer\ to mount the App component against the root DOM element.

examples/relay-treasurehunt/js · high confidence

The main entry point for the Star Wars JavaScript example (app.js) has been removed. This file previously initialized the React application using Relay for data fetching, rendering the StarWarsApp component with specific route configuration. Its deletion indicates the example is no longer maintained or has been restructured in a different location.

examples/star-wars/js · high confidence

The Star Wars example application components, specifically StarWarsApp and StarWarsShip, have been removed from the codebase. These files previously implemented a React-based UI for displaying factions and ships using the Relay library, and their deletion eliminates this specific example implementation.

examples/star-wars/js/components · high confidence

The \src/\_\forks\\_\ directory has been cleaned up by deleting several internal modules that were previously used to fork behavior in the Relay library. Specifically, \RelayContainerProxy\ and \prepareRelayContainerProps\ (along with their mocks) have been removed, eliminating the ability to customize how RelayContainer props are spread into inner components. Additionally, the \RelayConnectionInterface\ and \RelayNodeInterface\ (and their mocks) have been deleted, removing the internal logic that defined the informal GraphQL Connection and Node interfaces, including methods for handling payload results and connection calls. Finally, the \printRelayQuery\ module and its associated tests have been removed, meaning the internal function for generating string representations of Relay queries is no longer available in this fork.

src/\\forks\\_ · high confidence_

The \src/legacy\ directory has been completely removed, deleting the legacy GraphQL store implementation and its associated components. This includes the deletion of \GraphQLMutatorConstants\, \DliteFetchModeConstants\, and the entire \query/\ and \store/\ module trees (such as \GraphQL\_EXPERIMENTAL\, \GraphQLQueryRunner\, \GraphQLFragmentPointer\, \GraphQLRange\, and \GraphQLStoreQueryResolver\), along with their corresponding test mocks. This change eliminates the old data-fetching and mutation handling infrastructure in favor of the newer Relay architecture.

src/legacy · high confidence

The static assets for the Relay TodoMVC example, specifically the HTML entry point and the framework documentation metadata file, have been removed from the repository. This eliminates the legacy setup that relied on direct script includes for React and Relay, aligning the example with the project's current structure and build processes.

examples/todo/public · high confidence

The React components for the TodoMVC example (Todo, TodoApp, TodoList, TodoListFooter, and TodoTextInput) have been removed from the codebase. These files, which previously implemented the UI using the older Relay API (Relay.createContainer, Relay.Store.update), are no longer present, indicating the example has been updated or replaced to align with newer framework versions.

examples/todo/js/components · high confidence

The \src/container\ directory has been cleared of the legacy Relay implementation, including \RelayContainer\, \RelayRootContainer\, \RelayPropTypes\, \RelayContainerComparators\, and their associated test suites and mocks. This change removes the older container-based data-fetching API, requiring users to migrate to the newer \RelayRenderer\ and context-based environment approach.

src/container · high confidence

The \src/network\ directory has removed the legacy \RelayNetworkLayer\, \RelayMutationRequest\, and \RelayQueryRequest\ modules, along with their associated mocks and tests. This cleanup eliminates the old global injection pattern for network behavior and the specific request wrapper classes, signaling a shift away from the previous network abstraction in favor of newer Relay networking implementations.

src/network · high confidence

The \RelayPublic.js\ module, which served as the central public API entry point for Relay (exposing components like \RelayContainer\, \RelayMutation\, \RelayNetworkLayer\, and methods such as \createContainer\ and \injectNetworkLayer\), has been removed. Correspondingly, the \src/.flowconfig\ file and its associated mocks (\\_\mocks\\/Relay.js\, \\\mocks\\_/RelayPublic.js\) have been deleted. This change eliminates the legacy public interface and its specific Flow configuration, indicating a shift away from the older module structure and API surface.

src · high confidence

The \src/query\ directory has removed the legacy \RelayQuery\ runtime representation and its associated components, including \RelayFragmentReference\, \RelayQueryPath\, \RelayQuerySerializer\, \RelayQueryTransform\, \RelayQueryVisitor\, \RelayRefQueryDescriptor\, and \RelayRouteFragment\. This change eliminates the mutable query tree structure in favor of the newer concrete query model, requiring users to rely on the Babel plugin for query compilation rather than runtime query construction.

src/query · high confidence

The public HTML entry points for the Relay Treasure Hunt and Star Wars examples have been removed. These files previously handled client-side rendering via direct script tags for React and Relay; their deletion indicates these examples no longer rely on this specific legacy setup.

examples/relay-treasurehunt/public, examples/star-wars/public · high confidence

The \RelayDefaultNetworkLayer\ class, along with its associated test suite and mock, has been removed from the \src/network-layer\ directory. This change eliminates the built-in default network transport that previously handled GraphQL queries and mutations via \fetch\ and \fetchWithRetries\, requiring users to provide their own custom network layer implementation for data fetching.

src/network-layer · high confidence

The \babel-relay-plugin\ module has been completely removed from the codebase. This change deletes the core transformation logic (including \GraphQLDocumentTransformer\ and \GraphQLPrinter\) and all associated test fixtures, meaning the legacy Babel-based GraphQL compilation step is no longer available.

scripts/babel-relay-plugin · high confidence

The \examples/relay-treasurehunt/data\ directory has been removed, deleting the \database.js\, \schema.js\, and \schema.json\ files that previously provided the mock data store and GraphQL schema for the Relay Treasure Hunt example. This removes the local implementation of the \Game\ and \HidingSpot\ types, the mock data generation, and the GraphQL schema definition (including queries and mutations) that were used to drive the example application.

examples/relay-treasurehunt/data · high confidence

Deleted the \src/tools\ directory, removing internal utilities and their test mocks that are no longer needed. This includes \RelayDeprecated\ (which handled legacy container spec upgrades), \RelayError\ (error factory methods), \RelayGarbageCollection\ (store GC control), \RelayProfiler\ (method instrumentation and profiling), \RelayTaskScheduler\ (deferred task execution), and various type definitions (\RelayInternalTypes\, \RelayTypes\). The removal also cleans up associated test files and Jest mocks, reflecting a shift away from these legacy internal mechanisms.

src/tools · high confidence

The \RelayRoute\ and \RelayMetaRoute\ classes, along with their associated mocks and tests, have been removed from the codebase. This change eliminates the legacy route abstraction that previously handled URI generation, parameter definitions, and query metadata, signaling a shift away from the older routing model.

src/route · high confidence

The in-memory mock database (\database.js\) and the corresponding GraphQL schema definition (\schema.js\) for the Todo example have been removed. This eliminates the local, client-side data layer that previously handled todo and user operations via a mock \Object\-based store, effectively stripping the example of its self-contained data persistence and schema introspection capabilities.

examples/todo/data · high confidence

The legacy Relay mutation implementation files in the \examples/todo/js/mutations\ directory have been removed. This includes the specific mutation classes for adding, changing status, marking all, removing completed, removing single, and renaming todos, which previously handled optimistic updates and payload configurations using the older Relay Mutation API.

examples/todo/js/mutations · high confidence

The CheckHidingSpotForTreasureMutation class, which implemented the legacy Relay.Mutation API for checking hiding spots, has been removed from the examples directory. This deletion eliminates the old mutation pattern in favor of the current codebase structure.

examples/relay-treasurehunt/js/mutations · high confidence

The \src/store\ directory has been cleaned up by removing the legacy Relay store implementation files, including \RelayStore.js\, \RelayStoreData.js\, \RelayRecordStore.js\, \RelayQueryWriter.js\, \RelayQueryTracker.js\, \RelayPendingQueryTracker.js\, \RelayStoreGarbageCollector.js\, and related helper classes and mocks. This change removes the old data caching and query tracking infrastructure in favor of the newer contextualized store architecture.

src/store · high confidence

The hardcoded data module (starWarsDatabase.js), the GraphQL schema definition (starWarsSchema.js), and the generated schema JSON (starWarsSchema.json) in the Star Wars example have been deleted. This removes the legacy Relay-compliant schema implementation and its associated static data from the example directory.

examples/star-wars/data · high confidence

The \updateSchema.js\ scripts in both the Star Wars and Todo examples have been removed. These scripts previously used Babel to execute async functions that queried the GraphQL schema and wrote the results to JSON files, a pattern that is no longer included in these example projects.

examples/star-wars/scripts, examples/todo/scripts · high confidence

The standalone \server.js\, \.eslintrc\, \.gitignore\, and \README.md\ files have been removed from the \examples/todo\ and \examples/star-wars\ directories. This change eliminates the local development server setup and per-example linting configuration, indicating a shift away from running these examples as independent, self-contained applications with their own build pipelines.

examples/todo · high confidence

The \updateSchema.js\ script, previously used to generate \schema.json\ by executing a GraphQL introspection query against the local schema, has been removed from the \examples/relay-treasurehunt/scripts\ directory. This eliminates the ability to automatically update the schema definition file via this specific utility.

examples/relay-treasurehunt/scripts · high confidence

The minimatch dependency has been upgraded from version 3.1.2 to 3.1.4 to resolve security vulnerabilities [CVE redacted] and [CVE redacted]. This update ensures that file path matching operations within the Relay compiler and related tooling are protected against these specific security issues.

(dependencies) · high confidence

The Relay Rust compiler's project build logic has been reorganized into a structured \build\_project\ module, introducing dedicated components for artifact generation, schema building, and operation persistence. This change introduces \ArtifactGeneratedTypes\ to define the specific TypeScript/Flow types exported for operations and fragments, and \ArtifactWriter\ to handle file I/O with source control integration. It also adds \build\_ir\ for incremental IR construction with source hashing, \build\_schema\ for loading and extending schemas with resolver types, and \persist\_operations\ for parallel query persistence. These modules collectively replace the previous monolithic build flow, enabling more granular control over artifact generation and schema validation within the Rust compiler.

_compiler/crates/relay-compiler/src/build\project · high confidence

The Relay compiler's transform pipeline has been restructured to allow custom transforms to be applied before and after standard passes, enabling more flexible compiler extensions. Additionally, the compiler now supports the @catch directive, allowing developers to specify how errors should be handled (either returning NULL or the RESULT) on fields, fragments, and operations, with validation to prevent its use alongside @required.

compiler/crates/relay-transforms/src · high confidence

The compiler now supports server-value returns (including concrete \@weak\ and non-Node server VALUE types) by emitting inline-read artifacts with \{\_\typename, \\_id}\ identity, eliminating the need for pointers, refetches, or double-stores. It also introduces shadow resolvers that allow magic-fragment fields to read data directly from shadowed server fields without waterfalls, supporting both strong (Node) plural returns and interface-typed consumer fragment spreads. Additionally, the compiler now supports the \@catch\ directive on client edge fields and enforces that resolver-declared \@mayWaterfall\ requires consumer \@waterfall\.

_compiler/crates/relay-transforms/src/relay\resolvers · high confidence

The compiler now enforces strict rules for fragment spreads within operations marked with the @updatable directive. It validates that only fragments marked with @assignable are spread, ensures type compatibility between the fragment and the enclosing linked field, and prohibits directives (such as @skip or @include) on these spreads. Additionally, the compiler transforms these spreads by injecting internal directives to track type conditions, which enables the type generator to produce correct setter types for linked fields, including support for discriminated unions when inline fragments are used.

_compiler/crates/relay-transforms/src/assignable\_fragment\spread · high confidence

The Relay compiler now enforces several new validation rules to improve code safety and correctness. It emits warnings when deprecated fields, arguments, or enum values are used, and flags the use of the \@dangerouslyUnalias\ directive. Circular references involving \@no\inline\ fragments are now disallowed. To prevent runtime issues, read-time features like \@required\ with \throw\ actions, \@relayResolver\, and \@throwOnFieldError\ are prohibited in mutation responses. Additionally, the compiler ensures that \id\ fields conform to the \Node\ interface specification, prevents the use of reserved aliases (such as \\\typename\ and \\\_id\), and requires \@catch\ directives on client schema extension fields within \@throwOnFieldError\ blocks to handle missing data gracefully.

compiler/crates/relay-transforms/src/validations · high confidence

The LSP hover behavior has been refactored to provide richer, more specific information when hovering over GraphQL elements such as operation definitions, variable definitions, fragment spreads, and directives. A new \ContentConsumerType\ mechanism allows the hover content to be customized based on the consumer (e.g., Relay vs. standard GraphQL), enabling Relay-specific features like links to the Schema Explorer. This change improves the developer experience by offering more precise type information and navigation aids directly within the editor.

compiler/crates/relay-lsp/src/hover · high confidence

The selection conflict validation logic has been extracted into a new \graphql-ir-validations\ crate. This change introduces performance optimizations, including parallel validation of fragments using a BFS-level approach and the use of \FxBuildHasher\ for internal caches, which improves validation speed for complex GraphQL operations.

compiler/crates/graphql-ir-validations/src · high confidence

The saved state loading logic has been moved into a new standalone crate, \relay-saved-state-loader\. This introduces a \SavedStateConfig\ struct to manage configuration (specifically the saved state version) and defines a \SavedStateLoader\ trait with an asynchronous \load\ method. This change decouples the saved state loading mechanism, allowing for more modular integration and future extensibility of how saved states are retrieved and processed.

compiler/crates/relay-saved-state-loader · high confidence

The validation logic for extracting module names from file paths has been updated to correctly handle TypeScript files (\.ts\, \.tsx\) and index files (e.g., \index.js\, \index.tsx\). Previously, these file types might not have been processed correctly, potentially leading to validation errors or incorrect module name generation. The new implementation ensures that module names are derived consistently from the parent directory for index files and properly camel-cased for TypeScript extensions, aligning with the expected naming conventions for queries, fragments, subscriptions, and mutations.

_compiler/crates/relay-transforms/src/validations/validate\_module\names · high confidence

The schema's Interface definition now includes a \hack\_source\ field to record the origin of the type definition, enabling features like jumping to source code from type hints. Additionally, a new \recursively\_implementing\_objects\ method has been added to the Interface struct, allowing users to retrieve all objects that implement an interface either directly or through other implemented interfaces.

compiler/crates/schema/src/definitions · high confidence

The compiler now supports the new \@match\ and \@module\ directives, which allow you to define client-side data dependencies and split normalization operations. \@module\ marks a fragment spread as a module that generates a separate normalization file, while \@match\ enables type-based matching on fields with a \supported\ argument to select specific fragments. This change introduces a \JSDependency\ scalar type for linking modules, adds a \branch\ argument to \js()\ calls for 3D logging, and enforces stricter validation rules, such as preventing the use of \@alias\ within \@match\ selections and requiring literal string values for the \supported\ argument.

compiler/crates/relay-transforms/src/match\ · high confidence_

The compiler now uses a new \ProgramWithDependencies\ structure to manage compilation contexts, allowing it to distinguish between definitions within the current scope and those required as dependencies. This change enables users to look up fragment signatures across both scopes and dependencies while ensuring that operations and fragments listed as part of the program remain strictly scoped, improving clarity in how compiled GraphQL documents are structured and accessed.

compiler/crates/program-with-dependencies · high confidence

The \graphql-syntax\ crate now provides a new lexer and parser implementation for GraphQL documents, replacing the previous logic. This change introduces support for parsing both executable documents (queries, mutations, subscriptions, fragments) and schema documents (type definitions, schema definitions, and type system extensions). It also adds a \SyntaxVisitor\ trait for AST traversal, enables parsing of fragment variable definitions and string literal aliases via \ParserFeatures\, and improves error reporting by tracking source locations and emitting structured diagnostics.

compiler/crates/graphql-syntax/src · high confidence

The Relay compiler now uses a new Rust-based codegen printer and AST infrastructure in \relay-codegen\. This introduces an interned AST representation (\ast.rs\) with an \AstBuilder\ for deduplication, a new \build\_ast.rs\ module for constructing normalization and reader ASTs, and a \printer.rs\ module that outputs JSON artifacts. The change also adds support for generating top-level import statements (\top\_level\_statements.rs\) and constants (\constants.rs\) for codegen, enabling more efficient and consistent artifact generation for users.

compiler/crates/relay-codegen/src · high confidence

The Relay compiler now exposes new configuration structs in its project config to allow fine-grained control over schema expectations and output behavior. Users can now configure the \ConnectionInterface\ to customize the field names used for pagination (cursor, edges, node, pageInfo) to match non-standard GraphQL schemas, ensuring correct type generation for Relay connections. Additionally, the \DeferStreamInterface\ allows customization of the directive and argument names for \@defer\ and \@stream\, supporting schemas that use non-default names for these streaming features. The compiler also introduces \DiagnosticReportConfig\, enabling users to set the \critical\_level\ for diagnostics (Error, Warning, Info, Hint), which determines the severity threshold at which the compiler exits with an error. These changes are grounded in the new \connection\_interface.rs\, \defer\_stream\_interface.rs\, and \diagnostic\_report\_config.rs\ files within \relay-config\, which define the default structures and serialization logic for these new configuration options.

compiler/crates/relay-config · high confidence

The Relay compiler now supports loading file changes from external sources (such as saved state or pre-computed file lists) via \ExternalFileSource\, and falling back to a directory walk (\WalkDirFileSource\) when Watchman is unavailable. This includes a new \FileFilter\ to replicate Watchman's path filtering logic for non-Watchman sources, a \FileCategorizer\ that handles a new \Ignore\ file group for utility files in generated directories, and updated Watchman query building to support compact schema locations and dot-file globs.

_compiler/crates/relay-compiler/src/file\source · high confidence

The Relay compiler's artifact generation logic has been restructured to use a modular \ContentSections\ system. Generated output is now composed of distinct sections (Docblock, Disable Lint, Use Strict, Metadata Annotations, Types, Query Node, and Export), improving maintainability and consistency of the produced JavaScript/TypeScript/Flow files.

_compiler/crates/relay-compiler/src/artifact\content · high confidence

The fragment argument application logic has been refactored to use a dedicated \Scope\ struct for managing variable bindings. This change introduces a scope stack that tracks variable definitions and their resolved values (including defaults and passed arguments) per fragment invocation. A key behavioral improvement is the addition of a \has\_bindings\ check, which allows the compiler to skip unnecessary argument and directive traversal when a scope frame contains no variable bindings, potentially improving performance. The logic for resolving argument values against variable definitions and defaults has been moved into this new scope structure.

_compiler/crates/relay-transforms/src/apply\_fragment\arguments · high confidence

The compiler's resolver schema building logic has been refactored to properly handle base project inheritance. Docblock IR extraction now explicitly distinguishes between current and base project definitions, and the schema generation process marks base schema extensions with a \@relayBelongsToBaseSchema\ directive. This ensures that artifacts for types and fields defined in base projects are correctly identified and not regenerated, fixing issues with root fragment resolution and improving the stability of schema generation for projects that extend a base schema.

_compiler/crates/relay-compiler/src/build\_project/build\_resolvers\schema · high confidence

The refetchable fragment transform has been refactored to support configurable Node interface ID fields via the \node\_interface\_id\_field\ schema configuration, allowing the \id\ argument name to be customized rather than hardcoded. The \@refetchable\ directive now accepts a \preferFetchable\ boolean argument to control fetch behavior and a \directives\ argument that accepts a list of literal strings to inject server-side directives into the generated query. Additionally, the transform now supports refetchable fragments on GraphQL interfaces (provided they have implementations) and enforces stricter validation to prevent name collisions between generated refetch queries and existing fragment names.

_compiler/crates/relay-transforms/src/refetchable\fragment · high confidence

The Relay compiler now enforces stricter rules on the @required directive's action argument. It disallows using action: THROW on fields that are semantically nullable, and conversely prevents using action: DANGEROUSLY\_THROW\_ON\_SEMANTICALLY\_NULLABLE\_FIELD on non-nullable fields. These changes ensure that required field handling aligns with the schema's nullability guarantees, providing clearer error messages when mismatches occur.

_compiler/crates/relay-transforms/src/required\directive · high confidence

The Babel plugin now uses cosmiconfig to discover configuration from \relay.config.js\, \relay.config.json\, or the \relay\ key in \package.json\, replacing the previous \relay-config\ dependency. This change enables support for \.cjs\, \.mjs\, and \.js\ files with \package.json\ type="module". Additionally, the plugin now defaults to generating eager ES modules and allows users to specify a custom \artifactDirectory\ for generated files, while also supporting a \jsModuleFormat\ option for haste-style module resolution.

packages/babel-plugin-relay · high confidence

The Relay LSP server has been restructured to improve stability and maintainability. A new \GlobalState\ trait and \LSPState\ struct centralize access to schemas, programs, and configuration, replacing the previous scattered resource management. The server now uses a \TaskQueue\ with a semaphore-based scheduler to handle background compilation tasks, preventing UI blocking and managing parallelism. Request and notification handling has been moved into dedicated \LSPRequestDispatch\ and \LSPNotificationDispatch\ modules, providing a cleaner, chainable interface for routing LSP messages. Additionally, a new \heartbeat\ request has been added to allow clients to verify server connectivity.

compiler/crates/relay-lsp/src/server · high confidence

The Relay compiler binary has been rewritten in Rust, introducing a new CLI structure with explicit subcommands for codemods, schema updates, and compilation. A key behavioral change is the introduction of a background daemon mode (Unix-only) to improve build performance by reusing compiler state across invocations, though it conflicts with watch, validate, and repersist modes. The CLI now supports filtering compilation to specific projects, disabling Watchman for directory traversal, and exposing LSP functionality directly through the binary. Error handling has been centralized with specific error types for project filtering, LSP, config, and daemon failures.

compiler/crates/relay-bin · high confidence

The Relay compiler has shifted from a pure JavaScript implementation to a native binary executable, significantly changing how the tool runs. The \index.js\ entry point now detects the user's platform and architecture (macOS x64/arm64, Linux x64/arm64, Windows x64) and spawns the corresponding native binary, while the CLI wrapper (\cli.js\) facilitates this execution. This change introduces support for macOS ARM64 (M1) and Linux ARM64 builds, replacing the previous JS-only compiler. The README has been updated to redirect users to the online documentation, and the package now includes LLM/AI agent documentation in \node\_modules/relay-runtime/llm-docs/\ for programmatic access.

packages/relay-compiler · high confidence

The legacy mutation classes (RelayMutation, RelayMutationQuery, RelayMutationTransaction) and their tests have been removed from src/mutation. This change replaces the old mutation execution model with a new queue-based architecture (RelayMutationQueue), which alters how mutations are queued, committed, and rolled back, and introduces a ROLLED\_BACK status for transaction handling.

src/mutation · high confidence

The Relay documentation site has been rebuilt using Docusaurus v3, replacing the previous static site generator. This migration includes converting all documentation files from Markdown (.md) to MDX (.mdx) format, upgrading the underlying React version, and updating the build and deployment configuration. Users will see an updated site structure and improved documentation tooling, while the content itself remains consistent with previous versions.

website · high confidence

The Jest preprocessor and associated test infrastructure have been moved into the \scripts/\ directory and updated to use modern tooling. The preprocessor now relies on \@babel/core\ and a new \getBabelOptions\ helper instead of the legacy \babel-core\ and \fbjs\ rewrite modules, and it integrates the \babel-plugin-relay\ from the \dist\ folder. A new \scripts/config.tests.json\ centralizes test compiler settings, and the old \scripts/jest/testschema.json\ has been removed in favor of the schema defined in the test utilities. Additionally, a new \scripts/.babelrc\ applies the \fbjs\ preset to scripts, and a \scripts/jest/environment.js\ configures the Jest runtime environment.

scripts · high confidence

The main application entry point for the TodoMVC example, \examples/todo/js/app.js\, has been removed. This file previously handled the initial rendering of the \TodoApp\ component using the legacy \React.render\ API and a \Relay.RootContainer\. Its deletion indicates a shift away from this specific initialization pattern, likely as part of a broader migration to newer React or Relay conventions within the example.

examples/todo/js · high confidence

The legacy Relay route file (TodoAppHomeRoute.js) has been removed from the examples/todo/js/routes directory. This change eliminates the old route syntax and configuration, aligning the example with the updated routing approach.

examples/todo/js/routes · high confidence

The example applications (relay-treasurehunt and star-wars) no longer include the legacy \Relay.Route\ class-based route definitions (\AppHomeRoute.js\ and \StarWarsAppHomeRoute.js\). This change removes the old routing syntax, aligning the examples with the updated route syntax and explicit imports introduced in the starter kit.

examples/relay-treasurehunt/js/routes, examples/star-wars/js/routes · high confidence

The custom \babelGraphQLPlugin.js\ files have been removed from the build directories of the \relay-treasurehunt\, \star-wars\, and \todo\ examples. These files previously used the \babel-relay-plugin\ to process GraphQL schemas located in their respective data directories. This change simplifies the example setup by eliminating the manual Babel plugin configuration for Relay compilation.

examples/relay-treasurehunt/build, examples/star-wars/build, examples/todo/build · high confidence

Relay now uses the stabilized LiveResolverStore implementation for managing live resolver state, replacing the previous experimental version. Additionally, incremental data delivery (supporting @defer and @stream) is enabled by default without requiring a feature flag, allowing applications to receive partial query results immediately as they become available from the server.

packages/relay-runtime · high confidence

The project now uses a unified, centralized configuration for linting, formatting, and type checking. A new root \.eslintrc.js\ and \.eslintignore\ replace previous per-directory setups, extending \fbjs\ and enabling custom rules like \relay-internal/sort-imports\. Formatting is standardized via \.prettierrc.js\ with Flow parser support. Flow is configured in \.flowconfig\ (version 0.333.0) using the \haste\ module system and strict lints. Additionally, the repository license has been changed from BSD to MIT, and the \PATENTS\ file has been removed.

(repo-wide) · high confidence

The GraphQL schema FlatBuffer definition has been updated to include the \FragmentVariableDefinition\ directive location, allowing directives to be applied to fragment variables. Additionally, the \Interface\ table now exposes \implementing\_interfaces\ and \implementing\_objects\ fields, enabling the schema to capture interface inheritance and implementation relationships. The schema also preserves directives on argument definitions and directive definitions, ensuring that directive metadata is fully represented in the serialized schema format.

compiler/crates/schema-flatbuffer/src · high confidence

The generated files in the compiler test project (AppQuery.graphql.js and Component\_node.graphql.js) have been regenerated to reflect the new casting syntax and updated copyright headers from Facebook to Meta. This ensures the test project's output aligns with the compiler's current code generation standards.

compiler/test-project/src/\\generated\\_ · high confidence_

Added Flow typegen tests for @alias and @catch directives; Added Rust-based integration and fixture tests for the Relay compiler; Added TypeScript typegen test fixtures for fragment aliasing, @catch, and @match directives; Added async tests for docblock syntax parsing; Added compiler tests for abstract type refinement and module aliasing; Added compiler tests for custom Node interface ID fields; Added comprehensive test coverage for Relay docblock parsing and schema generation; Added fixture tests for Relay compiler transforms; Added fixture tests for graphql-syntax parser capabilities; Added fixture tests for the uppercase transformation; Added fixture-based tests for GraphQL IR parsing and validation; Added fixture-based tests for GraphQL schema validation; Added fixture-based tests for the GraphQL text printer; Added hover tests for Relay LSP features; Added integration tests for Relay compiler behavior and edge cases; Added parallel schema-printing tests with stable output fixtures; Added parse tests for graphql-ir validation rules; Added schema build fixture tests with FlatBuffer validation; Added schema validation test fixtures; Added snapshot tests for Relay resolver docblock schema generation; Added subschema extraction test suite; Added test coverage for @match and @module validation rules; Added test coverage for Flow and TypeScript type generation; Added test coverage for Flow type generation with custom ID fields; Added test coverage for Relay Resolver transform edge cases; Added test coverage for Relay codegen transforms and fixtures; Added test coverage for Relay docblock resolver parsing; Added test coverage for fragment argument application; Added test coverage for inline fragment transformation with directives and nested structures; Added test coverage for provided variable fragment transform; Added test coverage for request metadata generation; Added test coverage for updatable fragment spread validation; Added test fixtures for @defer and @stream directive validation; Added test fixtures for @outputType resolver validation; Added test fixtures for Flow schema extraction; Added test fixtures for GraphQL argument parsing error recovery; Added test fixtures for GraphQL document parsing; Added test fixtures for JSON codegen output validation; Added test fixtures for Relay connection transformations; Added test fixtures for client 3D module resolution; Added test fixtures for declarative connection directives; Added test fixtures for fragment alias conflict validation; Added test fixtures for inline data fragment and mask transforms; Added test fixtures for refetchable fragment validation and transformation; Added test fixtures for relay-transforms client extensions and ID/typename generation; Added test fixtures for resolver generation on abstract types; Added test fixtures for the dependency analyzer's incremental build logic; Added test fixtures for the dependency-analyzer AST module; Added test fixtures for the graphql-text-printer; Added test fixtures for unused variable validation edge cases; Added test project source files for compiler validation; Added tests for @alias directive validation and transformation; Added tests for @catch directive codegen on fragments, queries, and inline fragments; Added tests for @catch directive support on fragments, queries, and mutations; Added tests for @connection validation rules; Added tests for @defer and @stream code generation in fragments; Added tests for @relay\_test\_operation directive validation and metadata generation; Added tests for @required directive code generation; Added tests for @required directive validation on non-null and semanticNonNull fields; Added tests for GraphQL AST printer fixtures; Added tests for GraphQL IR parsing with provided variables; Added tests for GraphQL flatten and redundant node skipping transforms; Added tests for GraphQL module name validation in relay-transforms; Added tests for GraphQL operation printer; Added tests for GraphQL schema printing; Added tests for GraphQL selection conflict validation; Added tests for Relay LSP field usage, hover, rename, and type information features; Added tests for Relay LSP rename refactoring; Added tests for Relay codegen client extension handling; Added tests for Relay connection codegen fixtures; Added tests for Relay schema generation docblock and extraction logic; Added tests for aliased fragment generation in Relay codegen; Added tests for assignable fragment validation rules; Added tests for client edge code generation scenarios; Added tests for client edge compiler transforms; Added tests for compact GraphQL query text printing; Added tests for custom scalar literal validation in GraphQL IR; Added tests for data-driven dependency metadata generation; Added tests for deprecated field, argument, and enum value validation; Added tests for disallowed read-time features in mutation responses; Added tests for fragment spreads on client extension abstract types; Added tests for global variable validation in Relay transforms; Added tests for query stats fixture validation; Added tests for relay-lsp type information command; Added tests for required argument validation in the Relay compiler; Added tests for schema diffing logic; Added tests for schema printing and parallel consistency; Added tests for schema printing with directives and interface inheritance; Added tests for subscription transform edge cases; Added tests for the JavaScript configuration loader; Added tests for the Relay Compiler Playground API; Added tests for the dependency-analyzer crate; Added tests for unused variable skipping and non-nullable variable validation; Added unit tests for LSP completion logic; Added unit tests for the GraphQL extraction logic; Added unit tests for the extract-graphql fixture suite; Added validation tests for Relay connection schema errors; Removal of legacy Jest mocks and tests in src/traversal; Schema build tests cover directive validation and SDL extension support; Test coverage for @updatable directive validation rules.

The \flow-typed\ directory has been updated with new or refreshed type definitions for several dependencies. Jest definitions have been upgraded to version 29.x.x to match the latest testing framework API. Chalk definitions now reflect version 4.x.x, ensuring correct typing for its color output methods. Additionally, new or updated Flow stubs have been added for Babel (babel.js.flow), fbjs (fbjs.js.flow), and development shims (shim.js.flow), providing stricter type checking for internal utilities and external libraries used in the codebase.

flow-typed · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 34 → 55 (+20.5)
• Rubric changed (rubric-2026.08.15 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 53 → 52 (-1.4)
• Architecture 91 (new)
• Maturity 68 → 70 (+2.0)
• Readiness 21 → 47 (+26.4)
• Security 38 → 59 (+20.5)
• Event Sourcing 100 (new)

• (anonymous) (cognitive 19) (packages/relay-runtime/store/RelayReferenceMarker.js)
• (anonymous) (cognitive 20) (packages/relay-runtime/mutations/RelayDeclarativeMutationConfig.js)
• (anonymous) (cognitive 22) (packages/relay-runtime/mutations/createUpdatableProxy.js)
• (anonymous) (cognitive 26) (packages/relay-runtime/store/DataChecker.js)
• (anonymous) (cognitive 60) (packages/react-relay/relay-hooks/useFragmentInternal_EXPERIMENTAL.js)
• (anonymous) (cognitive 65) (packages/react-relay/relay-hooks/useFragmentInternal_CURRENT.js)
• (anonymous) (cognitive 70) (packages/relay-test-utils/RelayMockPayloadGenerator.js)
• (anonymous) (cyclomatic 16) (packages/relay-runtime/mutations/RelayDeclarativeMutationConfig.js)
• (anonymous) (cyclomatic 27) (packages/relay-runtime/store/RelayReferenceMarker.js)
• (anonymous) (cyclomatic 30) (packages/relay-runtime/store/DataChecker.js)
• (anonymous) (cyclomatic 45) (packages/react-relay/relay-hooks/useFragmentInternal_EXPERIMENTAL.js)
• (anonymous) (cyclomatic 47) (packages/react-relay/relay-hooks/useFragmentInternal_CURRENT.js)
• (anonymous) (cyclomatic 57) (packages/relay-test-utils/RelayMockPayloadGenerator.js)
• Context/problem and consequences/trade-offs are absent; only status and work items are present (meta/meeting-notes/2016-08-30-team-sync.md)
• Critical CVE: [GHSA redacted] (yarn.lock)
• Critical CVE: [GHSA redacted] (compiler/Cargo.lock)
• Dimension evaluation failed
• FileTooLong: tests/LiveResolvers-test.js (packages/react-relay/tests/LiveResolvers-test.js)
• FileTooLong: tests/ReactRelayPaginationContainer-test.js (packages/react-relay/tests/ReactRelayPaginationContainer-test.js)
• FileTooLong: tests/ReactRelayQueryRenderer-test.js (packages/react-relay/tests/ReactRelayQueryRenderer-test.js)
• …and 145 more

• (anonymous) (cognitive 16) (packages/react-relay/relay-hooks/useLoadMoreFunction.js)
• (anonymous) (cognitive 16) (packages/react-relay/relay-hooks/useLoadMoreFunction_EXPERIMENTAL.js)
• (anonymous) (cognitive 19) (packages/relay-runtime/handlers/connection/MutationHandlers.js)
• (anonymous) (cognitive 21) (packages/relay-runtime/handlers/connection/MutationHandlers.js)
• (anonymous) (cognitive 28) (packages/react-relay/relay-hooks/useFragmentInternal_CURRENT.js)
• (anonymous) (cognitive 29) (packages/react-relay/relay-hooks/useFragmentInternal_EXPERIMENTAL.js)
• (anonymous) (cognitive 46) (packages/relay-runtime/store/RelayPublishQueue.js)
• (anonymous) (cyclomatic 35) (packages/relay-runtime/store/RelayPublishQueue.js)
• (anonymous) (cyclomatic 46) (packages/relay-runtime/store/live-resolvers/LiveResolverCache.js)
• (anonymous)::_setResolverValue (cognitive 26) (packages/relay-runtime/store/live-resolvers/LiveResolverCache.js)
• (anonymous)::invalidateDataIDs (cognitive 21) (packages/relay-runtime/store/live-resolvers/LiveResolverCache.js)
• Ambiguous constructor naming. 'new' and 'from_raw' are both present. 'new' takes a 'str' while 'from_raw' takes a 'StringKey'. This suggests 'from_raw' is for pre-hashed or specific key types, while 'new' does hashing/conversion. However, 'new' is typically the primary constructor. The existence of 'from_raw' alongside 'new' is fine, but the naming 'from_raw' is vague compared to 'from_string_key' or similar.
• ApplyFragmentArgumentsTransform::transform_no_inline_fragment (cognitive 21) (compiler/crates/relay-transforms/src/apply_fragment_arguments.rs)
• ArtifactGeneratedTypes::from_operation (cognitive 19) (compiler/crates/relay-compiler/src/build_project/artifact_generated_types.rs)
• Change coupling: build_schema.rs ↔ lib.rs (compiler/crates/relay-compiler/src/build_project/build_schema.rs)
• Change coupling: docblocks.rs ↔ lsp_state.rs (compiler/crates/relay-compiler/src/docblocks.rs)
• Change coupling: docblocks.rs ↔ utils.rs (compiler/crates/relay-compiler/src/docblocks.rs)
• Change coupling: flow.rs ↔ typescript.rs (compiler/crates/relay-typegen/src/flow.rs)
• Change coupling: useEntryPointLoader.js ↔ useQueryLoader.js (packages/react-relay/relay-hooks/useEntryPointLoader.js)
• Change coupling: validate.rs ↔ validations.rs (compiler/crates/relay-compiler/src/build_project/validate.rs)
• …and 953 more

• 180 commits — 163 feature/other, 17 fixes

• compiler/crates — 62 commits
• compiler/Cargo.lock — 49 commits
• packages/relay-runtime — 25 commits
• packages/react-relay — 15 commits
• (root) — 11 commits
• compiler/rust-toolchain.toml — 5 commits
• packages/relay-e2e-test — 4 commits
• packages/relay-test-utils-internal — 4 commits
• website/docs — 2 commits
• .claude/commands — 1 commit
• .github/workflows — 1 commit
• packages/relay-test-utils — 1 commit

• fix: Back out "Revert D120541798: [flow] Pre-align console typing with TS typing"
• fix: Fix CI: mock_persister module path + Cargo.lock sync (#5396)
• fix: Fix Handler declared as a class in TypeScript declarations
• fix: Fix Relay Record overlapping with TypeScript's built-in Record
• fix: Fix RelayModernRecord TypeScript declarations (#5358)
• fix: Fix TodoMVC example commands in README (#5315)
• fix: Fix missing width/height props on Image in Fragments tutorial
• fix: Fix relay compiler path issues for Windows (#5365) (#5365)
• fix: Fix runIsANoop comparing a Set to 0 in RelayPublishQueue.run
• fix: Fix the module a client edge's normalization modelResolvers points at
• fix: Fix: @catch on fragment root breaks usePaginationFragment and usePrefetchableForwardPaginationFragment (#5281)
• fix: Revert D119985356: Rollout xplat & buckified Rust 1.98.1
• fix: Revert D120541798: Pre-align console typing with TS typing
• fix: fix(relay-test-utils): fix plural enum field generation (#5158)
• fix: fix: add extensions field to PayloadError per GraphQL spec (#5289)
• fix: fix: change PreloadedQuery back to interface to allow type inference based on PreloadedQuery generic type (#5361) (#5362)
• fix: fix: re-persist when @relayHash is absent from existing artifact
• change: (1/1) Accept BUCK as well as TARGETS
• change: (1/1) Drop redundant references in format arguments
• change: Accept a semantically non-null id on a strong resolver's interface
• …and 160 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

facebook/relay was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.