Skip to content
CAI
Software that uses CAICheck a score

fsprojects/FSharp.Data.GraphQL

55.3

Adequate · 13 November 2026

27.8k

lines of production code

F#

primary language

8

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Features

Add Apollo Client sample app with query runner

A new React sample application has been added to the samples/apollo-client directory, providing a web-based interface for testing GraphQL queries against a local server. The app includes a QueryRunner component that allows users to execute sample queries featuring defer, stream, threshold, and live directives, displaying results over a WebSocket connection.

samples/apollo-client · high confidence

Add file-upload sample with client and server components

A new sample demonstrating how to upload files to a GraphQL server using the TypeProvider and the Multipart Request Spec. This includes F\# scripts for uploading single files, multiple files, and querying uploaded files, alongside a Node.js Apollo server implementation to handle the uploads.

samples/client-provider/file-upload · high confidence

Added Oxpecker HTTP endpoint handlers for GraphQL requests

This change introduces the \HttpEndpoints.fs\ module in the \FSharp.Data.GraphQL.Server.Oxpecker\ package, providing the infrastructure to handle GraphQL requests via the Oxpecker HTTP library. It defines a \graphQL\ endpoint function that resolves a \GraphQLRequestHandler\ from the dependency injection container and processes incoming GET or POST requests, ensuring compatibility with the Oxpecker framework.

src/FSharp.Data.GraphQL.Server.Oxpecker · high confidence

Added PowerShell script for GitHub MCP authentication headers

A new PowerShell script (.claude/scripts/github-mcp-headers.ps1) has been added to support Claude Code's GitHub MCP integration. This script retrieves the GitHub OAuth token from Git Credential Manager and formats it as a JSON header object, allowing the MCP server to authenticate with GitHub without requiring a separate Personal Access Token (PAT). If no credential is found, it returns an empty object to keep the server unauthenticated rather than failing.

.claude · high confidence

Added Relay Global Object Identification support

The library now includes a new Node.fs module that implements the Relay Global Object Identification specification. This adds helper functions for encoding and decoding base64 global IDs (format 'typeName:localId'), an active pattern for matching these IDs, and extension methods on SchemaDefinitions to easily create 'id' fields, the 'node' query field (both synchronous and asynchronous versions), and the Node interface definition itself, simplifying the integration of Relay-compatible global identification into GraphQL schemas.

src/FSharp.Data.GraphQL.Server.Relay · high confidence

Added chat application sample with domain models and GraphQL schema

The chat application sample now includes the core server-side domain models and GraphQL schema definitions. This introduces value types for organizations, members, and chat rooms, along with the necessary GraphQL object and enum types to expose these entities via the API.

FSharp.Data.GraphQL.Samples.ChatApp · high confidence

Added chat-app sample with GraphQL server and client test data

The chat-app sample now includes a new F\# GraphQL server implementation using Giraffe and HotChocolate, featuring WebSocket support for subscriptions and integrated Altair and GraphiQL development tools. The server setup includes exception handling, in-memory persistence, and configuration files, while the client side adds schema snapshots and subscription examples for testing.

samples/chat-app · high confidence

Design-time GraphQL type provider implementation

The design-time experience for GraphQL clients is now supported by a new type provider that generates F\# types at compile time. This provider, located in the DesignTime project, integrates with the F\# compiler to resolve GraphQL schemas and provide IntelliSense and type safety for query construction without requiring runtime reflection.

src/FSharp.Data.GraphQL.Client.DesignTime · high confidence

Introduce AspNetCore integration for GraphQL server

This change adds the \FSharp.Data.GraphQL.Server.AspNetCore\ package, providing the necessary components to host the GraphQL server on ASP.NET Core. It includes \GraphQLRequestHandler\ for processing HTTP requests, \GraphQLWebSocketMiddleware\ for handling \graphql-transport-ws\ connections, and \ServiceCollectionExtensions\ to simplify service registration via \AddGraphQL\. The implementation supports subscriptions, deferred execution, and file uploads, with dedicated helpers for JSON binding and structured logging.

