Sangria (Scala)

Sangria (Scala)
Name	Sangria
Paradigm	Functional, Declarative, Query
Developer	Elliotte Rusty Harold, Alexey Klyukin, Sergio Benitez
First appeared	2014
Stable release	2.0.0
Typing	Static, Strong
Influenced by	Scala (programming language), GraphQL, Akka
Operating system	Cross-platform
License	MIT License

Sangria (Scala) Sangria is a Scala library for building and executing GraphQL schemas and queries. It provides a type-safe, composable API for defining Schema (GraphQL), Resolver (computer science), and execution semantics compatible with GraphQL specification implementations used by services such as Apollo GraphQL, Relay (JavaScript) and server frameworks like Play Framework and Akka HTTP. Sangria targets backend developers integrating with platforms including Amazon Web Services, Heroku, and Google Cloud Platform.

Overview

Sangria implements a GraphQL reference for the JVM ecosystem, enabling integration with Scala (programming language), Akka, Play Framework, Finagle, and Http4s. It exposes APIs for defining Object (computer science), Interface (computing), Union (computing), Enum (programming), and Scalar (computer science) types, while supporting features from the GraphQL specification like directives, fragments, and introspection. Sangria's design emphasizes compatibility with tools such as GraphiQL, Apollo Client, Insomnia (software), and Postman.

Features

Sangria provides typed schema definition and runtime execution with support for GraphQL features: query parsing, validation, execution, subscriptions, and schema stitching. It includes utilities for batching via DataLoader (programming pattern), error handling compatible with Sentry (software), and tracing compatible with OpenTracing and OpenTelemetry. The library offers integrations with Circe (software), Play JSON, and Spray JSON for JSON marshalling and with Slick (database query and access library) and Doobie for data access. Sangria supports middleware patterns used by Express (web framework)-style stacks and adapters for gRPC and GraphQL Federation.

Architecture and Design

Sangria's core components include an AST parser, a type system, an execution engine, and a subscription runtime. The execution engine follows resolvers and field collectors similar to implementations in GraphQL.js and the GraphQL specification, while leveraging Scala (programming language) features like implicits, typeclass resolution, and Future (Scala) for concurrency. Schema construction uses builders inspired by Slick (database query and access library) and module patterns observed in Play Framework and Akka HTTP. For performance, Sangria employs execution strategies comparable to Apollo Server optimizations and uses batching patterns from DataLoader (programming pattern) adopted in Relay (JavaScript) ecosystems.

Usage and Examples

Typical usage involves defining types with Sangria's schema DSL, writing resolvers that return scala.concurrent.Future, and mounting a route in Play Framework or an Akka HTTP route. Example workflows mirror patterns popularized by GraphQL.org reference projects and tutorials from ThoughtWorks and Lightbend. Developers commonly pair Sangria with ORMs like Slick (database query and access library) or query libraries like Doobie when accessing backends such as PostgreSQL, MongoDB, or MySQL. For real-time use, Sangria integrates with WebSocket transports used by Socket.IO and Phoenix (web framework) approaches.

Integration and Ecosystem

Sangria sits within an ecosystem that includes GraphiQL, Apollo Client, Relay (JavaScript), and server toolchains like Play Framework, Akka HTTP, Http4s, and Finagle. Serialization and codec integrations include Circe (software), Play JSON, Spray JSON, and adapters for Jackson (software). Sangria participates in community projects around GraphQL Federation, Apollo Federation, and tooling from GraphQL Code Generator. CI/CD pipelines for Sangria-backed services often use Jenkins, Travis CI, GitHub Actions, and container runtimes like Docker deployed to Kubernetes clusters managed by Helm.

Performance and Benchmarks

Performance characteristics depend on schema complexity, resolver IO patterns, and execution strategies. Benchmarks compare Sangria against GraphQL.js and Apollo Server in contexts like throughput on Akka HTTP or Play Framework servers, showing competitive latency when resolvers use non-blocking scala.concurrent.Future and batching via DataLoader (programming pattern). Real-world deployments at scale mirror practices from Netflix and Facebook for caching, tracing with Zipkin, and monitoring with Prometheus and Grafana.

History and Development

Sangria emerged from community efforts in the Scala (programming language) ecosystem to bring GraphQL support to the JVM. Early contributions came from maintainers active in Typelevel and Lightbend communities, and its development paralleled growth in projects like Akka and Play Framework. Over successive releases Sangria added features for subscriptions, federation, and improved integrations with JSON libraries such as Circe (software). Maintenance continues via contributors collaborating through GitHub, following practices from open-source projects like ScalaZ and Cats (library).

Category:Scala (programming language) libraries