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.
GraphQL Voyager is an interactive GraphQL schema explorer that visualizes any GraphQL API as an interactive graph. It consumes GraphQL introspection data (or SDL) and renders a navigable representation of the schema's types, fields, and relationships using Graphviz and SVG. The application is built with React and TypeScript, offering multiple consumption methods: a standalone bundle for direct browser use, an NPM package for integration with bundlers like Webpack, and middleware adapters for Express, Hapi, and Koa frameworks. The core functionality involves processing introspection JSON to extract type information, filtering out internal types (like Relay) and deprecated fields, and constructing a graph where nodes represent GraphQL types and edges represent relationships (such as field types). This graph is rendered via a Graphviz worker, with the resulting SVG enhanced for interactivity (tooltips, pan/zoom, click-to-explore). A companion documentation panel allows users to inspect details of selected types, including fields, arguments, and directives. Beyond the visualization, Voyager includes several reusable utilities that demonstrate thoughtful engineering: an LRU cache implemented in localStorage for efficient SVG rendering caching, a React hook for managing promise states (loading, error, success), and a flexible object matching utility. The project maintains a robust development workflow with TypeScript, Webpack, Playwright end-to-end testing (via Docker), and automated dependency updates via Dependabot. Recent commits indicate active maintenance, and the codebase adheres to modern React and TypeScript practices.
A production-grade GraphQL server library for Go that implements the September 2025 GraphQL specification. The library parses GraphQL Schema Definition Language (SDL), validates queries against the schema, and executes them using Go struct methods or field resolvers bound via reflection. It supports queries, mutations, subscriptions, Apollo Federation, introspection, and pluggable tracing (OpenTelemetry, OpenTracing). The codebase is well-tested with a novel validation parity harness that exports test cases from `graphql-js` to drive Go validation tests. It provides extensive configuration options including max query depth, parallel resolver limits, memory pool control, and deprecated usage validation. The library is not a standalone application but is designed as an importable package with example servers (Star Wars, social, caching, federation) demonstrating usage. Architecture follows a layered pattern: public API (`graphql.go`), schema parsing (`internal/schema`), query parsing (`internal/query`), validation (`internal/validation`), and execution (`internal/exec`). The resolver binding engine uses Go reflection to automatically map GraphQL fields to Go struct methods, enabling type-safe resolver definitions.
Microcks is a cloud-native API mocking and testing platform that ingests API specifications (OpenAPI, AsyncAPI, gRPC, GraphQL, Postman, SoapUI, HAR, and protobuf) and dynamically generates live mock endpoints and contract conformance tests. It supports REST, SOAP, GraphQL, gRPC, and asynchronous protocols (Kafka, RabbitMQ, MQTT, NATS, WebSocket, Amazon SQS/SNS, Google PubSub). The architecture consists of a main Spring Boot web application with an Angular frontend, a separate Quarkus-based async minion for event-driven mocking and testing, and optional dependencies on MongoDB, Keycloak, Kafka, and external message brokers. The system provides a rich set of features: dynamic response dispatching based on request parameters, scriptable mocks (Groovy/JavaScript), a template engine for dynamic content, SLA management, webhook notifications, AI-assisted sample generation via OpenAI, and OpenTelemetry-based observability. It is a well-engineered, modular project with extensive test coverage and a clean separation of concerns.
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.
Hey is a decentralized social media application built on the Lens Protocol. It provides a full-featured frontend for users to interact with the Lens blockchain, including wallet authentication, post creation and engagement (likes, comments, reposts, collects, tips), group management, notifications, and profile customization. The application uses React 19 with Vite for bundling, TypeScript for type safety, and Tailwind CSS for styling. State management combines Apollo Client for GraphQL data persistence with Zustand stores for client-side state (account, notifications, preferences). Key architectural patterns include optimistic UI updates for blockchain transactions, portal-based modals, and custom hooks for transaction handling and media uploads. The codebase demonstrates strong modularity with reusable UI components and clear separation between UI, state management, and data layers.
Authorizer is a self-hosted, production-grade authentication and authorization server written in Go. It implements OAuth 2.0 / OIDC, SAML IdP/SP, SCIM 2.0, WebAuthn/passkeys, TOTP, email/SMS OTP, and fine-grained authorization via an embedded OpenFGA engine. The architecture is transport-agnostic: a shared service layer (internal/service) is called by GraphQL resolvers, gRPC handlers, and HTTP handlers (Gin). It supports multiple storage backends (SQL, MongoDB, Cassandra, DynamoDB, Couchbase, ArangoDB) via a unified storage.Provider interface, plus Redis and in-memory stores for sessions and caching. The system includes a React admin dashboard, an end-user login SPA, and an MCP (Model Context Protocol) server for AI tool exposure. Security is a primary focus, with extensive regression tests for CVEs, SSRF protection, constant-time comparisons, and audit logging.
This repository is the frontend client suite for daily.dev, a developer-focused content and community platform. It is structured as a monorepo using pnpm workspaces, containing three primary packages: `packages/webapp` (Next.js application), `packages/extension` (browser extension), and `packages/shared` (shared UI components, hooks, and GraphQL logic). The system aggregates developer content, manages user profiles and communities (Squads), handles monetization (Plus subscriptions, Cores), and provides career opportunities. Key entry points include the Next.js pages router in `packages/webapp/pages` and the extension background/content scripts in `packages/extension/src`. Data flows primarily through GraphQL queries to an external `daily-api` service, with client-side state managed via TanStack Query and Jotai. External dependencies include Paddle for payments, GrowthBook for feature flags, and Cloudinary for media. The architecture emphasizes code sharing and consistency across platforms, with `packages/shared` serving as the core library for UI primitives, business logic, and API abstractions. The webapp utilizes Next.js for server-side rendering and static generation, while the extension leverages web extension APIs for browser integration. The codebase demonstrates strong engineering practices with strict TypeScript typing, comprehensive testing (Jest, Playwright), and a robust design system. However, the heavy reliance on feature flags and the use of a non-LTS Node version (v24.18) introduce some technical debt and potential compatibility risks. The platform supports multiple user journeys including content consumption, community engagement, and monetization. It features a sophisticated feed system with infinite scrolling, personalized recommendations, and content preferences. The extension provides companion features like new tab pages and frame embedding, requiring careful synchronization with the web app's authentication and permission models. The codebase is well-structured but complex, with deep nesting of contexts and modals that could impact maintainability if not carefully managed.
Apollo Router is a production-grade GraphQL gateway written in Rust. It accepts incoming GraphQL HTTP requests, composes a supergraph schema from subgraph schemas, plans queries across subgraphs, and executes them through a tower-style service pipeline. It supports federation, subscriptions, persisted queries, demand control, entity caching, progressive overrides, connectors, and defer. Configuration is YAML-based and can be managed via Apollo GraphOS Uplink for schema/config propagation.
Twenty is a production-grade, open-source CRM delivered as a large Nx monorepo. The system is a full-stack TypeScript application: a NestJS backend (twenty-server) exposing GraphQL/REST APIs, a React frontend (twenty-front) with Jotai-based state management, a shared UI component library (twenty-ui), and shared TypeScript packages (twenty-shared). It provides multi-tenant workspaces, object-record CRUD with custom data models, role-based permissions, AI chat/agent capabilities (model tiers, tool calls, streaming), analytics via ClickHouse, and a CLI scaffolding tool (create-twenty-app) for bootstrapping custom apps. The architecture is modular with NestJS ConfigurableModuleBuilder patterns, event-driven design using Zod-validated schemas, and component-scoped state via atom families and component instance contexts.
drawio-skill is a comprehensive toolkit for generating, manipulating, validating, and publishing draw.io architecture diagrams from natural language, codebases, infrastructure-as-code, API specifications, and other structured sources. It provides a unified CLI (`diagramctl.py`) and an optional MCP server (`diagramctl_mcp.py`) that expose workflows for building, syncing, viewing, testing, reviewing, querying, what-if analysis, story generation, and publishing diagrams. The system uses a formal Diagram Intermediate Representation (IR) to separate semantic meaning from geometry, enabling incremental reconciliation, multi-view projection, architecture contract enforcement, and accessible HTML story output. It includes 15+ importers for languages (Python, JS, Go, Rust), IaC (Terraform, Kubernetes, Docker Compose), schemas (SQL, OpenAPI, AsyncAPI, Protobuf, GraphQL), and live infrastructure (Docker, Terraform state). The project is packaged as an AI agent skill compatible with Claude Code, Cursor, Copilot, and other Agent Skills hosts, and ships with GitHub Actions for CI integration. While primarily an application, it also bundles curated icon indices and style presets that could be considered data assets.
This repository is a CLI tool (`api-platform`) that scaffolds new API Platform projects. It generates Symfony or Laravel project skeletons with optional Docker infrastructure, Next.js PWA, React-admin SPA, and AI agent instruction files. The tool configures API formats (JSON-LD, JSON:API, HAL) and documentation viewers (Swagger UI, ReDoc, Scalar). It fetches Docker files from a pinned commit of `dunglas/symfony-docker` and patches compose.yaml for CORS headers. The codebase is well-structured with clean abstractions, idempotent patching patterns, and comprehensive test coverage. It demonstrates professional PHP engineering using Symfony Console components and modern PHP features.
HeyForm is an open-source form builder and management platform designed for small businesses. It provides a full-stack solution with a React-based drag-and-drop form builder, a NestJS GraphQL API backend, a standalone form renderer for public-facing forms, and an embed script for third-party sites. The system supports a wide range of field types (text, choice, rating, payment, signature, etc.), conditional logic with branching, multi-language internationalization, Stripe payments, AI-assisted form generation via OpenAI, and integrations with popular services like Slack, Notion, and Google Sheets. The architecture follows a monorepo pattern with shared packages for answer validation, utility functions, and type definitions, enabling code reuse across the server, webapp, and renderer. The backend is built with NestJS, MongoDB (Mongoose), Redis (Bull queues), and Apollo GraphQL, with scheduled jobs for cleanup and async task processing. The frontend uses React 19, Tailwind CSS, Zustand for state management, and Apollo Client for GraphQL communication. Security is a strong focus: the codebase includes SSRF protection, upload content validation, rate limiting, atomic verification codes, and extensive input sanitization. The project has a comprehensive test suite covering unit, integration, and end-to-end scenarios, including a permission matrix with over 270 cases. Despite some duplicated logic and large locale files, the overall code quality is high, with well-structured modules and clear separation of concerns.
json-graphql-server is a TypeScript library and CLI that generates a fully functional GraphQL API from a plain JavaScript/JSON data object. At runtime it introspects the supplied data to infer GraphQL object types, filter input types, relationship fields, list queries, and mutations, then serves an executable schema through an Express middleware, a standalone CLI, or a browser-side XHR mock. The primary use case is fast prototyping and testing: developers provide an array of records per entity, and the tool immediately exposes queries like Post(id:), allPosts(page, perPage, sortField, sortOrder, filter), and _allPostsMeta, plus create/update/remove/delete mutations that mutate the in-memory data arrays. It is essentially json-server, but for GraphQL, and is designed to be used as a mock API or development fixture rather than a production data layer.
Opencast is a mature, open-source lecture capture and video management platform designed for educational institutions. It provides a complete pipeline for recording, processing, managing, and distributing academic video content. The system is built as a modular Java application using OSGi (Karaf) for service composition, with a REST API and a GraphQL layer for modern client interactions. Core capabilities include scheduled capture from lecture hall devices, automated workflow-driven processing (transcoding, transcription, captioning, silence detection, video editing), versioned asset storage (with AWS S3 support), multi-channel distribution (YouTube, OAI-PMH, streaming servers), and a rich admin UI for metadata management, access control, and analytics. The architecture follows a microservices-like pattern with separate API, implementation, and remote proxy modules, enabling distributed deployment across worker, admin, and presentation nodes. External dependencies include Elasticsearch/OpenSearch for search indexing, a relational database (MySQL/MariaDB/PostgreSQL), FFmpeg for media inspection and processing, and various cloud services for transcription and publication. The codebase demonstrates strong engineering practices with consistent module structure, extensive test coverage, and a well-documented upgrade path spanning over a decade of development.
This repository is a GraphQL code generation library and build plugin suite. It parses GraphQL schemas (SDL or introspection JSON) and generates Java, Kotlin, and Scala source files for types, enums, interfaces, unions, resolvers, client request/response classes, and response projections. The architecture is a core codegen engine with language-specific adapters (JavaGraphQLCodegen, KotlinGraphQLCodegen, ScalaGraphQLCodegen) that use FreeMarker templates for output. It integrates with Gradle, Maven, and SBT via dedicated plugins. External dependencies include graphql-java for schema parsing, FreeMarker for templating, and Jackson for serialization in generated code. The system supports extensive configuration (naming conventions, annotations, custom type mappings, Relay support) and is designed for schema-first development on both server and client sides.
Gatsby is a React-based static site generator (SSG) that also supports server-side rendering (SSR), deferred static generation (DSG), and client-side rendering. It uses a GraphQL data layer to source and transform content from various backends (CMSs, files, APIs) via a plugin system. The build pipeline compiles React components into static HTML, CSS, and JavaScript, with webpack bundling and Babel transpilation. The architecture is a monorepo containing the core framework (`packages/gatsby`), CLI (`gatsby-cli`), dozens of first-party plugins (source, transformer, utility), adapters for deployment (e.g., Netlify), and extensive testing infrastructure (e2e, integration, benchmarks). Key entry points are the CLI commands (`develop`, `build`, `serve`) and the plugin lifecycle hooks (`sourceNodes`, `createPages`, `onRenderBody`). External dependencies include React, GraphQL, webpack, Babel, Node.js, and various CMS SDKs. The codebase is well-structured with state machines (XState), a Redux store, and a modular plugin architecture, though it contains some deprecated packages and mixed JS/TS patterns.
This repository is the open-source iOS client for Kickstarter, a crowdfunding platform. It is a production-grade application built with Swift, UIKit, and SwiftUI, following an MVVM architecture with heavy use of ReactiveSwift and some Combine. The app supports project discovery, pledging, rewards, comments, video feeds, user settings, and authentication. The codebase is well-structured with a dedicated design system (KDS), GraphQL integration via Apollo, extensive snapshot and unit testing, and feature flag experimentation via Statsig. While the code quality is high with many reusable patterns (ValueCell, ShimmerLoading, PaginatingList), there is moderate technical drift due to the coexistence of two reactive frameworks, legacy color references, and some deprecated button styles.
Twikit is an asynchronous Python library that provides a comprehensive, unofficial client for the Twitter (X) API. It allows users to perform a wide range of Twitter operations—such as posting tweets, searching for tweets and users, managing bookmarks and lists, sending direct messages, uploading media, and streaming real-time events—without requiring an official API key. The library achieves this by reverse-engineering Twitter's internal GraphQL and REST v1.1 endpoints, handling authentication via login flows or guest tokens, and implementing sophisticated anti-bot evasion techniques like client-side transaction ID generation (X-Client-Transaction-Id) and UI metrics obfuscation. The architecture separates concerns into GraphQL (gql) and REST (v11) client modules, with data models for tweets, users, communities, and more. It includes optional CAPTCHA solving and cookie persistence for session reuse. The codebase is well-structured, actively maintained, and demonstrates deep reverse-engineering skill, particularly in the `x_client_transaction` module that mimics Twitter's client-side telemetry.
@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.