src/FSharp.Data.GraphQL.Server.AspNetCore · high confidence

Introduces ObjectListFilter for GraphQL query filtering

The middleware now includes an \ObjectListFilter\ type that allows users to define complex filtering logic for object lists in GraphQL queries. This new capability supports logical combinations (And, Or, Not), comparison operators (Equals, GreaterThan, LessThan, etc.), string operations (StartsWith, EndsWith, Contains) with optional case-sensitivity, and type-based filtering (OfTypes). The implementation includes LINQ translation options (\ObjectListFilterLinqOptions\) to configure discriminator handling and JSON serialization settings for filter value coercion, enabling these filters to be translated into database queries.

FSharp.Data.GraphQL.Server.Middleware · high confidence

Introduction of shared GraphQL core components

This change introduces the foundational shared library for the F\# GraphQL client and server, consolidating core types and logic into a Portable Class Library (PCL). It provides the Abstract Syntax Tree (AST) definitions for parsing and printing GraphQL documents, a comprehensive type system for schema introspection, and a robust validation engine to ensure queries and schemas adhere to the GraphQL specification. Additionally, it establishes a standardized error handling model using \GQLProblemDetails\ with extension support, implements a memory cache for validation results, and defines the protocol structures for WebSocket-based subscriptions, including support for incremental delivery via \@defer\ and \@stream\ directives.

FSharp.Data.GraphQL.Shared · high confidence

New F\# Giraffe GraphQL project template

A new .NET project template named 'F\# Giraffe GraphQL' (short name: fsharp.gir.graphql) is now available for generating Star Wars API sample projects. This template scaffolds a complete F\# GraphQL server using Giraffe and the FSharp.Data.GraphQL library, including configuration for HTTP/HTTPS ports (defaulting to 8086/8087), authorization policies (such as 'CanSetMoon'), and development tools like Altair, GraphiQL, and Voyager. It also includes necessary middleware for handling field-level authorization and resolves configuration file loading issues present in previous setups.

samples/star-wars-api · high confidence

New Fabulous + GraphQL sample for Xamarin

Added a new sample application demonstrating how to use Fabulous with FSharp.Data.GraphQL.Client on Xamarin. The project includes Android and iOS platform implementations, a shared core using the Elmish pattern, and a README with setup instructions. The app connects to a local GraphQL API (defaulting to port 8086) to fetch and display Star Wars character details.

samples/star-wars-fabulous-client · high confidence

New GraphQL HTTP handler for Giraffe integration

A new HttpHandlers module has been added to the Giraffe integration layer, providing the core HTTP handling logic for GraphQL requests. This includes a handler that routes both POST and GET requests to the GraphQL request handler, supports multipart file uploads by setting a specific request type header, and integrates with the ASP.NET Core dependency injection system to resolve the GraphQL request handler instance.

src/FSharp.Data.GraphQL.Server.Giraffe · high confidence

New GraphQL client library with custom JSON handling and file upload support

The \src/FSharp.Data.GraphQL.Client\ directory now contains the core implementation of the GraphQL client, introducing a custom \JsonValue\ type and \Serialization\ module for parsing and serializing JSON without external dependencies like Json.NET. This includes support for deserializing GraphQL responses into F\# records and handling file uploads via a new \Upload\ type that manages streams and MIME types. The library also provides a \GraphQLClientConnection\ component that wraps \HttpMessageInvoker\ for HTTP operations and includes utility extensions for string manipulation and reflection patterns to support F\#-specific types like options and lists.

src/FSharp.Data.GraphQL.Client · high confidence

New GraphiQL client sample with WebSocket subscription support

