WhoDB

WhoDB abstracts database connectivity through a plugin-based architecture where each database type (PostgreSQL, MySQL, MongoDB, Redis, etc.) implements a standardized interface. The system uses build tags and runtime flags to conditionally load Community Edition (7 databases) or Enterprise Edition plugins (15+ databases), enabling single-binary deployment without recompilation. Connection pooling, credential management, and session lifecycle are handled uniformly across all database types through the core plugin engine.

WhoDB exposes a unified GraphQL API that translates queries into database-specific SQL/query languages through resolver functions. The schema and type system are dynamically generated from database introspection, allowing clients to query PostgreSQL, MongoDB, and Redis through identical GraphQL syntax. Resolvers handle type coercion, pagination, filtering, and aggregation uniformly, abstracting away database-specific query syntax and capabilities.

WhoDB supports multiple deployment models (web via Docker, CLI, desktop) through environment-based configuration. Configuration is managed through environment variables and config files, enabling different setups for development, staging, and production without code changes. The build system uses conditional compilation (build tags) to create deployment-specific binaries, reducing binary size and attack surface for each deployment model.

WhoDB uses Redux for centralized state management in the React frontend, maintaining application state (selected database, active query, result set, UI preferences) in a single store. Redux enables predictable state updates, time-travel debugging, and state persistence across page reloads. The state is structured to support multiple concurrent queries, undo/redo functionality, and efficient re-rendering through selectors.

WhoDB implements database-specific plugins for SQL databases (PostgreSQL, MySQL, SQLite, MariaDB) and NoSQL databases (MongoDB, Redis, DynamoDB, Elasticsearch). Each plugin implements a standardized interface for connection management, query execution, schema introspection, and data type mapping. Plugins handle database-specific quirks (e.g., MongoDB's aggregation pipeline syntax, Redis's key-value operations) while presenting a unified API to the core engine.

WhoDB implements server-side pagination and result streaming to handle large query result sets without loading entire results into memory. Results are fetched in configurable chunks (e.g., 100 rows at a time), streamed to the client, and rendered incrementally in the data grid. The pagination mechanism supports offset-based and cursor-based pagination, with client-side caching to avoid re-fetching previously viewed pages.

WhoDB integrates an LLM-based chat interface that converts natural language questions into database-specific queries (SQL for relational databases, aggregation pipelines for MongoDB, etc.). The system provides database schema context to the LLM, enabling it to generate syntactically correct queries without manual prompt engineering. Query results are returned to the chat interface for iterative refinement, creating a conversational database exploration experience.

WhoDB renders query results in a React-based data grid component that mimics spreadsheet UX (sortable columns, filterable rows, inline cell editing). The grid uses virtualization to handle large result sets efficiently, loading data in chunks as users scroll. Edits are captured client-side and sent back to the database through GraphQL mutations, with optimistic UI updates and rollback on failure.

WhoDB automatically introspects connected databases to extract schema metadata (tables, columns, indexes, relationships, constraints) and renders an interactive schema browser in the UI. The system builds a dependency graph of tables and foreign keys, enabling visualization of data relationships. Schema metadata is cached and refreshed on-demand, supporting both relational and document-oriented databases with different metadata models.

WhoDB provides a code editor component (likely using Monaco or similar) where users can write and execute raw SQL queries, aggregation pipelines, or database-specific query languages. The editor includes syntax highlighting for multiple languages, query history tracking, and execution result display. Queries are sent to the backend through GraphQL mutations, executed against the connected database, and results are streamed back to the client.

WhoDB includes a standalone CLI tool that provides terminal-based database exploration through a text user interface (TUI). The CLI uses the same backend engine as the web/desktop versions, enabling database browsing, query execution, and schema inspection from the command line. The TUI supports keyboard navigation, table rendering, and query result pagination within terminal constraints.

WhoDB implements the Model Context Protocol (MCP) server specification, allowing AI agents and LLMs to call WhoDB functions as tools. The MCP server exposes database operations (query execution, schema introspection, data modification) as callable functions with defined input/output schemas. Agents can discover available tools, call them with parameters, and receive structured results, enabling autonomous database operations within agentic workflows.

WhoDB is packaged as a native desktop application using the Wails framework, which embeds the Go backend and React frontend into a single executable. The desktop app integrates with the OS (file dialogs, system tray, native menus) and supports platform-specific packaging (DMG for macOS, MSI for Windows, AppImage for Linux). The desktop version shares the same backend engine as the web version, enabling offline database access and local data caching.

WhoDB implements authentication and session management to control access to databases and features. The system supports multiple authentication methods (local credentials, OAuth, LDAP) and maintains user sessions with role-based access control (RBAC). Sessions are tracked server-side, and permissions are enforced at the GraphQL resolver level, preventing unauthorized database access. The authentication layer is abstracted to support both Community and Enterprise authentication schemes.