Projects sharing features with Graphql Tools

Graphene is a library and framework for building type-safe GraphQL APIs and schemas using Python objects and resolvers. It provides a system for mapping internal data models to typed GraphQL schemas, enabling the creation of servers that process queries and execute resolvers to return structured data. The project includes a full implementation of the Relay specification, providing standardized patterns for global object identification and cursor-based pagination. It utilizes a class-based approach to schema definition and supports interface-based type inheritance. The framework covers a broa

This project is a PHP implementation of the GraphQL specification. It provides a suite of tools for building servers that process queries and mutations, including a schema parser, an execution engine for evaluating operations, and a toolkit for manipulating abstract syntax trees. The library differentiates itself through a specialized AST toolkit that allows for the inspection, modification, and printing of GraphQL abstract syntax trees. It also includes a mechanism for deferred field resolution to enable asynchronous data fetching and prevent blocking the primary execution thread. The imple

Strawberry is a type-safe GraphQL library for Python that enables the design of schemas using Python type annotations and dataclasses. It functions as an asynchronous GraphQL server and execution engine, providing a bridge to expose schemas across ASGI-compliant web frameworks such as FastAPI, Django, Flask, and Litestar. The project implements GraphQL Federation, allowing for the creation of distributed schemas and entities that merge into a unified supergraph across multiple services. It also includes a dedicated toolkit for the Relay specification, supporting global object identification a

HotChocolate is a GraphQL server implementation for .NET that handles queries, mutations, and subscriptions over HTTP. It provides code-first schema generation directly from C# classes and attributes, keeping the schema and business logic in sync without manual type definitions. The project also includes a GraphQL gateway that composes multiple GraphQL and REST endpoints into a single unified schema, along with a GraphQL IDE for exploring, testing, and debugging GraphQL APIs interactively. The project distinguishes itself through its comprehensive tooling ecosystem, which includes a GraphQL c

gqlgen is a schema-first Go library designed to build type-safe GraphQL servers. It functions as a code generation engine that transforms declarative GraphQL schema definitions into strongly-typed Go source code, ensuring strict alignment between the API contract and the underlying implementation. The framework distinguishes itself through its deep integration with the Go type system and its highly extensible build pipeline. By using schema-first development, it automates the creation of server boilerplate and resolver stubs, allowing developers to map schema fields directly to Go structs and

Type-graphql is a framework for building GraphQL servers that uses TypeScript classes as the single source of truth for schema definitions and types. It provides a schema generator and a resolver framework that allows developers to define queries and mutations using class-based controllers and decorators. The project focuses on a schema-first approach where TypeScript classes and metadata reflection are used to automatically derive GraphQL schemas. It incorporates a dependency injection container to manage the instantiation and lifecycle of resolver classes. The system includes a middleware

GraphQL.NET is a server-side framework for building and executing GraphQL APIs within C# applications. It provides a comprehensive toolkit for schema building, a federated engine for distributed data graphs, and a subscription handler for managing real-time data streams. The project distinguishes itself with a flexible schema builder that supports both programmatic code-first definitions and declarative schema-first approaches using the standard schema definition language. It includes a dedicated federation engine to split data graphs into subgraphs and compose them into a unified gateway, as

graphql-go is a schema-first GraphQL library and server implementation for Go. It provides a query execution engine and schema parser that converts schema definition strings into executable structures and validates resolver signatures. The library also includes a streaming implementation for real-time GraphQL subscriptions using channels within resolvers. The project distinguishes itself through parallel resolver execution to reduce request latency and the use of buffer-pool memory management to lower garbage collection overhead. It enables the creation of cloneable schema instances from a sh

Spring GraphQL is a Java framework designed for building GraphQL services by mapping schema definitions directly to backend controller logic. It provides a reactive execution engine that processes queries and subscriptions asynchronously, supporting multiple network transports to facilitate communication between clients and data sources. The framework distinguishes itself through annotation-driven request routing, which decouples schema definitions from business logic to reduce implementation boilerplate. It includes native support for federated service composition, allowing developers to agg