A new GraphiQL client sample has been added to the repository, providing a standalone interface for interacting with GraphQL servers. This client is configured to support both standard HTTP queries and real-time subscriptions via WebSockets, utilizing the \subscriptions-transport-ws\ and \graphiql-subscriptions-fetcher\ libraries. The sample is set up to connect to a backend at \localhost:8086\ and includes the necessary build configuration (Webpack, Babel) and dependencies to run the interactive playground.

samples/graphiql-client · high confidence

New ObjectListFilter middleware for filtering list fields

The middleware now includes an \ObjectListFilterMiddleware\ that automatically adds a \filter\ argument to list fields, allowing users to filter results using operators like \\_gt\, \\_lt\, \\_in\, \\_starts\_with\, and \\_ends\_with\. String comparisons support both case-insensitive (lowercase suffixes) and case-sensitive (capitalized suffixes) modes, and filters can be supplied via GraphQL variables or inline constants. The middleware also reports applied filters to the response metadata when enabled.

src/FSharp.Data.GraphQL.Server.Middleware · high confidence

New Relay Connection and Edge type definitions

The library now includes explicit F\# type definitions for Relay-compliant pagination structures, specifically \Edge\<'Node\>\, \PageInfo\, and \Connection\<'Node\>\, along with a \SliceInfo\ discriminated union for handling forward and backward pagination arguments. This change introduces the core data models and GraphQL object type definitions (\PageInfo\, \EdgeOf\) required to implement the Relay Cursor Connections Specification within the server, enabling users to build paginated APIs that adhere to the Relay standard.

FSharp.Data.GraphQL.Server.Relay · high confidence

New Star Wars sample app using Fabulous and FSharp.Data.GraphQL

Added a new sample application in the StarWars folder that demonstrates an F\# mobile client built with Fabulous and FSharp.Data.GraphQL. The app connects to the Star Wars API to fetch and display a list of characters, allowing users to select a character to view their details, including name, home planet or primary function, and appearance information.

StarWars · high confidence

New relay-book-store sample demonstrating Relay-style pagination

A new sample project has been added to demonstrate building Relay-style connections (pagination) against an SQL-like data source. The sample includes a SQLite-backed database layer with cursor-based pagination logic, a GraphQL schema defining a \books\ connection field with forward/backward paging, and an ASP.NET Core/Giraffe host that exposes the GraphQL endpoint along with development UI tools (GraphiQL, Altair, Voyager).

samples/relay-book-store · high confidence

Relay cursor encoding and decoding logic introduced

The Relay Book Store sample now includes explicit logic for encoding and decoding cursor objects used in pagination. A new \Domain.fs\ file defines a \BookCursor\ type and a companion module that handles serialization to and from Base64-encoded JSON strings, enabling the sample to correctly manage Relay-style cursor-based pagination for book lists.

FSharp.Data.GraphQL.Samples.RelayBookStore · high confidence

Shared GraphQL core library introduced with async value handling, introspection, and parsing

The \src/FSharp.Data.GraphQL.Shared\ project was created to house shared GraphQL components, introducing a new \AsyncVal\<'T\>\ struct to uniformly handle synchronous values, asynchronous computations, and failures while reducing allocations. This location now provides the core GraphQL introspection schema definitions (including \\_\Type\, \\\Field\, and \\\_DirectiveLocation\ with extended locations), the GraphQL query parser built on FParsec, and JSON serialization configuration using \System.Text.Json\. It also defines the \NameValueLookup\ output structure and error coercion logic for input values, forming the foundational type system and parsing layer for the library.

src/FSharp.Data.GraphQL.Shared · high confidence

Support for GraphQL Incremental Delivery via WebSocket

The AspNetCore server now implements the incremental delivery specification for GraphQL subscriptions over WebSocket. This introduces new \GraphQLOptions\ configuration, an \IncrementalDelivery\ engine to manage pending, incremental, and completed delivery states, and updated \SubscriptionWorker\ and \SubscriptionPayloads\ logic to translate engine events into the standard wire format. Users can now utilize \@defer\ and \@stream\ directives, receiving partial results and updates in real-time rather than waiting for the entire response.

