ghostdogpr/caliban
57.8
Adequate · 14 November 2026
42.8k
lines of production code
Scala
primary language
5
measurements over time
What this system is
Features
Add Apollo Federation subgraph compatibility test tool
A new apollo-compatibility module has been added to provide a federated subgraph implementation for verifying compatibility against the Apollo Federation Subgraph Specification. This tool includes a Scala-based server (using Caliban and ZIO) that exposes a GraphQL schema with Federation v2.3 directives, custom directives, and various entity resolution patterns. It is designed to be run via Docker (exposing port 4001) and can be used with the @apollo/federation-subgraph-compatibility CLI to test other subgraphs against the spec.
apollo-compatibility · high confidence
Add Apollo Federation v1 compatibility example and benchmark suite
The repository now includes a new \apollo-compatibility\ module that provides a complete example of a federated GraphQL schema using Apollo Federation v1, featuring entity resolvers for Product, User, Inventory, and other types, along with support for directives like @key, @provides, @external, and @override. Additionally, a new \benchmarks\ module has been added to measure performance against other GraphQL libraries (Sangria, Grackle) and to benchmark internal components like the FragmentValidator with complex query shapes.
repository · high confidence
Add Caliban adapter for ChilliCream GraphQL Gateway Benchmarks
Users can now benchmark Caliban's GraphQL gateway against the standard ChilliCream Federation benchmarks. This change introduces a new adapter that composes the four pinned Rust subgraphs (accounts, inventory, products, reviews) into a single gateway served on port 5220, forwarding the Authorization header to subgraphs. It includes shell scripts to install the adapter, run the k6-based benchmark suite, and perform local comparisons against other gateways like Apollo Router and Cosmo.
gateway-benchmark · high confidence
Add Caliban adapter for Federation Gateway Audit
A new adapter has been added to the \gateway-audit\ location, enabling Caliban's gateway to be validated against the pinned Federation Gateway Audit suite. This includes the \Main.scala\ entry point which serves the gateway on port 4000, along with shell scripts (\install.sh\, \run.sh\, \verify-results.sh\) and configuration files to build, run, and verify the audit results against the upstream repository.
gateway-audit · high confidence
Add Caliban-to-Tapir example with GraphiQL and Swagger integration
The calibantotapir example now demonstrates how to unify GraphQL and REST endpoints using Tapir, including a new GraphiQL UI accessible at /graphiql, Swagger documentation at /docs, and a sample REST endpoint at /example alongside the standard GraphQL routes.
examples/src/main/scala/example/calibantotapir · high confidence
Add Circe JSON scalar support
The core module now includes a new interop layer for Circe, introducing a \CirceJson\ trait that provides \Schema\ and \ArgBuilder\ instances for Circe's \Json\ type. This allows users to directly use Circe's \Json\ as a GraphQL scalar, enabling seamless encoding of GraphQL input values into Circe JSON structures and decoding of response values back into them.
core/src/main/scala/caliban/interop/circe · high confidence
Add FS2 Stream interop support for Caliban schemas
Users can now use fs2.Stream types directly in Caliban GraphQL schemas. This change introduces new implicit schemas in the caliban.interop.fs2.implicits package that allow fs2 streams to be resolved as GraphQL subscriptions or data streams, bridging the gap between ZIO's ZStream and fs2's Stream abstraction for reactive data handling.
interop/cats/src/main/scala/caliban/interop/fs2 · high confidence
Add GraphQL Federation V2 example application
The examples directory now includes a complete Federation V2 implementation, demonstrating how to split a GraphQL schema across multiple services. This example features a CharacterService and an EpisodeService, each exposing their own GraphQL API on separate ports (8088 and 8089) and wired together via a FederatedApi composition, providing a reference for building federated graph architectures.
examples/src/main/scala/example/federation/v2 · high confidence
Add Monix interop example
An example demonstrating how to integrate Caliban with Monix has been added to the examples directory. This new file shows how to construct a GraphQL API using Monix's Task and Observable types for queries and subscriptions, respectively, and how to execute them within a Monix application context.
examples/src/main/scala/example/interop · high confidence
Add Monix interop support for Caliban
Introduces the \MonixInterop\ module, enabling Caliban users to work with Monix effects. This includes utilities to convert ZIO-based GraphQL interpreters into Monix \Task\ for async execution and schema validation, as well as schema definitions that allow GraphQL fields to return Monix \Task\ (for queries) and \Observable\ (for subscriptions), seamlessly bridging ZIO streams with Monix reactive types.
interop/monix/src/main/scala/caliban/interop/monix · high confidence
Add Monix interop support for GraphQL execution and schema conversion
Users can now integrate Caliban with the Monix library via the new \caliban.interop.monix.implicits\ package. This adds implicit classes to \GraphQLInterpreter\ and \GraphQL\ that enable asynchronous execution returning Monix \Task\ and \Observable\ types, and provides implicit schema conversions for \Task\[A\]\ and \Observable\[A\]\ fields, allowing Monix-based effects to be used directly in GraphQL schemas.
interop/monix/src/main/scala/caliban/interop/monix/implicits · high confidence
Add OpenTelemetry tracing wrappers for GraphQL execution
New tracing components (SchemaTracer, FieldTracer, TracingWrapper) have been added to integrate OpenTelemetry into Caliban's execution pipeline. SchemaTracer creates spans for GraphQL operations, adhering to semantic conventions for span naming (e.g., 'query \<name\>') and masking sensitive argument values (lists, enums, booleans, strings) to prevent data leakage in traces. FieldTracer wraps individual field resolution, ensuring proper span status handling (including error states) via ZIO's acquire-release pattern. These wrappers are composed in TracingWrapper to provide a unified tracing experience for GraphQL requests.
tracing/src/main · high confidence
Add Play 3 example application using Pekko HTTP and Tapir adapters
A new example application (ExampleApp.scala) demonstrates how to run a Caliban GraphQL server on Play 3, leveraging the underlying Pekko HTTP infrastructure. The example configures HTTP and WebSocket endpoints via Tapir adapters (HttpInterpreter and WebSocketInterpreter) and includes a GraphiQL interface, providing a concrete reference for integrating Caliban with the Play framework.
examples/src/main/scala/example/play · high confidence
Add Play JSON interop support
Caliban now includes a new \PlayJson\ trait in the \core/src/main/scala/caliban/interop/play\ module, enabling seamless integration with the Play JSON library. This addition provides implicit \Schema\ and \ArgBuilder\ instances for \play.api.libs.json.JsValue\, allowing users to directly use Play JSON types in their GraphQL schema definitions and argument parsing without manual conversion.
core/src/main/scala/caliban/interop/play, core/src/main/scala/caliban/interop/zio · high confidence
Add cats-effect interop for Caliban
This change introduces a new interop module that bridges Caliban with the cats-effect ecosystem. It provides implicit classes to convert existing Caliban components into cats-effect types: \GraphQLInterpreter\ gains \executeAsync\ and \checkAsync\ methods to return results wrapped in a generic effect \F\[\_\]\, \GraphQL\ gains an \interpreterF\ method to create interpreters effectfully, and a new \Schema\ instance is provided to handle fields returning \F\[A\]\ types.
interop/cats/src/main/scala/caliban/interop/cats/implicits · high confidence
Add schema reporting capability
Introduces a new schema reporting feature that allows GraphQL servers to send their schema metadata to Apollo. This includes the \SchemaReporter\ service for handling the reporting logic, client-side mutation definitions for the Apollo GraphQL API, and utility functions for hashing schemas, enabling integration with Apollo's schema registry.
reporting/src/main · high confidence
Added core abstractions for Relay global identifiers and node resolution
This change introduces the foundational Scala traits and resolvers required to implement the Relay Global Object Identification spec within Caliban. It adds the \Cursor\ trait for abstracting cursor encoding/decoding, the \NodeResolver\ trait (with factory methods for ZIO, Either, and Option-based lookups) to handle resolving objects by their global ID, and the \TypeResolver\ trait to determine the concrete type of an object from its ID. These components enable the framework to correctly materialize and resolve nodes in a Relay-compliant manner.
core/src/main/scala/caliban/relay · high confidence
Added example configurations for Apollo Federation gateways
The examples directory now includes configuration files for running Apollo Federation gateways. A new Play example configuration file (application.conf) has been added, alongside JavaScript implementations for both the original Apollo Federation gateway (gateway/gateway.js) and the Federation V2 gateway (gateway\_v2/gateway.js). These files demonstrate how to set up gateway servers to aggregate the 'episodes' and 'characters' subgraphs, with the V2 example utilizing the newer @apollo/server package and IntrospectAndCompose for schema composition.
examples/src/main/resources · high confidence
Added federation tracing protocol buffer definitions
A new \reports.proto\ file has been added to the federation module, defining the schema for federation tracing data. This includes message structures for \Trace\, \Node\, \QueryPlanNode\, and related metadata (such as cache policies, HTTP details, and error locations), enabling the collection and reporting of detailed execution traces across federated GraphQL services.
federation/src/main/protobuf · high confidence
Initial CircleCI configuration for multi-version Scala testing
The project now includes a CircleCI configuration that establishes a continuous integration pipeline for building and testing the codebase. The pipeline runs linting, unit tests, and scripted tests across multiple Scala versions (2.12, 2.13, and 3.3) and JDK versions (17 and 21). It also includes specific jobs for testing Scala.js and Scala Native targets, with a dedicated script to install a supported version of Clang (version 19) to ensure stable compilation for Scala Native.
.circleci · high confidence
Introduce Caliban Federation support with v1, v2.0–v2.13, and Connect protocol
This change adds the core federation implementation to Caliban, enabling schemas to be consumed by Apollo Federation gateways. It introduces \EntityResolver\ to handle entity resolution for federated types, \FederationSupport\ to augment GraphQL schemas with federation-specific types (like \\_Entity\ and \\_service\), and \FederationV1\ for legacy v1 directive support. The package also exposes lazy values for federation versions v2.0 through v2.13, progressively adding support for directives like \@key\, \@requires\, \@shareable\, \@inaccessible\, \@override\, \@cacheTag\, and the Apollo Connect protocol (v0.2–v0.4). Users can now enable federation by applying the \federated\ aspect or using the specific version helpers (e.g., \caliban.federation.v2\_12\) to ensure schema compliance with the desired federation spec version.
federation/src/main/scala/caliban/federation · high confidence
Introduce ExampleService for character management
Added ExampleService.scala, a new ZIO-based service layer that manages a list of characters. It provides methods to retrieve characters by origin, find specific characters by name, and delete characters, while also exposing a stream of deletion events via a ZIO Hub for reactive updates.
examples/src/main/scala/example · high confidence
Introduce Laminext-based GraphQL client integration
Adds a new \client-laminext\ module providing a JavaScript/Scala client for GraphQL queries, mutations, and subscriptions using the Laminext library. This integration enables reactive UI updates via \EventStream\ for HTTP requests and WebSocket-based subscriptions, supports JSON serialization via \jsoniter\, and includes a demo application to illustrate usage.
client-laminext · high confidence
Introduce schema transformation system with rename and exclude capabilities
Caliban now provides a new \Transformer\ framework in the core module, allowing users to programmatically modify the GraphQL schema and its resolution logic. This feature includes built-in transformers for renaming types (\RenameType\), fields (\RenameField\), and arguments (\RenameArgument\), as well as excluding specific fields from the schema (\ExcludeField\). These transformers can be composed and applied to customize the schema output without modifying the underlying data models.
core/src/main/scala/caliban/transformers · high confidence
Introduction of GraphQL over WebSocket protocol support
Added a new \caliban.ws\ module that implements the \graphql-transport-ws\ protocol (and legacy support) for handling GraphQL subscriptions over WebSockets. This introduces a \Protocol\ abstraction and a \CalibanPipe\ type, enabling users to integrate real-time subscription capabilities into their GraphQL servers using the standard \graphql-ws\ protocol operations like connection initialization, subscription management, and keep-alive pings.
core/src/main/scala/caliban/ws · high confidence
Introduction of core GraphQL AST data structures
The parsing module now exposes the fundamental Abstract Syntax Tree (AST) classes for GraphQL documents, specifically \Document\ and \VariableDefinition\. The \Document\ class serves as the root container for all GraphQL definitions (types, operations, fragments, etc.) and provides convenient, lazy-accessors to filter these definitions by category (e.g., \queryDefinitions\, \mutationDefinitions\, \typeDefinitions\). It also includes utility methods to check for introspection queries, locate specific operation definitions by name, and traverse selection sets to detect specific fields or directives. The \VariableDefinition\ class defines the structure for operation variables, including their name, type, default value, and associated directives.
core/src/main/scala/caliban/parsing/adt · high confidence
New Akka HTTP adapter implementation via Tapir
Introduces a new \AkkaHttpAdapter\ that implements HTTP, upload, WebSocket, and GraphiQL services for the Akka HTTP framework. This adapter leverages the Tapir integration to provide a unified interface for serving GraphQL APIs, including support for subscriptions via WebSocket and interactive documentation via GraphiQL.
adapters/akka-http/src/main · high confidence
New Apollo Persisted Queries and Incremental Delivery wrappers
The \core/src/main/scala/caliban/wrappers\ module now includes new wrappers for Apollo Persisted Queries and Incremental Delivery. The \ApolloPersistedQueries\ wrapper implements the Apollo Persisted Queries spec, caching parsed GraphQL documents by SHA-256 hash to reduce parsing overhead and supporting custom persistence stores. The \IncrementalDelivery\ wrapper adds support for the \@defer\ and \@stream\ directives, enabling partial response delivery with specific validation rules (e.g., \@stream\ only on list fields, unique labels). Additionally, the \Wrappers\ object provides utilities for printing errors with full stack traces, logging slow queries, enforcing query timeouts, and limiting query depth and field count.
core/src/main/scala/caliban/wrappers · high confidence
New Caliban GraphQL client implementation
This change introduces the core components of the Caliban GraphQL client library. It adds \ArgEncoder\ and \ScalarDecoder\ typeclasses to handle encoding arguments and decoding responses for standard types (Int, String, Boolean, etc.), UUIDs, and Java time types (Instant, LocalDate, etc.). It also defines \GraphQLRequest\ and \GraphQLResponse\ case classes for serializing queries and parsing results, including support for response extensions. The \Argument\ class represents query arguments, \Operations\ enforces root-type constraints, and \Zippable\ supports combining selection builders.
client/src/main/scala/caliban/client · high confidence
New Pekko HTTP adapter for Caliban
This change introduces a new \PekkoHttpAdapter\ in the \adapters/pekko-http\ module, enabling users to run Caliban GraphQL services on Apache Pekko HTTP. The adapter provides methods to create HTTP routes for standard queries (\makeHttpService\), file uploads (\makeHttpUploadService\), and WebSocket subscriptions (\makeWebSocketService\). It also includes support for serving the GraphiQL UI (\makeGraphiqlService\), with an overloaded method that accepts a \wsPath\ parameter to configure WebSocket subscription endpoints. The implementation bridges Caliban's ZIO-based interpreters with Pekko's streaming and HTTP capabilities via the Tapir adapter layer.
adapters/pekko-http/src/main · high confidence
New Pekko HTTP examples with GraphiQL and WebSocket support
Added new example applications for the Pekko HTTP adapter that demonstrate modern usage patterns, including built-in GraphiQL endpoints and WebSocket support for subscriptions. The ExampleApp showcases how to configure HTTP, WebSocket, and GraphiQL routes together, while AuthExampleApp illustrates how to implement custom authentication logic using Tapir interceptors.
examples/src/main/scala/example/pekkohttp · high confidence
New Play Framework adapter using Tapir and Pekko Streams
Adds a new Play adapter that integrates Caliban with the Play Framework by leveraging Tapir for HTTP routing and Apache Pekko Streams for handling requests, uploads, and WebSocket subscriptions. This allows users to serve GraphQL APIs, including GraphiQL UI and subscription endpoints, within a Play application using the modern Pekko ecosystem.
adapters/play/src/main · high confidence
New Quick adapter for zio-http with WebSocket and GraphiQL support
The \caliban-quick\ module introduces a new adapter built on zio-http, providing a lightweight alternative to the existing Tapir-based adapters. This new adapter allows users to serve GraphQL APIs with built-in support for WebSocket subscriptions, file uploads, and the GraphiQL UI. It exposes a \QuickAdapter\ class that generates \Routes\ for API, upload, and WebSocket endpoints, along with a convenience \runServer\ method for quick setup. The implementation includes a dedicated \GraphiQLHandler\ to serve the UI from CDN and handles WebSocket protocol negotiation, enabling real-time subscriptions directly through the zio-http server.
adapters/quick/src/main/scala/caliban · high confidence
New Scala 3 schema derivation macros for method-based fields and annotation handling
A new \Macros.scala\ file introduces Scala 3-specific compile-time macros to enhance schema derivation. Users can now derive GraphQL fields directly from case class methods using the \@GQLField\ annotation or automatically for all methods via \@GQLFieldsFromMethods\. The macros also provide specialized logic to correctly identify excluded fields (\@GQLExcluded\) and detect enum fields, ensuring accurate schema generation for these specific patterns in Scala 3.
core/src/main/scala-3/caliban/schema/macros · high confidence
New ZIO-based Federation example application
Added a new example application in the federation module that demonstrates a federated GraphQL setup using ZIO and Caliban. The example includes CharacterService and EpisodeService implementations backed by ZIO's Ref and Queue for state management and event streaming, wired together in FederatedApp to run two separate GraphQL servers (ports 8088 and 8089) serving their respective schemas.
examples/src/main/scala/example/federation · high confidence
New cats-effect interop module for ZIO integration
A new \interop/cats\ module has been added to provide bidirectional conversion between ZIO effects (\RIO\) and Cats Effect types (\F\). This includes \CatsInterop\, \ToEffect\, and \FromEffect\ traits that allow executing GraphQL queries within a Cats Effect context using a \Dispatcher\. It also introduces \InjectEnv\ to support contextual interop, enabling the injection of ZIO environments into effects like \Kleisli\ or \IO\ with \IOLocal\, facilitating seamless integration between ZIO and Cats Effect-based applications.
interop/cats/src/main/scala/caliban/interop/cats · high confidence
New example demonstrating Tapir-to-Caliban interop with GraphiQL support
Added a new example in the \tapirtocaliban\ location that demonstrates how to convert Tapir endpoints into Caliban GraphQL schemas. The example showcases two approaches: using \Endpoint\ with provided logic and using \ServerEndpoint\ with pre-provided logic. It also includes a GraphiQL endpoint at \/graphiql\ for interactive API exploration, serving as a practical reference for users integrating Tapir with Caliban.
examples/src/main/scala/example/tapirtocaliban · high confidence
New gateway examples and OpenTelemetry tracing module
Added runnable gateway example applications demonstrating local, mixed-source, and Federation gateway configurations, including a managed gateway that loads a supergraph from Apollo GraphOS. Introduced a new \caliban-gateway-tracing\ module that provides OpenTelemetry integration for the gateway, recording spans for request preparation, subgraph calls, retries, and subscriptions while propagating W3C trace context.
gateway-examples, gateway-tracing · high confidence
New http4s adapter implementation using Tapir
The http4s adapter has been rewritten to leverage the Tapir library for defining and interpreting HTTP and WebSocket routes. This change introduces new factory methods (such as \makeHttpService\, \makeHttpUploadService\, and \makeWebSocketService\) that bridge Caliban's interpreters with http4s server endpoints via Tapir's \Http4sServerInterpreter\ and \ZHttp4sServerInterpreter\. It also adds support for serving the GraphiQL UI from a CDN and provides utility functions to extract request context into ZIO layers, enabling more flexible middleware and environment management for http4s-based GraphQL servers.
adapters/http4s/src/main · high confidence
New http4s example applications using Tapir adapters
Added two new example applications (ExampleApp.scala and ExampleAppF.scala) demonstrating how to run a Caliban GraphQL server using the http4s framework. These examples showcase the integration of the new Tapir-based adapters (HttpInterpreter and WebSocketInterpreter) for both ZIO and Cats Effect runtimes, providing users with concrete reference implementations for setting up HTTP and WebSocket endpoints with GraphiQL support.
examples/src/main/scala/example/http4s · high confidence
New schema introspection and comparison tools
Added IntrospectionClient to fetch and map GraphQL schema definitions from a remote endpoint, including support for deprecated arguments and descriptions. Introduced SchemaComparison to detect breaking changes between two schemas, specifically adding support for type extensions and preserving interface-implements-interface relationships.
tools/src/main · high confidence
Quick example now supports SSE subscriptions and WebSocket endpoints
The \ExampleApp\ in the \quick\ example has been updated to demonstrate Server-Sent Events (SSE) based subscriptions with a 5-second heartbeat interval and exposes a WebSocket endpoint at \/ws/graphql\. This change reflects the addition of the \QuickAdapter\ (a zio-http adapter without Tapir dependency) and heartbeating for SSE subscriptions, providing users with a concrete reference for configuring these real-time features in their own applications.
examples/src/main/scala/example/quick · high confidence
Support for @defer and @stream directives with configurable execution modes
Caliban now supports the GraphQL @defer and @stream directives, allowing clients to receive partial query results incrementally rather than waiting for the entire response. This is implemented via new execution models in the Executor, including a new QueryExecution configuration with Parallel, Sequential, Batched, and Mixed modes to optimize how effectful fields are resolved. The update introduces a new Feature flag system to enable these capabilities and handles the necessary infrastructure for deferred fragment and stream processing.
core/src/main/scala/caliban/execution · high confidence
WebSocket and SSE configuration support in Caliban Quick adapter
The \caliban-quick\ adapter now exposes configuration options for real-time subscriptions via new \SseConfig\ and \WebSocketConfig\ case classes. Users can control Server-Sent Events (SSE) heartbeat intervals to prevent connection timeouts and configure WebSocket keep-alive times, hooks, and underlying zio-http settings. These configurations are integrated into the \runServer\ and \routes\ convenience methods on \GraphQL\, allowing users to enable and customize WebSocket-based subscriptions by specifying a \webSocketPath\.
adapters/quick/src/main/scala/caliban/quick · high confidence
Behavioural changes
Add source location mapping and improve variable coercion validation
The parsing module now includes a SourceMapper to track line and column information for GraphQL source strings, enabling more precise error reporting. Additionally, the VariablesCoercer has been updated to strictly validate input types during variable coercion, ensuring that variables conform to expected input types and rejecting invalid values earlier in the process.
core/src/main/scala/caliban/parsing · high confidence
Added Scala 2-specific compatibility and optimization utilities
This change introduces new Scala 2-specific source files to support cross-compilation and performance. It adds a \Macros\ object providing a compile-time \gqldoc\ macro to validate GraphQL documents at compile time, stubs for Scala 3-specific annotations (\@static\, \@threadUnsafe\) to ensure API compatibility, and syntax extensions (\EnrichedImmutableMapOps\, \EnrichedListOps\, \EnrichedListBufferOps\) that provide optimized or polyfilled methods like \foreachOne\ and \addOne\ to address Scala 2.12/2.13 differences and hot-path performance.
core/src/main/scala-2/caliban · high confidence
Codegen now supports configurable Scala 3 formatting and granular generation options
The codegen module has been refactored to include a bundled default scalafmt configuration (version 3.8.2, Scala 3 dialect) and a new \CalibanCommonSettings\ structure that exposes granular control over code generation. Users can now configure the output effect type, enable abstract effect types, preserve input names, add type class derives, and toggle support for GraphQL features like \@isRepeatable\ and \@deprecated\ arguments. The generator also handles Scala reserved keywords more robustly via \safeName\ and allows customizing the generated client name and package structure.
codegen/src/main · high confidence
Introduce semi-auto derivation for introspection schema
The introspection schema now uses semi-auto derivation via the new IntrospectionDerivation trait, allowing the system to automatically generate schemas for introspection types like \_\Type, \\Field, and \\Schema while providing explicit control over union types such as \\_TypeKind.
core/src/main/scala-3/caliban/introspection · high confidence
Introspection queries are now explicitly introspectable and support @skip, @include, and @specifiedBy directives
The introspection system has been refactored to allow introspection queries themselves to be introspected, enabling tools to query the structure of the introspection API. This change introduces support for the standard @skip and @include directives on fields, fragment spreads, and inline fragments, as well as the @specifiedBy directive for custom scalars. Additionally, the @oneOf directive is now included in the introspection schema when applicable, and the Boolean and String types are explicitly registered to support these directive arguments.
core/src/main/scala/caliban/introspection · high confidence
Introspection schema derivation via semi-auto trait
The introspection module now provides a new \IntrospectionDerivation\ trait that enables semi-automatic derivation of the introspection schema. By mixing in this trait, users can access the \introspectionSchema\ and rely on implicit \Schema\ instances for \\_\_Type\, simplifying the setup required for introspection capabilities.
core/src/main/scala-2/caliban/introspection · high confidence
Migrate Tapir adapter to use jsoniter for JSON encoding and decoding
The Tapir adapter now uses jsoniter for serializing and deserializing GraphQL requests and responses, replacing the previous JSON library. This change introduces a custom configuration to increase the maximum character and buffer sizes to their limits, allowing handling of larger payloads, and ensures that parse exceptions no longer include hex dumps in their error messages. Users relying on the Tapir integration will see these JSON handling behaviors updated, with jsoniter becoming a required dependency for this module.
interop/tapir/src/main · high confidence
New Akka HTTP example with Tapir-based adapters and GraphiQL support
The Akka HTTP example application has been rewritten to use Tapir adapters for handling HTTP and WebSocket requests, replacing the previous implementation. This change introduces support for GraphQL subscriptions via a WebSocket endpoint at /ws/graphql and includes a GraphiQL interface at /graphiql that is configured to use the new HTTP and WebSocket paths, providing a complete interactive development environment for the example service.
examples/src/main/scala/example/akkahttp · high confidence
New DocumentRenderer and ValueRenderer implementations
The rendering logic for GraphQL documents and values has been replaced with new \DocumentRenderer\ and \ValueRenderer\ components. \DocumentRenderer\ now handles the serialization of GraphQL documents, including support for schema extensions (\extend\), directive definitions, and type system extensions, while adhering to specification requirements for block strings and escape characters. \ValueRenderer\ provides dedicated rendering for input values and response values, ensuring correct formatting for lists, objects, enums, and special types like streams.
core/src/main/scala/caliban/rendering · high confidence
New configuration and execution model for GraphQL APIs
The core module introduces a new \Configurator\ object that allows runtime configuration of query execution, including enabling/disabling introspection, skipping validation, selecting execution strategies (sequential, parallel, batched), and providing custom ZQuery caches. The \GraphQL\ trait and \GraphQLInterpreter\ have been refactored to use this configuration via \FiberRef\, and the \GraphQLRequest\ now tracks whether it originated from a GET request to enforce mutation restrictions. Additionally, \GraphQLAspect\ provides a composable way to transform GraphQL APIs, and helper methods like \renderSchema\ simplify schema rendering.
core/src/main/scala/caliban · high confidence
Refactor stitching internals and add cache invalidation tests
The stitching module has been restructured by introducing new internal abstractions: \PartialRemoteSchema\ to handle schema resolution and environment provisioning for remote types, \ResolveRequest\ to encapsulate field arguments and context, and a package-level \HttpRequest\ type alias. Additionally, a new test suite (\CacheInvalidatorSpec\) has been added to verify that the federation subgraph cache invalidator correctly sends POST requests with the expected authorization headers and JSON body when invalidating subgraphs, types, or cache tags.
stitching · medium confidence
Refactored GraphQL parser into modular components with improved string and number handling
The GraphQL parser implementation has been restructured into distinct, modular traits (NumberParsers, StringParsers, ValueParsers, SelectionParsers, and the main Parsers object) to improve maintainability and performance. This change introduces more robust parsing for string literals, including support for variable-width Unicode escape sequences and corrected handling of block-string line terminators and control-character rendering. It also fixes a bug where float literals containing both a fraction and an exponent were being truncated, and ensures that enum values starting with true, false, or null are correctly parsed without being misinterpreted as keywords.
core/src/main/scala/caliban/parsing/parsers · high confidence
Refactored sbt plugin into modular components with CLI support
The Caliban sbt plugin has been restructured into distinct modules to improve maintainability and add new capabilities. A new CLI interface is now available via \calibanGenSchema\ and \calibanGenClient\ commands, allowing users to generate GraphQL sources and client code directly from the sbt console. The plugin's internal logic has been split into separate files for keys, settings, source generation, and compatibility layers (including Scala 2/3 specific implementations), providing a cleaner architecture for the code generation tasks.
codegen-sbt/src/main · high confidence
Refactored schema construction with dedicated resolver and builder classes
The schema module has been restructured to improve performance and modularity. A new \ObjectFieldResolver\ class replaces previous field resolution logic, utilizing a mutable HashMap for faster lookups when resolving object fields. Schema composition is now handled by \RootSchemaBuilder\ and \Operation\ case classes, which provide a \\|+\|\ operator to merge query, mutation, and subscription definitions along with their associated types and directives. Additionally, \SchemaUtils\ introduces support for the \semanticNonNull\ directive and fixes handling of empty union objects, while \SubscriptionSchema\ enforces that subscriptions are strictly backed by ZIO streams or Unit.
core/src/main/scala/caliban/schema · high confidence
Scala 2 schema and ArgBuilder derivation refactored to use Magnolia 1
The Scala 2-specific schema derivation logic has been rewritten to use Magnolia 1, introducing new version-specific files for annotations, schema derivation, and ArgBuilder derivation. This change enables support for new GraphQL features including \@GQLDirective\ for adding custom directives to schema types, \@GQLOneOfInput\ for one-of input types, and \@GQLValueType\ for treating case classes as scalars. It also improves ArgBuilder behavior by correctly handling value types and providing better fallbacks for parent type annotations.
core/src/main/scala-2/caliban/schema · high confidence
Scala 2.13 compatibility via version-specific hash implementation
The core library now supports Scala 2.13 by introducing separate source directories for Scala 2.12 and 2.13. The \caliban.Hash\ object is implemented differently in each: Scala 2.12 uses \MurmurHash3.productHash\, while Scala 2.13 uses the newer \MurmurHash3.caseClassHash\. This ensures correct hashing behavior for case classes on both supported Scala versions.
core/src/main/scala-2.12, core/src/main/scala-2.13 · high confidence
Scala 3 schema and ArgBuilder derivation implementation
This change introduces the Scala 3-specific implementation for Caliban's schema and argument builder derivation in the \core/src/main/scala-3/caliban/schema\ package. It replaces previous approaches with new files leveraging Scala 3 macros and Magnolia, including \SchemaDerivation.scala\ and \ArgBuilderDerivation.scala\ for automatic type class derivation. The update adds support for deriving GraphQL fields from case class methods via \@GQLField\ and \@GQLFieldsFromMethods\ annotations, handles \oneOf\ input types with \OneOfArgBuilder\, and provides specialized schemas for enums, interfaces, unions, and value types. It also includes utilities for customizing input type naming, handling directives, and supporting semantic non-null features.
core/src/main/scala-3/caliban/schema · high confidence
Scala 3-specific performance and compile-time validation utilities
This change introduces Scala 3-specific implementation files to optimize runtime performance and add compile-time safety. It adds a \Hash\ object to leverage MurmurHash3 for case class hashing, and \syntax\ extensions that use \@static\ and inline methods to optimize map lookups and list iteration (replacing \foreach\ with a while loop) in hot paths. Additionally, a new \Macros\ object provides a \gqldoc\ inline macro that validates GraphQL document strings at compile-time, aborting compilation if the document is invalid.
core/src/main/scala-3/caliban · high confidence
Switch WebSocket protocol support to jsoniter
The GraphQL WebSocket client now uses jsoniter for encoding and decoding messages instead of the previous JSON library. This change introduces new request and response case classes (GraphQLWSRequest and GraphQLWSResponse) that rely on jsoniter codecs, ensuring consistent serialization behavior across the WebSocket transport layer.
client/src/main/scala/caliban/client/ws · high confidence
Updated @connect directive builder and added support for Connect spec versions v0.1–v0.4
The federation module now includes a corrected builder for the @connect and @source directives, ensuring proper generation of HTTP method, URL, body, headers, selection, source, entity, batch, and error configurations. Additionally, support for Apollo Connect specification versions v0.1 through v0.4 has been added via the new ConnectV0 object, enabling compatibility with these earlier versions of the connect spec.
federation/src/main/scala/caliban/federation/connect · high confidence
Updated magnolia integration to v1 for Scala 2 schema derivation
The macros module now uses Magnolia v1 for automatic schema derivation in Scala 2. This change introduces new files (Derived.scala and DerivedMagnolia.scala) that wrap Magnolia's generation output to manage implicit priority, ensuring that derived schemas work correctly alongside other implicit definitions.
macros · high confidence
Updated test-compile client examples to use sttp 4
The client implementation examples in the compile-time codegen test suite have been updated to use sttp 4 for HTTP requests, replacing the previous client library. This change affects the generated client code structure, specifically how requests are sent and responses are handled within the test modules.
codegen-sbt/src/sbt-test/compiletime-codegen/test-compile/modules/clients · high confidence
Validation logic refactored into separate, optimized components
The validation logic in \core/src/main/scala/caliban/validation\ has been restructured into distinct, specialized files (\FieldMap\, \FragmentValidator\, \SchemaValidator\, \ValueValidator\, \ValidationOps\, and \Validator\) to improve performance and maintainability. This change introduces a new \FieldMap\ for efficient collection of fields and fragments, a dedicated \FragmentValidator\ with caching and memoization to optimize conflict detection, and a \SchemaValidator\ that enforces stricter rules for input objects (including \@oneOf\ support) and directives. The refactoring also adds \ValidationOps\ for streamlined error handling and \Utils\ for type checking, resulting in faster validation execution and more precise error reporting for users.
core/src/main/scala/caliban/validation · high confidence
Test coverage
3 commits adding/updating tests in gateway; Add gen-client-task scripted test with GitLab schema and scalafmt integration; Add integration tests for the HTTP4s adapter; Add scripted test infrastructure for caliban-codegen-sbt; Added benchmark suite for query execution and validation performance; Added compile-time codegen test examples using semi-auto derivation; Added comprehensive test coverage for schema derivation, rendering, and validation; Added comprehensive test suite for the Scala code generator; Added integration tests for the HTTP4s adapter; Added integration tests for the ZIO HTTP Quick adapter; Added integration tests for the gen-client task; Added placeholder directories for test modules; Added scripted test for caliban-codegen-sbt; Added scripted test for split-files code generation; Added scripted tests for compile-time Caliban client code generation; Added snapshot test for PostService GraphQL API validation; Added test coverage for Caliban client core components; Added test for newtype and lazy directive code generation; Added test suite for Federation v2.x schema directives and fixtures; Added test suite for the Tapir adapter integration; Added tests for Cats interop contextual and plain modes; Added tests for FS2 stream interop schema derivation; Added tests for Federation Tracing behavior; Added tests for Federation V1 entity resolution and SDL generation; Added tests for ReportingDaemon schema reporting behavior; Added tests for SBT codegen options parsing; Added tests for introspection client, remote schema parsing, and schema comparison; Added tests for the Pekko HTTP adapter; Added tests for tracing and masking functionality; Expanded GraphQL schema test coverage for codegen edge cases; Expanded test coverage for GraphQL client code generation; Test configuration for Play adapter buffer limits; Test suite defines ZIO environment type for newtype compilation.
Dependencies
Dependency and build configuration updates
This release updates the project's build configuration and dependencies, including upgrading Scala versions (2.12.21, 2.13.18, 3.3.8), ZIO (2.1.26), Tapir (1.13.32), and various other libraries like http4s, Play, and ZIO-HTTP. It also introduces a new \client-laminext\ module with its own \package.json\ for frontend dependencies and adds several SBT scripted tests for the codegen plugin to verify compilation and generation settings across different Scala versions.
(dependencies) · high confidence
Upgrade build infrastructure to sbt 1.13.0 and update core plugins
The project's build system has been upgraded to sbt 1.13.0, accompanied by significant updates to key plugins: sbt-scalafmt to 2.6.2, sbt-scalajs to 1.22.0, sbt-scala-native to 0.5.12, sbt-ci-release to 1.12.1, and sbt-mdoc to 2.9.2. To support this modernized build environment, new helper utilities have been introduced, including a console welcome message that displays useful sbt tasks and version information, a scripted dependency definition for testing (sttp 3.10.1, zio-test 2.1.9), and a dedicated Scala 3 test helper command to verify codegen-sbt compilation across Scala 2.12 and Scala 3.
project · high confidence
Housekeeping
Project initialization and repository setup
The repository has been initialized with essential configuration files, including \.gitignore\, \.scalafmt.conf\ (version 3.8.2), \.pre-commit-config.yaml\, and \.sbtopts\ (configuring 3G metaspace and heap). Documentation files such as \README.md\, \CONTRIBUTING.md\, and \CODE\_OF\_CONDUCT.md\ have been added, along with a list of adopters.
(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 58 → 58 (+0.1)
- Rubric changed (rubric-2026.10.5 → rubric-2026.11.4) — scores are not directly comparable.
Lenses
- Code Health 70 → 67 (-3.2)
- Architecture 82 → 82 (+0.0)
- Maturity 52 → 55 (+2.9)
- Readiness 55 → 54 (-1.3)
- Security 65 → 58 (-6.7)
- Performance 80 → 94 (+14.0)
Resolved (7)
- Duplicated block (11 lines × 3) (adapters/akka-http/src/main/scala/caliban/AkkaHttpAdapter.scala)
- Duplicated block (17 lines × 2) (core/src/main/scala-2/caliban/schema/SchemaDerivation.scala)
- Duplicated block (5 lines × 2) (core/src/main/scala/caliban/parsing/Parser.scala)
- No ADRs found
- Off-boarding risk: anonymized user #1
- Orphaned file (core/src/main/scala/caliban/relay/PaginationArgs.scala)
- TooManyMethods: SchemaComparison (tools/src/main/scala/caliban/tools/SchemaComparison.scala)
New (55)
- Duplicated block (25 lines × 2) (core/src/main/scala-2/caliban/schema/SchemaDerivation.scala)
- Edited copies of one member (3 members, 12+ corresponding lines) (tools/src/main/scala/caliban/tools/SchemaComparison.scala)
- Edited copies of one member (3 members, 13+ corresponding lines) (core/src/main/scala/caliban/rendering/DocumentRenderer.scala)
- Edited copies of one member (3 members, 54+ corresponding lines) (adapters/akka-http/src/main/scala/caliban/AkkaHttpAdapter.scala)
- Edited copies of one member (3 members, 6+ corresponding lines) (core/src/main/scala/caliban/schema/Schema.scala)
- Edited copies of one member (3 members, 7+ corresponding lines) (core/src/main/scala/caliban/CalibanError.scala)
- Edited copies of one member (4 members, 12+ corresponding lines) (core/src/main/scala/caliban/wrappers/CostEstimation.scala)
- Edited copies of one member (4 members, 7+ corresponding lines) (interop/cats/src/main/scala/caliban/interop/cats/CatsInterop.scala)
- Edited copies of one member (5 members, 13+ corresponding lines) (federation/src/main/scala/caliban/federation/EntityResolver.scala)
- Edited copies of one member (6 members, 6+ corresponding lines) (core/src/main/scala/caliban/schema/Schema.scala)
- Edited copies of one member (7 members, 7+ corresponding lines) (core/src/main/scala/caliban/GraphQL.scala)
- Edited copies of one member (8 members, 3+ corresponding lines) (client/src/main/scala/caliban/client/SelectionBuilder.scala)
- Edited copy of a member (10 corresponding lines) (core/src/main/scala-3/caliban/schema/ArgBuilderDerivation.scala)
- Edited copy of a member (10 corresponding lines) (core/src/main/scala/caliban/parsing/parsers/Parsers.scala)
- Edited copy of a member (10 corresponding lines) (core/src/main/scala/caliban/relay/PaginationArgs.scala)
- Edited copy of a member (10 corresponding lines) (core/src/main/scala/caliban/rendering/Renderer.scala)
- Edited copy of a member (10 corresponding lines) (core/src/main/scala/caliban/wrappers/CostEstimation.scala)
- Edited copy of a member (10 corresponding lines) (tools/src/main/scala/caliban/tools/SchemaComparison.scala)
- Edited copy of a member (11 corresponding lines) (adapters/http4s/src/main/scala/caliban/Http4sAdapter.scala)
- Edited copy of a member (11 corresponding lines) (core/src/main/scala/caliban/introspection/adt/__Field.scala)
- …and 35 more
Changes since last survey
- 31 commits — 31 feature/other, 0 fixes
By area
- core/src — 14 commits
- (root) — 9 commits
- docs/docs — 3 commits
- vuepress/docs — 2 commits
- codegen/src — 1 commit
- gateway/src — 1 commit
- project/build.properties — 1 commit
Notable commits
- change: Add @deprecated to introspected directives with a default reason (#3213)
- change: Add lookahead restrictions to number literals (#3207)
- change: Add schema coordinates (#3217)
- change: Allow empty selection sets (#3218)
- change: Don't use $ in generated pattern variable names (#3181)
- change: Fetch entities below union members only for their own fragment (#3220)
- change: Forbid @skip/@include on the subscription root selection set (#3209)
- change: Keep the enclosing type condition in fragments without one (#3221)
- change: Keep whitespace following a braced unicode escape in strings (#3215)
- change: Link to Shard instead of Shardcake in the about page (#3175)
- change: Link to the ghostdogpr stack page (#3182)
- change: Make includeDeprecated arguments Boolean! = false (#3211)
- change: Raise a field error for non-finite Float values (#3195) (#3208)
- change: Reject implementation fields deprecated while the interface field is not (#3199) (#3212)
- change: Reject input objects that cannot have a finite value (#3216)
- change: Reject lone surrogate escapes in strings (#3210)
- change: Set PaginationError as the cause of rejected pagination arguments (#3180)
- change: Support descriptions on operations, fragments and variable definitions (#3214)
- change: Update commons-lang3 to 3.22.0 (#3193)
- change: Update jsoniter-scala-circe, ... to 2.42.1 (#3170)
- …and 11 more
Architecture
- Containers 0 added · 0 removed · contexts 1 added · 1 removed · edges 1 added · 2 removed
Added bounded contexts (1)
- codegen-sbt/src/sbt-test/compiletime-codegen/test-compile
Removed bounded contexts (1)
- codegen-sbt/src/sbt-test/compiletime-codegen/test-compile
Added dependency edges (1)
- codegen-sbt/src/sbt-test/compiletime-codegen/test-compile → repository (coupling)
Removed dependency edges (was a dependency, now gone) (2)
- codegen-sbt/src/sbt-test/compiletime-codegen/test-compile → repository (coupling)
- repository → codegen-sbt/src/sbt-test/compiletime-codegen/test-compile (coupling)
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
Survey your own repository
ghostdogpr/caliban 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 14 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 9fce325a05168430d3eb272ea2299acc3638e4ef — the exact code this score is about.
- Scored under rubric-2026.11.4 — 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.65+preprod-e1a3b69fc8ee.