This project is a GraphQL implementation for Go, providing a complete suite for building GraphQL servers. It includes a schema engine for defining types, a query parser to convert strings into abstract syntax trees, and an execution engine that resolves fields against a defined schema to return structured data. The library distinguishes itself through reflection-based type mapping, allowing object definitions and arguments to be derived directly from native Go structs. It also supports the execution of real-time data streaming via GraphQL subscriptions and provides an extensible execution pip

async-graphql is a type-safe framework for building specification-compliant GraphQL servers in Rust. It uses procedural macros to automatically generate schemas from native language structures, ensuring consistency between the data model and the API specification. The project provides native support for Apollo Federation v2, allowing entities and fields to be shared and resolved across multiple distributed subgraphs. It also implements real-time data streaming via WebSocket subscriptions and asynchronous event streams. The framework includes a wide array of capabilities for schema design, su

Pothos is a code-first GraphQL schema builder and framework designed for type-safe development. It allows developers to construct schemas using typed definitions in TypeScript, eliminating the need for external code generation steps. The framework distinguishes itself through a dedicated data mapper that connects GraphQL types to relational databases and ORMs, such as Prisma, while optimizing query resolution. It provides a full implementation of the Relay specification, including global object identification and cursor-based pagination. The project covers several core capability areas, incl

Apollo Server is a spec-compliant JavaScript implementation for building GraphQL APIs that resolve queries and mutations based on a defined schema. It functions as a Node.js framework that integrates GraphQL functionality into various web frameworks and serverless environments through middleware. The project provides a federated GraphQL gateway that aggregates multiple distributed subgraphs into a single unified entry point. It includes a built-in interactive API sandbox for testing operations at the server endpoint and a schema registry client to automate the synchronization of API definitio

This project is a comprehensive educational resource and fullstack tutorial for GraphQL development. It provides instructional content and guides focused on designing schemas, implementing servers, and managing the end-to-end workflow of building production-ready applications. The material covers the conceptual differences between graph-based data structures and traditional API architectures. It includes a dedicated security course and guides for client integration, teaching users how to fetch data, manage application state, and apply protection measures to secure API endpoints. The scope of

This project is a strongly-typed GraphQL client library and code generator designed for Android, JVM, and Kotlin Multiplatform. It provides a toolset for executing queries and mutations, generating immutable classes and parsers from GraphQL schemas to ensure compile-time type safety. The library features a normalized client-side caching system that flattens server responses into a lookup table to maintain a single source of truth. It includes a specialized subscription client for handling real-time server-side updates via WebSockets or Server-Sent Events, and a mocking framework for simulatin

Juniper is a GraphQL server library and schema engine for Rust. It provides a toolkit for building type-safe APIs by mapping native Rust data structures to GraphQL objects, inputs, and scalars. The project functions as an execution engine that can process queries and mutations either through a network server or as a headless engine for local execution. The library is runtime-agnostic, allowing it to bridge GraphQL processing with various asynchronous Rust web frameworks. It includes a subscription framework that manages persistent WebSocket connections to push real-time data updates to client

This project is a full stack monorepo boilerplate and Node.js GraphQL API template. It provides a seed project that integrates a schema-first GraphQL API, a PostgreSQL database, and a React frontend within a single repository to share types between the backend and user interface. The architecture includes a serverless wrapper for cloud deployment and automatic scaling. It implements a request batching layer to optimize database performance by preventing the N+1 query problem. The project covers database management through migration-based schema versioning and seed files. It also includes cap

Javalin is a lightweight web framework for Java and Kotlin designed for building REST APIs and web applications. It functions as an embedded Jetty web server, allowing applications to run as standalone processes without the need for an external servlet container. The project provides specialized frameworks for diverse communication patterns, including a REST API framework with automatic OpenAPI schema generation, a GraphQL API framework with query and mutation resolvers, and a WebSocket server for bidirectional real-time communication. It also includes a dedicated framework for pushing real-t