FSharp.Data.GraphQL.Server.AspNetCore · high confidence

Architecture

New internal helper modules for collections, reflection, and diagnostics

The library introduces a new \Helpers\ folder containing internal modules (\CollectionExtensions\, \Diagnostics\, \Extensions\, \ObjAndStructConversions\, and \Reflection\) that provide foundational utilities for the GraphQL provider. These modules add \voption\-aware sequence and list operations (such as \vtryHead\, \vchoose\, and \vtryFind\), reflection helpers for runtime type construction of options and skippables, case-insensitive property/method lookup, and debug execution timing. This refactoring consolidates scattered utility code into a single location to support the broader migration to \voption\ and improve internal organization without changing public APIs.

src/FSharp.Data.GraphQL.Shared/Helpers · high confidence

Behavioural changes

Build system migrated to .NET 10 and SLNX format with launch profiles

The build infrastructure has been upgraded to target .NET 10.0 (SDK 10.0.303) and migrated from traditional .sln files to the new SLNX solution format (e.g., FSharp.Data.GraphQL.slnx). To support this transition, launch profiles have been added to the Build project, enabling developers to easily run specific build targets like 'BuildAndTest' or 'PackAndPush' directly from their IDE.

Build · high confidence

Introduces design-time caching and runtime base types for the GraphQL client

The design-time provider now caches generated types and validation results to improve performance, configurable via options like \ClientQueryValidation\ and \ExplicitOptionalParameters\. Runtime support is enhanced with new base types (\RecordBase\, \EnumBase\) and error handling structures (\OperationError\ with locations and extensions), while the client module now supports introspection via GET requests and handles file uploads through multipart requests.

FSharp.Data.GraphQL.Client.DesignTime · high confidence

New Executor middleware architecture and subscription filtering

The server now uses a phased middleware system (compile, post-compile, plan, execute) allowing custom logic to intercept specific stages of query processing, and subscriptions now support tag-based filtering for more precise event delivery.

src/FSharp.Data.GraphQL.Server · high confidence

New error handling types and execution result structures

The server now introduces dedicated error types (\CoercionError\, \CoercionErrorWrapper\) and a structured response model (\GQLResponse\, \GQLExecutionResult\) that support detailed error metadata, including input source tracking (variables vs arguments) and field paths. This change enables more precise error reporting to clients and supports advanced execution features like deferred responses and streaming by separating execution content shapes (Direct, Deferred, Stream, RequestError) and carrying request-specific metadata through the execution pipeline.

FSharp.Data.GraphQL.Server · high confidence

Redefined Star Wars API sample with new schema and streaming support

The Star Wars API sample project has been restructured to demonstrate a simplified schema featuring Human, Droid, and Planet entities, along with a new PatchPlanet type for entity patching. The sample now includes support for lazy async collection streaming via the @stream directive using TaskSeq, and implements per-field authorization using ASP.NET authorization policies.

FSharp.Data.GraphQL.Samples.StarWarsApi · high confidence

Updated client provider samples with new examples and configuration

The samples in the client-provider directory have been refreshed to demonstrate current capabilities. New examples include field aliases, GitHub access with custom authorization headers, and mutations. The samples now support custom HTTP headers for both introspection and runtime queries, allow loading queries from external files, and demonstrate the use of a reusable GraphQLClientConnection via a connection factory. Additionally, the samples have been updated to use the netstandard2.0 target framework and reference the latest server schemas.

samples/client-provider · high confidence

Test coverage

