Database workbench

The Data sources overlay is a full database workbench: every connection you add for syncing can also be browsed, queried, edited, diagrammed, backed up and restored from the same place. Open it with the Data sources button at the top of the sidebar; close it with Done.

One overlay, four tabs

The overlay splits in two. The left side lists your connections and, under each one, a schema tree of databases and tables. The right side has four tabs that act on whatever the tree has selected: Data (a row grid), Structure, Query and Diagram. The open state persists in the URL as ?data=1, so a reload brings the workbench back. Connections belong to the active workspace and are the same connections the bridge builder uses — the quickstart walks through creating one.

Five engines are supported: PostgreSQL (default port 5432), MySQL/MariaDB (3306), SQLite (a file path instead of a host), MongoDB (27017, with an optional connection URI for Atlas) and Redis (6379, plus a logical database index 0–15). The connection dialog has a Test button that tries the connection before saving, and credentials are encrypted at rest.

Browsing and editing rows

The Data tab reads through POST /api/connections/:id/browse: paginated, sortable, and filterable with any number of conditions. The page size is selectable — 25, 50, 100 (the default), 250 or 500 rows — and the server caps a single page at 1000. Filter operators are eq, neq, lt, lte, gt, gte, contains, startsWith, endsWith, isNull, notNull and in.

Editing goes through a row editor dialog: insert a new row, or update and delete existing ones. Rows are identified by primary key, so editing is only offered when the engine supports row editing and the table actually has a primary key. The export buttons write the rows currently in the grid to CSV or JSON entirely in the browser — no server round-trip, so what you export is exactly the page you are looking at.

The query editor

The Query tab is a multi-tab Monaco editor. Tabs keep their content when you switch views, autocomplete draws on the connection's schema, and Cmd/Ctrl+Enter runs the active tab. What you write depends on the engine:

• PostgreSQL, MySQL/MariaDB, SQLite — plain SQL, with a Format button (sql-formatter) in the toolbar.
• MongoDB — a JSON command document naming the collection. Supported operations: find (with sort and limit; the default limit is 100), aggregate (results capped at 1000 documents) and countDocuments.
• Redis — one command per line; lines starting with # are comments.

{
  "collection": "users",
  "find": { "status": "active" },
  "sort": { "created_at": -1 },
  "limit": 20
}

SQL results are capped at 5000 rows by default. The cap can be raised per connection with the maxQueryRows connection option — see Configuration for the related settings and their current limits.

Structure and the ER diagram

Structure shows the selected table's columns with primary-key and foreign-key badges. Diagram renders the whole schema as an interactive ER diagram: one node per table listing up to its first 20 columns — a key icon marks the primary key, a link icon marks referencing columns — and an edge for every foreign key, labeled with the referencing columns. Only engines that report foreign keys (the three relational ones) get edges; MongoDB and Redis schemas render as unconnected nodes.

Schema operations

The schema tree doubles as the DDL surface. At the connection level you can create and drop databases on PostgreSQL and MySQL/MariaDB — SQLite is a single file, MongoDB creates a database implicitly when you add a collection to it, and Redis databases are fixed numbered slots. Tables (and MongoDB collections, which behave like tables here) are created through a dialog whose column types come from the driver; names must match ^[A-Za-z_][A-Za-z0-9_$]*$ and stay within 128 characters.

Per table, the tree offers: browse it, open it in the query editor (SQL engines), seed the bridge builder from it (see How bridges work), truncate it, or drop it. Destructive actions ask for confirmation first. Redis has no tables or databases to manage, so none of this appears for it.

Backup and restore

On the relational engines, backups fetch 1000 rows per batch to bound memory and restores insert up to 500 rows at a time; MongoDB and Redis stream in their own units. The browser calls POST /api/connections/:id/backup?database=..., which returns { filename, format, content } — the filename is <database>-<timestamp>.json or .sql — and saves the file locally (see the HTTP API page for the response envelope). Individual tables can also be backed up to JSON from their own menu. Restore takes an uploaded .json or .sql file; the format is inferred from the extension.

What each engine supports

Feature availability never branches on engine names. Each driver publishes capability flags through GET /api/drivers — query language, DDL, database management, row editing, backup formats — and the UI shows or hides features by reading those flags. An engine that lacks a capability just does not offer the control.

SSH tunnels

A database on a private network can be reached through an SSH tunnel configured on the connection itself: SSH host, port (default 22) and user, authenticated by password or a PEM private key with an optional passphrase. The tunnel is opened by the API server, and the SSH secrets are encrypted at rest alongside the database password — see Self-hosting & security for the wider posture.

Two rules are enforced at validation time. SQLite connections cannot use a tunnel — a file has no network hop — and the API refuses with "SSH tunnels are not supported for SQLite connections". A tunnel also cannot be combined with a connection string, because the tunnel rewrites the discrete host and port and a full URI would bypass it; use the separate host/port fields instead. That leaves PostgreSQL, MySQL/MariaDB, MongoDB and Redis as the engines that tunnel.