tabularis - Moses Yebei

Abstract

Open-source database client for PostgreSQL, MySQL/MariaDB and SQLite with SQL notebooks, visual EXPLAIN, AI and MCP built in. Hackable with plugins.

The Problem

Database work usually splits across tools: a GUI client for browsing, a separate editor for SQL, another tool for visualizing query plans, and nothing native for handing query context to AI agents. Tabularis tries to collapse that into one desktop app with SQL notebooks, visual EXPLAIN, and a built-in MCP server so AI tools can query your databases directly.

What This Does

Tabularis is a Tauri-based desktop client (Rust backend, React/TypeScript frontend) for PostgreSQL, MySQL/MariaDB, and SQLite. The src/ tree holds the UI and state; src-tauri/ holds the Rust shell; packages/ contains a plugin API and a scaffolding CLI (packages/create-plugin/src/cli.ts) for building drivers and UI extensions. AI features live in src/utils/aiActivity.ts and src/utils/explainPlan.ts (visual EXPLAIN-to-flow rendering).

The repo is a portfolio of five distinct projects: the main app (src/), the Tauri shell (src-tauri/), the plugin tooling (packages/), a demo stack (demo/docker-compose.yml), and CI scripts. Don't look for a single architecture across these—they share conventions but are separate codebases.

How It Is Wired

Execution enters through src/App.tsx, which mounts the React tree. The app is driven by a handful of high-fan-in hooks: useSettings (called from 38 places), useDatabase (36), useAlert (19), and useEditorTheme (12). These are the blast-radius hubs—change their signatures and the whole UI breaks. The module graph confirms this: src/types/editor.ts and src/types/notebook.ts are each imported by ~40 modules and are part of a circular import cycle with src/utils/explainPlan.ts. That cycle means any edit to those types forces a full recompile and risks subtle runtime order bugs.

The heaviest UI files are src/pages/Editor.tsx (1422 lines, nesting depth 11) and src/components/ui/DataGrid.tsx (oversized). ExplorerSidebar.tsx imports 48 modules—it's the wiring hub for the left panel. The call graph shows runQuery is called from 10 places and quoteTableRef from 13, so query execution and identifier quoting are core utilities.

One function reads/writes a database (the driver layer), and one calls a model for inference (the AI feature). The wiring from UI to database is short: a hook like useDatabase feeds a query into runQuery, which goes through the driver. The MCP server path hasn't been mapped in the analysis.

How To Use It

git clone https://github.com/moses-y/tabularis
cd tabularis
npm install        # or pnpm install, per package.json
npm run tauri dev  # launches the desktop app

For the demo stack: docker compose -f demo/docker-compose.yml up. The plugin CLI is packages/create-plugin/src/cli.ts—run it with node packages/create-plugin/src/cli.ts. No environment variables are documented in the repo for the core app; database credentials are entered through the connection modal.

Real-World Use

A data team runs Tabularis against a shared Postgres instance. An analyst writes a notebook with EXPLAIN on a slow query, sees the visual plan from src/utils/explainPlan.ts, and flags a bad join. A second analyst points an MCP-enabled AI assistant at the same database via the built-in MCP server; the assistant runs splitQueries (in src/utils/sqlSplitter/index.ts) to execute multi-statement SQL safely.

Code Health & Issues

Static analysis (not opinion) found 155 issues: 52 high, 101 medium, 2 low. Key findings:

High - Import cycle in src/types/editor.ts, src/types/notebook.ts, src/utils/explainPlan.ts - mutually reachable modules, break the cycle.
High - Hub modules: editor.ts and notebook.ts have ~40 dependents each; churn here is expensive.
High - Oversized files: DataGrid.tsx, NewConnectionModal.tsx, Editor.tsx (1422 lines).
High - Deep nesting (max depth 11) in Editor.tsx, ExplorerSidebar.tsx, SidebarRoutineItem.tsx.
Medium - High branching density in identifiers.ts, driverCapabilities.ts, driverUI.tsx.

Security audit found one high: GitHub Actions pinned to tags not commit SHAs (e.g., dtolnay/rust-toolchain@stable), which risks supply-chain compromise. Also: no least-privilege GITHUB_TOKEN permissions, no Dependabot, no dependency scan in CI, and persist-credentials not disabled. A test_ca.pem file in src-tauri/tests/ is flagged as secret-shaped—verify it's a test fixture. Tests exist (163 files), CI runs, and a license is present.

The Bottom Line

Solid scope for a database client: notebooks, visual EXPLAIN, MCP, and a genuinely extensible plugin system. The code works but is heavy in the wrong places—the UI layer needs decomposition before it becomes unmaintainable. Worth using if you want a free, cross-platform client with AI integration and don't mind the rough edges.