Added GraphQL benchmark suite for performance analysis; Added SQL integration tests for LINQ-to-GraphQL execution; Added Star Wars API schema for integration testing; Added benchmark result artifacts for SimpleExecution and SimpleExecutionWithMiddlewares; Added benchmark schema and query definitions for performance testing; Added compile-time kind-safety tests for ListOf, Nullable, and StructNullable wrappers; Added comprehensive test coverage for GraphQL engine features; Added integration test server scaffolding and compilation tests; Added tests for AspNetCore GraphQL server features; Added tests for AsyncVal and Observable helpers; Added tests for GraphQL input coercion and variable handling; Expanded integration test coverage for GraphQL client features; Expanded test coverage for GraphQL AST printing, error handling, and ObjectListFilter type coercion.

Dependencies

Initial dependency manifests for build, samples, and client projects

This change introduces the foundational dependency configuration files for the repository, establishing the build environment and sample applications. The build system is defined in \build/Build.fsproj\ targeting .NET 8.0 with FAKE and NuGet tooling. Sample projects are configured for various platforms: the Star Wars API and Relay Book Store target .NET 6.0, while the Fabulous mobile clients (Android and iOS) rely on Xamarin.Forms 4.0 and F\# Core 4.6.2. JavaScript dependencies are also initialized, with the root \package.json\ adding \fable-core\ and specific sample clients (Apollo, GraphiQL) pulling in React, GraphQL, and related tooling.

(dependencies) · high confidence

Migrated to .NET 10 and updated core dependencies

The project has been upgraded to target .NET 10.0, with the \Directory.Build.props\ file setting the target framework to \net10.0\ and the F\# compiler language version to 10.0. This migration is accompanied by a significant update to the dependency graph defined in \Packages.props\, including \FSharp.Core\ to version 10.1.202, \Microsoft.Extensions\ packages to 10.0.\, and \HotChocolate.AspNetCore\ to 15.\. The solution structure has also been modernized by migrating from legacy \.sln\ files to the new \.slnx\ format.

(repo-wide) · high confidence

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

How this codebase got here

Score

  • CAI 62 → 55 (-6.9)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.3) — scores are not directly comparable.

Lenses

  • Code Health 74 → 74 (+0.0)
  • Architecture 79 → 79 (+0.0)
  • Maturity 60 → 66 (+6.0)
  • Readiness 63 → 63 (+0.1)
  • Security 58 → 41 (-17.4)
  • Performance 94 → 91 (-2.1)

Resolved (5)

  • Hotspot: src/FSharp.Data.GraphQL.Client/Serialization.fs (src/FSharp.Data.GraphQL.Client/Serialization.fs)
  • Hotspot: src/FSharp.Data.GraphQL.Server/Linq.fs (src/FSharp.Data.GraphQL.Server/Linq.fs)
  • Hotspot: src/FSharp.Data.GraphQL.Server/Planning.fs (src/FSharp.Data.GraphQL.Server/Planning.fs)
  • Off-boarding risk: anonymized user #1
  • Test reliability not measured — test suite did not build

New (4)

  • Edited copy of a member (45 corresponding lines) (samples/chat-app/server/Program.fs)
  • Off-boarding risk: anonymized user #1
  • Orphaned file (src/FSharp.Data.GraphQL.Client/TextConversions.fs)
  • Orphaned file (src/FSharp.Data.GraphQL.Shared/Output.fs)

Changes since last survey

  • 1 commits — 1 feature/other, 0 fixes

By area

  • samples/graphiql-client — 1 commit

Notable commits

  • change: Bump follow-redirects from 1.16.0 to 1.16.2 in /samples/graphiql-client (#644)

Architecture

  • Unchanged — 0 containers · 14 contexts · 11 edges

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

Survey your own repository

fsprojects/FSharp.Data.GraphQL 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.

About this page

  • The score is its most recent published measurement, taken on 13 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit 46796a50c01655a8297d172d4a09834b25d3dd9a — the exact code this score is about.
  • Scored under rubric-2026.11.3 — the same rubric and the same method as every other entry in this index.
  • Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.61+preprod-b8b1a43ae4c3.