Apihub is a deployable REST API mock server and public sandbox that provides a collection of functional endpoints for testing HTTP requests and building frontend portfolios. It serves as a pre-built backend infrastructure for simulating diverse services without requiring a custom backend. The project provides dedicated mock endpoints for various business domains, including ecommerce workflows, social networking features, realtime chat, and task management. It also includes specialized endpoints for verifying HTTP method behavior and header handling. The system implements a RESTful architectu

Easy Mock is a tool for API mocking and simulation that allows for the creation of fake server responses using schemas. It enables the generation of mock API data and the implementation of OpenAPI specifications to align development with technical contracts. The project supports collaborative API design through a shared workspace where team members can synchronize and manage mock endpoints. It also features specification-driven bootstrapping, which automatically constructs mock environments by importing standard API definition files. The system provides API development proxying to forward re

This project is a multi-protocol API simulation and mocking system designed to replace external dependencies during development and testing. It provides an API mocking server, a network traffic proxy, and specialized simulators for language model services and identity providers. The system distinguishes itself through deep AI simulation capabilities, including the emulation of language model providers and Model Context Protocol servers using JSON-RPC 2.0. It supports multi-turn conversational logic, state tracking for AI chat APIs, and the visualization of agent execution through call graphs

Mockoon is an HTTP API simulation platform and design tool used to create fake API endpoints that simulate server responses without a backend. It functions as an OpenAPI mock server tool and a JSON API mocking utility, allowing for the rapid iteration of API contracts and the generation of response templates. The project distinguishes itself through a combination of stateful mocking, using a local JSON database to simulate CRUD operations, and the ability to run as a headless API mock server via a command line interface. It supports real-time collaborative editing and AI-assisted prototyping

json-server is a development toolset used to simulate a full REST API from a JSON file. It functions as a customizable mock API server that allows for the simulation of CRUD operations and resource relationships without the need to write backend code. The project enables rapid prototyping by generating a fake backend that persists data changes back to a local JSON file. It distinguishes itself by providing a static asset file server to deliver local documents, images, and stylesheets alongside the mock API endpoints. The server includes capabilities for data querying, such as parameter-based

This platform serves as a centralized web interface for managing, executing, and reporting on automated API test suites and manual endpoint validation tasks. It provides a comprehensive environment for RESTful service testing, allowing users to organize projects, track team access, and maintain a clear history of execution results to monitor system stability. The platform distinguishes itself by integrating a mock server that generates synthetic responses for API endpoints, enabling client-side development and testing before backend services are fully implemented. It supports complex testing

api-blueprint is a markdown-based API design language and specification standard used to define the structure, behavior, and data schemas of HTTP web services. It provides a formal method for mapping HTTP methods to resources and defining payload validation rules through a machine-readable syntax. The project functions as a blueprint for creating interactive technical documentation and functional mock servers. These tools transform design specifications into human-readable guides and simulated backend environments to enable integration testing before implementation. The language covers API m

Keystone is a GraphQL headless content management system and Node.js backend framework. It functions as a schema-driven data manager that automatically generates a GraphQL API and a React administrative dashboard based on a central data model configuration. The system uses an adapter-based database abstraction to decouple core logic from storage layers and a storage-provider abstraction for managing media assets via local or cloud drivers. It distinguishes itself through a component-based field rendering system and a hook-based middleware pipeline for data validation and automation. The fram

Karate is an end-to-end testing framework and API test automation tool used to validate REST and SOAP APIs, drive browser interactions, and measure system performance. It functions as a unified solution for executing automated tests across both API backends and web frontends. The framework utilizes a custom domain specific language and Gherkin-style feature mapping to define requests and assertions. It includes an API mocking server to simulate backend responses, enabling development and integration testing without live dependencies. The tool covers a broad range of functional testing catego