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.
instagram4j is a Java library that provides an object-oriented interface to Instagram's private (undocumented) API. It supports both mobile and web API endpoints, allowing actions such as logging in with username/password or existing session tokens, fetching profiles, posts, stories, direct messages, searching, posting pictures, liking, commenting, following/unfollowing, and more. The library is structured as a multi-module Gradle project with separate 'mobile' and 'web' modules, each mirroring similar functionality but using different API endpoints (REST for mobile, GraphQL for web). It uses OkHttp for HTTP requests and a custom JSON library. The codebase demonstrates good engineering practices with clear separation of concerns, pagination iterators, and robust error handling. However, there is significant code duplication between the two modules, and the library relies on reverse-engineered endpoints that may break with Instagram updates. The last commit date appears to be in the future (2026), suggesting the repository may be stale or the timestamp is erroneous.
Tape is a decentralized video-sharing platform built on Lens Protocol. The monorepo contains multiple frontends: a legacy Next.js app (apps/web), a newer Vite + TanStack Router rewrite (apps/web-vite), an Expo/React Native mobile app, an embeddable video player, and an Open Graph image generator. The backend consists of a Hono API (apps/api) for oEmbed, DID resolution, metadata, and event ingestion, plus a cron service (apps/cron) for cleanup, analytics flushing, and S3 backups. Smart contracts for permissionless signup live in apps/contracts. The platform supports video upload, short-form bytes, comments, mirrors, collects, tips, follows, notifications, search, and profile management, all interacting with Lens Protocol's GraphQL APIs and on-chain contracts. Data flows through several layers: media is uploaded to IPFS/S3/Arweave, metadata is stored on Arweave or IPFS, and social actions are executed via Lens Protocol typed-data signing and broadcasting. The platform also runs an in-house analytics pipeline: browser events are queued through a service worker to Redis, flushed to ClickHouse by cron jobs, and backed up to S3. Postgres (via Prisma) stores platform-level data such as allowed tokens, profile toggles, curated profiles, and platform stats. Redis is used for caching and queueing throughout. Although primarily an application, the repository has a meaningful data/analytics component (ClickHouse schema, event/trail tracking, Redis-backed queues, S3 backup jobs) that could be reused independently. The codebase is actively maintained but carries migration debt: two web frontends, two UI kits (packages/ui and packages/winder), two Lens GraphQL clients (v1 and v2), and commented-out cron services indicate an in-progress transition. No meaningful test suite is present; CI focuses on Biome checks and builds.
This repository provides the `starred` Python CLI tool, which generates and maintains an Awesome-style Markdown list from a GitHub user's starred repositories. The tool queries the GitHub GraphQL API to fetch all starred repos (with pagination), groups them by programming language or repository topic, and outputs a formatted Markdown document. It can optionally sort categories alphabetically, filter by topic popularity, include private repositories, and directly push the generated file to a target GitHub repository using the GitHub REST API. The architecture is a simple single-command CLI with two source modules: `starred/starred.py` (Click CLI entry point and Markdown generation) and `starred/githubgql.py` (a self-contained GraphQL client for fetching starred repos). External dependencies include `click`, `requests`, `github3.py`, `gql`, and `aiohttp`. The code is clean, follows a straightforward functional design, and integrates well with GitHub's APIs. While it lacks unit tests, the CI runs an integration test against the real GitHub API.
BigBlueButton is an open-source web conferencing system designed for online learning. It provides real-time audio/video, screen sharing, whiteboard, chat, polling, breakout rooms, and recording/playback. The architecture is distributed and polyglot: a Scala/Akka backend handles meeting logic and state via Redis pub/sub; a Java API layer exposes REST endpoints for meeting creation and recording management; a React frontend with GraphQL subscriptions enables real-time collaboration; Ruby workers process recordings; and a Go GraphQL middleware optimizes subscription delivery. The system integrates with FreeSWITCH for legacy voice and LiveKit for modern WebRTC audio. A plugin SDK allows third-party extensions via customizable UI areas and data consumption hooks. Despite a large feature set and active development, the codebase suffers from significant technical debt due to its multi-language nature, incomplete migrations (e.g., from Meteor to pure React), duplicated logic across frontend and backend, and outdated library versions. Reusable components include the Redis pub/sub framework, GraphQL subscription deduplication hooks, and an annotation export service.
Automation Gateway is a reactive, configuration-driven bridge for industrial protocols (OPC UA, MQTT, PLC4X) that routes real-time process data to multiple time-series databases (InfluxDB, IoTDB, OpenSearch, Cassandra, PostgreSQL, etc.) and exposes it via GraphQL, MQTT, and OPC UA servers. The system runs as a single JVM or GraalVM native binary, orchestrated through YAML configuration files that define driver instances, logger sinks, and server endpoints. Its core architecture is built on Vert.x event bus for internal pub/sub messaging, with abstract base classes (DriverBase, LoggerBase) enabling consistent extension for new protocols or data stores. The gateway does not persist data itself; it acts as a real-time router with configurable buffering and queue reliability (memory-mapped disk queue). Key entry points include `App.kt` for the main application and `GraphQLServer.kt` for the administrative API, which supports JWT authentication, health checks, and dynamic component management. External dependencies include Eclipse Milo (OPC UA), HiveMQ MQTT client, PLC4X, Apache IoTDB Thrift, InfluxDB HTTP client, and various database drivers. The codebase is mature (v1.38) with active development, but carries some technical drift in the form of deprecated features still present in source code and a large set of reflection configurations for GraalVM native-image that require careful maintenance.
This repository implements a React library for building forms based on GraphQL APIs, specifically designed to work with Apollo Client. The library provides a code generation CLI tool that extracts GraphQL mutation information and converts it to JSON Schema, along with a React component that renders forms and handles submission via GraphQL mutations. The architecture consists of: 1. A CLI tool (`lib/cli.ts`) for generating schema and type definitions from GraphQL endpoints 2. Core form logic in `lib/forms/` including the main `ApolloForm` component, utilities for schema processing, and rendering customization 3. Integration with React-jsonschema-form as the underlying form engine Key features include conditional fields, custom validation, theming support, and automatic JSON Schema generation from GraphQL schemas. The library demonstrates particular strength in its JSON Schema manipulation utilities, which handle complex operations like resolving $ref references and applying conditional logic to schemas.
This repository is primarily a curated knowledge base and personal reference collection (a 'second brain') organized into dozens of markdown files across categories such as coding languages, blockchain, operating systems, trading, and general utilities. Each markdown file contains tables of contents and extensive lists of external links to tools, libraries, tutorials, and best practices. The repository also includes a small set of utility scripts (e.g., remark.js for auto-generating table of contents, wip-dedupe.js for deduplication, shell migration scripts, and code snippets) and an Obsidian vault configuration. While not a traditional application, the automation scripts add a thin layer of tooling around the curated content. The primary value is as a discovery index for developers and researchers, but the code itself is minimal and tightly coupled to personal workflow, limiting reuse.
GraphQL Playground is a full-featured GraphQL IDE (similar to GraphiQL) that provides an interactive development environment for GraphQL APIs. It includes a React-based frontend with query editing, schema exploration, documentation, subscriptions, and history. The repository is a monorepo (Lerna + Yarn workspaces) containing packages for the core React app (`graphql-playground-react`), an Electron desktop app (`graphql-playground-electron`), an HTML embedding page (`graphql-playground-html`), and server middleware for Express, Koa, Hapi, and Lambda. The architecture is a typical React + Redux + Redux-Saga + Immutable.js stack with CodeMirror for editors and Apollo Link for network execution. The project is now archived; future development has moved to GraphiQL. The codebase shows signs of age (outdated dependencies, legacy lifecycle methods, global variable assignments) and has had two documented XSS vulnerabilities. Despite this, some components like the schema fetcher, theming system, and middleware wrappers demonstrate solid engineering patterns.