Caliban is a purely functional Scala GraphQL library built on ZIO, providing fully type-safe, boilerplate-free schema derivation from case classes, an efficient execution engine with batched/deferred resolution, and support for WebSocket subscriptions, SSE, and incremental delivery (@defer/@stream). It implements Apollo Federation (v1 and v2) with entity resolvers, tracing, and schema reporting. The library offers a type-safe client module for Scala.js and JVM, an sbt plugin for compile-time code generation from GraphQL schemas, and adapters for http4s, Akka HTTP, Pekko HTTP, Play, and ZIO HTTP. Interoperability is provided through Cats Effect, Monix, Tapir, and multiple JSON libraries (circe, zio-json, jsoniter, play-json). The repository includes extensive tests, JMH benchmarks, and Apollo compatibility tests. It is actively maintained and cross-compiled for Scala 2.13 and 3.
urql is a highly customizable and versatile GraphQL client library for JavaScript/TypeScript, organized as a monorepo with a core package (`@urql/core`), multiple exchange packages (middleware), and framework-specific bindings for React, Preact, Vue, Svelte, Solid, and Next.js. The core architecture is built on a composable exchange pipeline using Wonka reactive streams, where operations flow through a chain of exchanges (e.g., cache, fetch, subscription, SSR) that can be mixed and matched. The client dispatches GraphQL queries, mutations, and subscriptions, and returns results as streams. The `@urql/exchange-graphcache` package provides a sophisticated normalized cache with support for offline persistence, optimistic updates, pagination resolvers (Relay and simple), and schema-aware partial results. Framework integrations expose idiomatic hooks (e.g., `useQuery`, `useMutation`) or stores that wrap the core client and manage component lifecycle. External dependencies include Wonka for streams, `@0no-co/graphql.web` for GraphQL parsing, and framework-specific libraries. The repository also includes a documentation site, extensive examples, and a comprehensive test suite using Vitest and Cypress.
Houdini is a full-stack GraphQL client framework with a compile-time-first approach, targeting React and Svelte applications. It consists of a Go-based compiler pipeline that extracts GraphQL documents from source files, generates optimized runtime artifacts (TypeScript), and manages caching, pagination, subscriptions, and optimistic updates. The runtime includes a normalized cache with fine-grained reactivity, client-side pagination (cursor and offset), progressive form handling with CSRF protection, OAuth integration, and a file-based routing system. The framework also provides a Vite plugin for HMR, a language server (LSP) with GraphQL completions and diagnostics, and production adapters for Node.js, Cloudflare, and static hosting. The architecture is hybrid: the core compiler is written in Go using SQLite for metadata storage, while the client runtime and framework integrations are TypeScript, with a plugin system supporting both Go and JavaScript extensions. The codebase is highly modular, with extensive unit and end-to-end test coverage across both SvelteKit and React.
Bruno is a comprehensive API client and testing tool built with Electron, React, and Redux. It provides a full-featured interface for creating, sending, and analyzing HTTP/WebSocket/gRPC/GraphQL requests, similar to Postman but with an open-source core. The application features a modular architecture with separate packages for the GUI (bruno-app), Electron main process (bruno-electron), CLI (bruno-cli), request handling (bruno-requests), file storage (bruno-filestore), and shared utilities (bruno-common). Key capabilities include environment and variable management with secure secret handling, pre-request and test scripting using a custom BruJS runtime, collection organization and workspaces, import/export from formats like Postman, OpenAPI, and Insomnia, mock server functionality, and code generation from requests. The UI uses styled-components for theming with light/dark/system themes, and incorporates advanced features like AI-assisted request building and OpenAPI synchronization. The codebase demonstrates strong engineering practices with extensive unit and end-to-end testing, TypeScript throughout, and a clean separation of concerns between the main and renderer processes via IPC. Notable reusable components include a secure variable interpolation system, cross-platform detection utilities, persistent state hooks, and a worker-offloaded file format parser.
Suwayomi-JUI is a multiplatform manga reader application built with Kotlin Multiplatform, targeting Android, Desktop, and iOS. It functions as a client for the Suwayomi-Server backend, communicating via GraphQL (Apollo) and REST (Ktor) to manage a personal manga library, download content for offline reading, and provide a customizable reading experience. The architecture follows a clean layered structure: core utilities, data layer (repositories and network clients), domain layer (business logic and use cases), and presentation layer (UI with Jetpack Compose/SwiftUI). Key features include library management with categorization, extension/plugin support, download queue management, reading interface with various navigation modes, backup/restore functionality, and comprehensive settings. The application employs dependency injection via custom annotations, reactive programming with Kotlin Flows and coroutines, and a cross-platform preference storage system. It is actively maintained with recent commits and demonstrates strong engineering practices in modularity and platform abstraction.
The official Buildkite CLI (`bk`) is a production-grade Go command-line client for the Buildkite CI/CD platform. It interacts with Buildkite's REST and GraphQL APIs to manage pipelines, agents, builds, jobs, clusters, secrets, teams, and more. The architecture follows a command-pattern with Kong-based parsing, a centralized factory for dependency injection, and a rich set of I/O primitives (spinners, pagers, confirmation prompts) that produce structured output (JSON, YAML, text tables). It includes advanced authentication flows (OAuth device/PKCE), token refresh, keyring-backed credential storage, and self-update capabilities. The codebase demonstrates strong engineering discipline with extensive parallel tests, mock HTTP servers, and a composable error handling framework.
@octokit/graphql.js is a lightweight, purpose-built JavaScript library for making GraphQL queries to the GitHub API. It wraps the `@octokit/request` HTTP client to handle authentication, variables, error parsing, and GitHub Enterprise Server base URL normalization. The primary entry point is the `graphql` function, which accepts a query string and optional parameters (variables, headers, operation name) and returns a promise of the response data. It also exposes a `withCustomRequest` factory for injecting a custom request instance, a `GraphqlResponseError` class for structured error handling, and a `withDefaults` method for creating pre-configured instances. The library is fully typed with TypeScript, supports ESM and bundling, and follows the Octokit ecosystem conventions. It does not handle pagination or subscription – it is purely a thin GraphQL client for the GitHub API.
graphql-hooks is a lightweight React GraphQL client library that provides a set of hooks for querying, mutating, and subscribing to GraphQL endpoints. It is designed as a minimal yet feature-rich alternative to Apollo Client, with a focus on small bundle size (22.9 kB gzipped). The library is organized as a Lerna monorepo containing the core package (`graphql-hooks`), an in-memory cache (`graphql-hooks-memcache`), SSR utilities (`graphql-hooks-ssr`), and a Babel plugin for compile-time GraphQL query extraction (`babel-plugin-extract-gql`). In production, the system operates as a client-side GraphQL executor within React applications. The primary entry points are React hooks: `useQuery`, `useMutation`, `useManualQuery`, and `useSubscription`. These hooks internally use `GraphQLClient` to send HTTP or WebSocket requests, passing through an optional middleware pipeline. The client supports caching via a pluggable interface (defaulting to `graphql-hooks-memcache` with LRU eviction and TTL), automatic refetching after mutations, file uploads via the GraphQL multipart spec, and server-side rendering by pre-fetching query results and injecting initial state into the HTML. Key data flows begin when a React component calls a hook. The hook interacts with `GraphQLClient`, which applies middleware (e.g., Automatic Persisted Queries or custom interceptors) before sending the request. Responses are cached and returned to the component. Mutations can optionally trigger refetches of related queries via an event emitter. The architecture promotes separation of concerns via middleware, a clean cache API, and support for multiple transport layers (HTTP, WebSocket, Full-WS). External dependencies include React (peer), `graphql-ws` or `subscriptions-transport-ws` for subscriptions, and `formdata-node` for file uploads in Node environments.
GraphQL Zeus is a TypeScript-first GraphQL client generator that produces a fully type-safe query builder from any GraphQL schema. It provides a CLI tool (`zeus`) that accepts a GraphQL schema file or introspection URL and generates a complete TypeScript client with zero runtime dependencies beyond `cross-fetch` and `ws` (for subscriptions). The generated client supports multiple transport modes: standard HTTP via `Chain` and `Thunder` (with custom fetch injection), WebSocket subscriptions (both legacy and `graphql-ws`), and Server-Sent Events (SSE). It also offers integration helpers for Apollo Client (`typedDocumentNode`) and exports reusable selection set composition via `Selector`. The monorepo is structured into three packages: `graphql-zeus` (CLI orchestration), `graphql-zeus-core` (code generation engine and runtime functions), and `graphql-zeus-jsonschema` (JSON Schema generation from input types). The code generation pipeline parses the schema into a tree structure, then templates it into TypeScript types and runtime functions. The project is moderately well-maintained with active issues and a test suite focused on the core code generator, though the CLI lacks automated tests and the build tooling relies on the deprecated `ttypescript` package, indicating some technical drift.