What the analyser found

Deployment readiness

6/7

Container image
CI pipeline
Lockfile committed
Test suite
README
License
No committed secrets

Composition

866 files

TypeScript280
TSX222
Rust130
Markdown55
JSON38
YAML17

ReactExpressDockerTransformers

Architecture

Top-level areas of the codebase, sized by module count. Arrows show how many imports cross from one area into another.

graph TD g0["src 352 modules"] g1["tests 130 modules"] g2["packages 18 modules"] g3["(root) 4 modules"] g4["scripts 4 modules"] g1 -->|208| g0

Module dependencies

The 10 most depended-upon modules of 509, from static import analysis. Red outline marks a module in an import cycle.

graph LR n0_src_types_editor["editor"] n1_src_types_notebook["notebook"] n2_src_hooks_useDatabase["useDatabase"] n3_src_hooks_useSettings["useSettings"] n4_src_contexts_DatabaseContext["DatabaseContext"] n5_src_components_ui_Modal["Modal"] n6_src_types_plugins["plugins"] n7_src_types_theme["theme"] n8_src_contexts_SettingsContext["SettingsContext"] n9_src_hooks_useAlert["useAlert"] n4_src_contexts_DatabaseContext --> n6_src_types_plugins n2_src_hooks_useDatabase --> n4_src_contexts_DatabaseContext n3_src_hooks_useSettings --> n8_src_contexts_SettingsContext n0_src_types_editor --> n1_src_types_notebook n1_src_types_notebook --> n0_src_types_editor classDef cyc stroke:#ef4444,stroke-width:2px; class n0_src_types_editor,n1_src_types_notebook cyc;

Findings

LowSecret-shaped paths present; the code-health audit confirms or clears them src-tauri/tests/test_ca.pem

What would stop me shipping this

Ranked by severity × confidence × production reach. Reach is the honest discriminator across a collection that is mostly other people's code: the same finding matters more in something that ships.

high1

medium4

low2

Pin third-party GitHub Actions to a commit SHAhigh7 occurrences

.github/workflows

KSXGitHub/github-actions-deploy-aur@v4.1.2, pnpm/action-setup@v5, dtolnay/rust-toolchain@stable, swatinem/rust-cache@v2.9.1

A tag can be moved, so the action running with your token and secrets is whatever its owner last pushed; this is how tj-actions/changed-files leaked secrets from thousands of repos.

Fix: Replace each @vN with the 40-character commit SHA, keep # vN as a comment, and let Dependabot bump the SHAs.

Declare least-privilege permissions for GITHUB_TOKENmedium3 occurrences

.github/workflows/aur.yml

3 workflow(s) declare no permissions, 2 of them reference secrets

With no declaration the token inherits the repository default, so any injected step can push commits or mint releases from inside your own CI.

Fix: Add permissions: contents: read at the top of the workflow and widen per job only where needed.

Enable Dependabot or Renovatemedium

4 manifest(s), no update bot configured

Without a bot a published advisory sits unpatched until someone audits by hand, which across 1,322 repositories means never.

Fix: Commit .github/dependabot.yml covering the repo ecosystems plus github-actions.

Gate pull requests on a dependency vulnerability scanmedium

.github/workflows

no dependency scan in CI

This is the one gate that would catch a known-vulnerable package before it reaches a build, and no repository in the sample had it.

Fix: Add dependency-review-action on pull_request, or osv-scanner on push and a schedule.

Set persist-credentials: false on checkoutmedium

.github/workflows/ci.yml

checkout keeps the token, then dependencies are installed

The token stays in .git/config for every later step, so a malicious postinstall script reads a pushable credential without one ever being passed to it.

Fix: Add with: persist-credentials: false, and pass an explicit token only to the step that pushes.

Set timeout-minutes on the workflow jobslow4 occurrences

.github/workflows/aur.yml

4 workflow(s) declare no job timeout

A wedged step runs to the six-hour platform default, which on a two-hourly schedule means three runs overlap behind it.

Fix: Add timeout-minutes with a realistic bound to each job.

Add the repository convention files this project lackslow3 occurrences

missing .editorconfig, .gitattributes, a formatter config

Without them one contributor's editor writes tabs into a Python file, a shell script commits with CRLF and fails in the container, and a notebook diff is unreviewable.

Fix: Add .editorconfig, .gitattributes with text=auto eol=lf, and a formatter config.

Checked deterministically against the repository tree and a bounded set of its files: committed credentials, unpinned actions and base images, missing lockfiles and update bots, workflows that discard failures, published advisories against the declared dependencies, runtime configuration, licensing and notebook reproducibility. No language model is involved in this section.