dirsql 0.4.111__tar.gz → 0.4.112__tar.gz

{dirsql-0.4.111 → dirsql-0.4.112}/Cargo.lock

@@ -573,7 +573,7 @@ dependencies = [
 
 [[package]]
 name = "dirsql"
-version = "0.4.111"
+version = "0.4.112"
 dependencies = [
  "assert_cmd",
  "axum",
@@ -625,7 +625,7 @@ dependencies = [
 
 [[package]]
 name = "dirsql-py-ext"
-version = "0.4.111"
+version = "0.4.112"
 dependencies = [
  "dirsql",
  "pyo3",

{dirsql-0.4.111 → dirsql-0.4.112}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dirsql
-Version: 0.4.111
+Version: 0.4.112
 Requires-Dist: bin-shim>=0.1
 Summary: Ephemeral SQL index over a local directory
 Keywords: sql,filesystem,directory,sqlite,index

{dirsql-0.4.111 → dirsql-0.4.112}/docs/reference/cli.md

@@ -240,18 +240,46 @@ requests, closes open `/events` streams, and exits.
 Pass `--frontend` to serve the bundled dirsql SQL explorer shell at `/` on
 the same origin as the HTTP API. It works offline and prints `Frontend at
 http://<host>:<actual-port>/` without opening a browser. With `--port 0`, the
-printed URL uses the assigned port. The initial shell shows server status;
-query controls are coming in a subsequent update.
+printed URL uses the assigned port. The page offers an editable SQL box
+holding the starter query `SELECT * FROM './' LIMIT 100`. Nothing runs until
+you press **Run** (or Ctrl/Cmd+Enter); pressing it again refreshes the
+result. Queries go through `POST /query`, so the read-only rule applies, and
+run exactly as written. The page shows elapsed time, the number of rows
+returned, and errors. Values render as text (`NULL` is marked), and only the
+first 1000 rows are displayed. An empty result says so and shows no column
+names, since the response carries none.
 
 ```bash
 dirsql server --frontend
 dirsql server --frontend -c .dirsql.toml
 ```
 
-The shell reads `GET /frontend/state`: `{"error":null}` when the index is
-ready, or HTTP `503` with `{"error":"<diagnostic>"}` when config loading
-fails. Fix the config and restart the server. Without `--frontend`, the `/`
-and `/frontend/state` routes return `404`.
+The shell reads `GET /frontend/state`. When the index is ready it returns
+HTTP `200`:
+
+```json
+{
+  "error": null,
+  "root": "/abs/path/of/the/invocation/directory",
+  "tables": [
+    {"name": "posts", "columns": [{"name": "basename", "type": "TEXT"}]}
+  ]
+}
+```
+
+`root` is the query root, where [path-tables](./path-tables.md) resolve.
+`tables` lists the declared tables, ordered by name, each with its columns in
+declaration order and the declared SQLite type (`""` when untyped). Empty
+tables are listed. A configless server, or a config with only functions or
+extensions, returns `"tables": []`. dirsql's bookkeeping tables, SQLite's own
+tables, virtual tables with their shadow tables, and path-tables are never
+listed. The metadata is read from SQLite's catalog: no file is parsed, no
+directory walked, no table counted.
+
+When config loading fails the endpoint returns HTTP `503` with
+`{"error":"<diagnostic>"}` and no `root` or `tables`. Fix the config and
+restart the server. Without `--frontend`, the `/` and `/frontend/state`
+routes return `404`. `POST /query` is unchanged.
 
 ### Flags
 

{dirsql-0.4.111 → dirsql-0.4.112}/packages/python/Cargo.toml

@@ -4,7 +4,7 @@ name = "dirsql-py-ext"
 # pypi/maturin handler can rewrite it via `write-version` before
 # `maturin build`. `pyproject.toml` declares `dynamic = ["version"]`
 # and maturin reads this field. Mirrors `packages/rust/Cargo.toml`.
-version = "0.4.111"
+version = "0.4.112"
 # abi3 note: the `abi3-py310` pyo3 feature (below) builds ONE stable-ABI
 # `cp310-abi3` wheel per platform that loads on every CPython >= 3.10
 # (matching `pyproject.toml`'s `requires-python = ">=3.10"`), instead of

{dirsql-0.4.111/packages/rust → dirsql-0.4.112/packages/python}/docs/reference/cli.md

@@ -240,18 +240,46 @@ requests, closes open `/events` streams, and exits.
 Pass `--frontend` to serve the bundled dirsql SQL explorer shell at `/` on
 the same origin as the HTTP API. It works offline and prints `Frontend at
 http://<host>:<actual-port>/` without opening a browser. With `--port 0`, the
-printed URL uses the assigned port. The initial shell shows server status;
-query controls are coming in a subsequent update.
+printed URL uses the assigned port. The page offers an editable SQL box
+holding the starter query `SELECT * FROM './' LIMIT 100`. Nothing runs until
+you press **Run** (or Ctrl/Cmd+Enter); pressing it again refreshes the
+result. Queries go through `POST /query`, so the read-only rule applies, and
+run exactly as written. The page shows elapsed time, the number of rows
+returned, and errors. Values render as text (`NULL` is marked), and only the
+first 1000 rows are displayed. An empty result says so and shows no column
+names, since the response carries none.
 
 ```bash
 dirsql server --frontend
 dirsql server --frontend -c .dirsql.toml
 ```
 
-The shell reads `GET /frontend/state`: `{"error":null}` when the index is
-ready, or HTTP `503` with `{"error":"<diagnostic>"}` when config loading
-fails. Fix the config and restart the server. Without `--frontend`, the `/`
-and `/frontend/state` routes return `404`.
+The shell reads `GET /frontend/state`. When the index is ready it returns
+HTTP `200`:
+
+```json
+{
+  "error": null,
+  "root": "/abs/path/of/the/invocation/directory",
+  "tables": [
+    {"name": "posts", "columns": [{"name": "basename", "type": "TEXT"}]}
+  ]
+}
+```
+
+`root` is the query root, where [path-tables](./path-tables.md) resolve.
+`tables` lists the declared tables, ordered by name, each with its columns in
+declaration order and the declared SQLite type (`""` when untyped). Empty
+tables are listed. A configless server, or a config with only functions or
+extensions, returns `"tables": []`. dirsql's bookkeeping tables, SQLite's own
+tables, virtual tables with their shadow tables, and path-tables are never
+listed. The metadata is read from SQLite's catalog: no file is parsed, no
+directory walked, no table counted.
+
+When config loading fails the endpoint returns HTTP `503` with
+`{"error":"<diagnostic>"}` and no `root` or `tables`. Fix the config and
+restart the server. Without `--frontend`, the `/` and `/frontend/state`
+routes return `404`. `POST /query` is unchanged.
 
 ### Flags
 

dirsql-0.4.112/packages/python/e2e-attestations/bot-1487-frontend-query-1011.json

@@ -0,0 +1,7 @@
+{
+  "command": "uv run python -m pytest tests/e2e/cli_version_test.py tests/e2e/query_contract_test.py tests/e2e/fanout_test.py tests/e2e/extension_package_test.py tests/e2e/server_speed_test.py -x -q",
+  "ran_at": 1791765336,
+  "exit_code": 0,
+  "commit": "a2b5671787b3cfa038a128d5cbbeac13e6c268a9",
+  "branch": "bot/1487-frontend-query-1011"
+}

dirsql-0.4.112/packages/python/e2e-attestations/bot-1488-frontend-metadata-1011.json

@@ -0,0 +1,7 @@
+{
+  "command": "uv run python -m pytest tests/e2e/cli_version_test.py tests/e2e/query_contract_test.py tests/e2e/declared_table_name_test.py tests/e2e/on_file_query_test.py -x -q",
+  "ran_at": 1791764712,
+  "exit_code": 0,
+  "commit": "ae61a26f7b9018c3e12aebeea7c6a3cf32ef4d87",
+  "branch": "bot/1488-frontend-metadata-1011"
+}

dirsql-0.4.112/packages/python/e2e-attestations/bot-1504-bench-names-1011.json

@@ -0,0 +1,7 @@
+{
+  "command": "uv run python -m tests.e2e.bench_suite --pairs 3 --out /tmp/bench-1504 -k \"glob_speed_symlink or glob_speed_dotfiles or glob_speed_recursive\"",
+  "ran_at": 1791770495,
+  "exit_code": 0,
+  "commit": "cce3e83ece8026cc8feedbb1cd64f73242f1d230",
+  "branch": "bot/1504-bench-names-1011"
+}

dirsql-0.4.112/packages/python/e2e-attestations/bot-speed-gap-childpath-1011.json

@@ -0,0 +1,7 @@
+{
+  "command": "uv run python -m pytest tests/e2e/glob_speed_depth_bound_test.py tests/e2e/glob_speed_one_level_test.py tests/e2e/glob_speed_recursive_test.py tests/e2e/glob_speed_symlink_test.py tests/e2e/glob_speed_matchers_test.py tests/e2e/glob_speed_dotfiles_test.py tests/e2e/glob_speed_gitignore_test.py -x -q",
+  "ran_at": 1791777891,
+  "exit_code": 0,
+  "commit": "fb7068d3883fd35c014146a174f4f342aaf93dab",
+  "branch": "bot/speed-gap-childpath-1011"
+}

dirsql-0.4.112/packages/python/e2e-attestations/bot-speed-parse-overlap-1011.json

@@ -0,0 +1,7 @@
+{
+  "command": "uv run python -m pytest tests/e2e/jsonl_parse_speed_test.py tests/e2e/frontmatter_parse_speed_test.py tests/e2e/on_file_query_test.py tests/e2e/query_contract_test.py -x -q",
+  "ran_at": 1791768023,
+  "exit_code": 0,
+  "commit": "db8e06627eb807a3932ae3989ef662019a288ce1",
+  "branch": "bot/speed-parse-overlap-1011"
+}

dirsql-0.4.112/packages/python/e2e-attestations/bot-speed-parse-pragmas-1011.json

@@ -0,0 +1,7 @@
+{
+  "command": "uv run python -m pytest tests/e2e/jsonl_parse_speed_test.py tests/e2e/frontmatter_parse_speed_test.py tests/e2e/on_file_query_test.py tests/e2e/query_contract_test.py -x -q",
+  "ran_at": 1791766109,
+  "exit_code": 0,
+  "commit": "a2a42d2c9ac8c5aa5292f4d4d540296cf1e1ee6c",
+  "branch": "bot/speed-parse-pragmas-1011"
+}

dirsql-0.4.112/packages/python/e2e-attestations/bot-speed-walk-components-1011.json

@@ -0,0 +1,7 @@
+{
+  "command": "uv run python -m pytest tests/e2e/glob_speed_depth_bound_test.py tests/e2e/glob_speed_one_level_test.py tests/e2e/glob_speed_recursive_test.py tests/e2e/glob_speed_symlink_test.py tests/e2e/glob_speed_dotfiles_test.py tests/e2e/glob_speed_node_modules_test.py tests/e2e/glob_speed_matchers_test.py tests/e2e/glob_speed_gitignore_test.py tests/e2e/stat_speed_test.py tests/e2e/query_contract_test.py -x -q",
+  "ran_at": 1791771802,
+  "exit_code": 0,
+  "commit": "6a704d60f7963656097b921100e1f3aaefba6bbd",
+  "branch": "bot/speed-walk-components-1011"
+}

dirsql-0.4.112/packages/python/e2e-attestations/bot-speed-walk-rowpath-1011.json

@@ -0,0 +1,7 @@
+{
+  "command": "uv run python -m pytest tests/e2e/glob_speed_depth_bound_test.py tests/e2e/glob_speed_one_level_test.py tests/e2e/glob_speed_recursive_test.py tests/e2e/glob_speed_symlink_test.py tests/e2e/glob_speed_dotfiles_test.py tests/e2e/glob_speed_node_modules_test.py tests/e2e/glob_speed_matchers_test.py tests/e2e/glob_speed_gitignore_test.py tests/e2e/stat_speed_test.py tests/e2e/query_contract_test.py -x -q",
+  "ran_at": 1791768231,
+  "exit_code": 0,
+  "commit": "d6653e1f4d8a1d8b4b723b6f24c0bc805e4aa7e1",
+  "branch": "bot/speed-walk-rowpath-1011"
+}

{dirsql-0.4.111 → dirsql-0.4.112}/packages/rust/Cargo.toml

@@ -6,7 +6,7 @@ description = "Ephemeral SQL index over a local directory"
 # version stays for the binding crates (publish = false). The literal
 # intentionally lags the published version: putitoutthere rewrites it to
 # the planned release version at build time and never commits it back.
-version = "0.4.111"
+version = "0.4.112"
 edition.workspace = true
 # Literal `license` (not `license.workspace = true`) because
 # putitoutthere's preflight check reads `[package].license` directly

{dirsql-0.4.111/packages/python → dirsql-0.4.112/packages/rust}/docs/reference/cli.md

@@ -240,18 +240,46 @@ requests, closes open `/events` streams, and exits.
 Pass `--frontend` to serve the bundled dirsql SQL explorer shell at `/` on
 the same origin as the HTTP API. It works offline and prints `Frontend at
 http://<host>:<actual-port>/` without opening a browser. With `--port 0`, the
-printed URL uses the assigned port. The initial shell shows server status;
-query controls are coming in a subsequent update.
+printed URL uses the assigned port. The page offers an editable SQL box
+holding the starter query `SELECT * FROM './' LIMIT 100`. Nothing runs until
+you press **Run** (or Ctrl/Cmd+Enter); pressing it again refreshes the
+result. Queries go through `POST /query`, so the read-only rule applies, and
+run exactly as written. The page shows elapsed time, the number of rows
+returned, and errors. Values render as text (`NULL` is marked), and only the
+first 1000 rows are displayed. An empty result says so and shows no column
+names, since the response carries none.
 
 ```bash
 dirsql server --frontend
 dirsql server --frontend -c .dirsql.toml
 ```
 
-The shell reads `GET /frontend/state`: `{"error":null}` when the index is
-ready, or HTTP `503` with `{"error":"<diagnostic>"}` when config loading
-fails. Fix the config and restart the server. Without `--frontend`, the `/`
-and `/frontend/state` routes return `404`.
+The shell reads `GET /frontend/state`. When the index is ready it returns
+HTTP `200`:
+
+```json
+{
+  "error": null,
+  "root": "/abs/path/of/the/invocation/directory",
+  "tables": [
+    {"name": "posts", "columns": [{"name": "basename", "type": "TEXT"}]}
+  ]
+}
+```
+
+`root` is the query root, where [path-tables](./path-tables.md) resolve.
+`tables` lists the declared tables, ordered by name, each with its columns in
+declaration order and the declared SQLite type (`""` when untyped). Empty
+tables are listed. A configless server, or a config with only functions or
+extensions, returns `"tables": []`. dirsql's bookkeeping tables, SQLite's own
+tables, virtual tables with their shadow tables, and path-tables are never
+listed. The metadata is read from SQLite's catalog: no file is parsed, no
+directory walked, no table counted.
+
+When config loading fails the endpoint returns HTTP `503` with
+`{"error":"<diagnostic>"}` and no `root` or `tables`. Fix the config and
+restart the server. Without `--frontend`, the `/` and `/frontend/state`
+routes return `404`. `POST /query` is unchanged.
 
 ### Flags
 

{dirsql-0.4.111 → dirsql-0.4.112}/packages/rust/src/cli/frontend.html

@@ -16,6 +16,18 @@
     .panel { margin-top: 2.5rem; padding: 1.5rem; border: 1px solid #d9e1da; border-radius: 12px; background: #fff; box-shadow: 0 3px 12px #17302609; }
     .panel h2 { margin: 0 0 .5rem; font-size: 1rem; }
     .panel p { margin: 0; }
+    form { margin-top: 2rem; }
+    label { display: block; font-weight: 600; margin-bottom: .4rem; }
+    textarea { width: 100%; min-height: 7rem; padding: .7rem; border: 1px solid #b9c7bd; border-radius: 8px; font: .95rem/1.5 ui-monospace, monospace; resize: vertical; }
+    button { margin-top: .6rem; padding: .5rem 1.2rem; border: 0; border-radius: 8px; background: #1f6b46; color: #fff; font: inherit; font-weight: 600; cursor: pointer; }
+    button[aria-busy="true"] { opacity: .6; cursor: progress; }
+    .hint { font-size: .85rem; margin: .4rem 0 0; }
+    #result { margin-top: 1.5rem; overflow-x: auto; }
+    #result p.error { color: #a0362a; white-space: pre-wrap; overflow-wrap: anywhere; }
+    table { border-collapse: collapse; font: .85rem/1.4 ui-monospace, monospace; background: #fff; }
+    th, td { border: 1px solid #d9e1da; padding: .3rem .6rem; text-align: left; vertical-align: top; white-space: pre-wrap; overflow-wrap: anywhere; max-width: 40rem; }
+    th { background: #eef2ee; }
+    td.null { color: #7a8a80; font-style: italic; }
     .error { border-color: #d7a7a1; background: #fff8f7; }
     .error h2 { color: #a0362a; }
     .error pre { white-space: pre-wrap; overflow-wrap: anywhere; font: .9rem/1.5 ui-monospace, monospace; margin: .8rem 0; }
@@ -30,7 +42,15 @@
       <h2 id="state-title">Connecting to dirsql…</h2>
       <p id="state-message">Checking the server state.</p>
     </section>
+    <form id="query" onsubmit="return false">
+      <label for="sql">SQL (read-only)</label>
+      <textarea id="sql" name="sql" spellcheck="false" aria-describedby="sql-hint">SELECT * FROM './' LIMIT 100</textarea>
+      <button type="button" id="run">Run</button>
+      <p class="hint" id="sql-hint">Runs exactly as written; edit the LIMIT as needed. Press Ctrl+Enter or Cmd+Enter to run.</p>
+    </form>
+    <section id="result" aria-live="polite" aria-label="Query result"></section>
   </main>
+  <script type="module" src="/frontend.js"></script>
   <script>
     (async () => {
       const panel = document.getElementById('state');

dirsql-0.4.112/packages/rust/src/cli/frontend.js

@@ -0,0 +1,161 @@
+export const STARTER_QUERY = "SELECT * FROM './' LIMIT 100";
+export const DISPLAY_ROW_LIMIT = 1000;
+
+export function formatCell(value) {
+  if (value === null || value === undefined) return { text: 'NULL', isNull: true };
+  if (typeof value === 'object') return { text: JSON.stringify(value), isNull: false };
+  return { text: String(value), isNull: false };
+}
+
+async function failureOf(response) {
+  let message = `HTTP ${response.status}`;
+  try {
+    const body = await response.json();
+    if (body && typeof body.error === 'string') message = body.error;
+  } catch {}
+  return { kind: response.status === 400 ? 'query' : 'server', httpStatus: response.status, message };
+}
+
+export function createQueryRunner({ fetch, now, onChange }) {
+  let current = { status: 'idle' };
+  let seq = 0;
+  let inflight = null;
+
+  const set = (state) => {
+    current = state;
+    onChange(state);
+  };
+
+  async function execute(sql, id, controller) {
+    const started = now();
+    const elapsed = () => Math.round(now() - started);
+    let outcome;
+    try {
+      const response = await fetch('/query', { method: 'POST', body: JSON.stringify({ sql }), signal: controller.signal });
+      if (response.ok) {
+        const rows = await response.json();
+        if (!Array.isArray(rows)) throw new Error('unexpected response');
+        const shown = rows.slice(0, DISPLAY_ROW_LIMIT);
+        outcome = {
+          status: 'success',
+          sql,
+          rows: shown,
+          columns: shown.length ? Object.keys(shown[0]) : [],
+          rowCount: rows.length,
+          shownCount: shown.length,
+          truncated: rows.length > shown.length,
+        };
+      } else {
+        outcome = { status: 'error', sql, ...(await failureOf(response)) };
+      }
+    } catch (error) {
+      outcome =
+        error instanceof TypeError || error.name === 'AbortError'
+          ? { status: 'error', sql, kind: 'network', message: error.message }
+          : { status: 'error', sql, kind: 'server', message: error.message };
+    }
+    if (id !== seq) return;
+    inflight = null;
+    set({ ...outcome, elapsedMs: elapsed() });
+  }
+
+  return {
+    state: () => current,
+    run(sql) {
+      if (inflight && inflight.sql === sql) return Promise.resolve();
+      if (inflight) inflight.controller.abort();
+      seq += 1;
+      const controller = new AbortController();
+      inflight = { sql, controller, done: null };
+      set({ status: 'running', sql });
+      inflight.done = execute(sql, seq, controller);
+      return inflight.done;
+    },
+  };
+}
+
+const plural = (n, word) => `${n} ${word}${n === 1 ? '' : 's'}`;
+
+function summaryOf(state) {
+  const returned = `${plural(state.rowCount, 'row')} returned in ${state.elapsedMs} ms`;
+  if (state.truncated) return `${returned}. Display limit: first ${state.shownCount} shown.`;
+  if (state.rowCount === 0) return `${returned}. Column names are not available for an empty result.`;
+  return `${returned}.`;
+}
+
+function tableOf(doc, state) {
+  const table = doc.createElement('table');
+  const head = doc.createElement('tr');
+  for (const column of state.columns) {
+    const th = doc.createElement('th');
+    th.setAttribute('scope', 'col');
+    th.textContent = column;
+    head.append(th);
+  }
+  table.append(head);
+  for (const row of state.rows) {
+    const tr = doc.createElement('tr');
+    for (const column of state.columns) {
+      const { text, isNull } = formatCell(row[column]);
+      const td = doc.createElement('td');
+      td.textContent = text;
+      if (isNull) td.className = 'null';
+      tr.append(td);
+    }
+    table.append(tr);
+  }
+  return table;
+}
+
+const ERROR_LABEL = { query: 'Query error', server: 'Server error', network: 'Could not reach the server' };
+
+function errorText(state) {
+  if (state.kind === 'network') return `${ERROR_LABEL.network}: ${state.message}`;
+  const status = state.httpStatus ? ` (HTTP ${state.httpStatus})` : '';
+  return `${ERROR_LABEL[state.kind]}${status}: ${state.message}`;
+}
+
+export function renderResult(doc, container, state) {
+  const note = doc.createElement('p');
+  if (state.status === 'running') {
+    note.textContent = 'Running…';
+    container.replaceChildren(note);
+    return;
+  }
+  if (state.status === 'error') {
+    note.className = 'error';
+    note.setAttribute('role', 'alert');
+    note.textContent = errorText(state);
+    container.replaceChildren(note);
+    return;
+  }
+  if (state.status !== 'success') {
+    container.replaceChildren();
+    return;
+  }
+  note.textContent = summaryOf(state);
+  container.replaceChildren(...(state.rowCount ? [note, tableOf(doc, state)] : [note]));
+}
+
+if (typeof document !== 'undefined') {
+  const sql = document.getElementById('sql');
+  const run = document.getElementById('run');
+  const result = document.getElementById('result');
+  sql.value = STARTER_QUERY;
+  const runner = createQueryRunner({
+    fetch: (url, init) => fetch(url, init),
+    now: () => performance.now(),
+    onChange(state) {
+      run.setAttribute('aria-busy', String(state.status === 'running'));
+      renderResult(document, result, state);
+    },
+  });
+  const submit = () => runner.run(sql.value);
+  run.addEventListener('click', submit);
+  sql.addEventListener('keydown', (event) => {
+    if (event.key === 'Enter' && (event.ctrlKey || event.metaKey)) {
+      event.preventDefault();
+      submit();
+    }
+  });
+}

{dirsql-0.4.111 → dirsql-0.4.112}/packages/rust/src/cli/router.rs

@@ -22,6 +22,7 @@ use tokio_stream::wrappers::BroadcastStream;
 
 use super::AppState;
 use super::execute::{QueryFailure, execute_query, require_ready};
+use crate::TableInfo;
 
 pub(super) struct AppContext {
     pub state: AppState,
@@ -46,14 +47,31 @@ pub(super) fn router(ctx: SharedCtx, frontend: bool) -> Router {
     if frontend {
         app = app
             .route("/", get(|| async { Html(include_str!("frontend.html")) }))
+            .route("/frontend.js", get(handle_frontend_script))
             .route("/frontend/state", get(handle_frontend_state));
     }
     app.with_state(ctx)
 }
 
+async fn handle_frontend_script() -> Response {
+    (
+        [(header::CONTENT_TYPE, "text/javascript; charset=utf-8")],
+        include_str!("frontend.js"),
+    )
+        .into_response()
+}
+
 async fn handle_frontend_state(State(ctx): State<SharedCtx>) -> Response {
     match &ctx.state {
-        AppState::Ready(_) => Json(json!({ "error": null })).into_response(),
+        AppState::Ready(db) => match db.tables() {
+            Ok(tables) => Json(json!({
+                "error": null,
+                "root": db.root().to_string_lossy(),
+                "tables": tables.iter().map(table_json).collect::<Vec<_>>(),
+            }))
+            .into_response(),
+            Err(err) => error_response(StatusCode::INTERNAL_SERVER_ERROR, err.to_string()),
+        },
         AppState::Unavailable(reason) => (
             StatusCode::SERVICE_UNAVAILABLE,
             Json(json!({ "error": reason })),
@@ -62,6 +80,17 @@ async fn handle_frontend_state(State(ctx): State<SharedCtx>) -> Response {
     }
 }
 
+fn table_json(table: &TableInfo) -> serde_json::Value {
+    json!({
+        "name": table.name,
+        "columns": table
+            .columns
+            .iter()
+            .map(|c| json!({ "name": c.name, "type": c.sql_type }))
+            .collect::<Vec<_>>(),
+    })
+}
+
 async fn handle_query(State(ctx): State<SharedCtx>, body: String) -> Response {
     match execute_query(&ctx.state, body, Some(ctx.query_timeout)).await {
         Ok(value) => Json(value).into_response(),
@@ -215,6 +244,31 @@ mod tests {
         assert_eq!(resp.status(), StatusCode::SERVICE_UNAVAILABLE);
     }
 
+    #[tokio::test]
+    async fn frontend_script_is_served_as_javascript() {
+        let resp = handle_frontend_script().await;
+        assert_eq!(resp.status(), StatusCode::OK);
+        assert_eq!(
+            resp.headers()[header::CONTENT_TYPE],
+            "text/javascript; charset=utf-8"
+        );
+    }
+
+    #[test]
+    fn table_json_names_each_column_with_its_type() {
+        let table = TableInfo {
+            name: "t".into(),
+            columns: vec![crate::ColumnInfo {
+                name: "a".into(),
+                sql_type: "TEXT".into(),
+            }],
+        };
+        assert_eq!(
+            table_json(&table),
+            json!({"name": "t", "columns": [{"name": "a", "type": "TEXT"}]})
+        );
+    }
+
     #[test]
     fn error_response_sets_json_content_type() {
         let resp = error_response(StatusCode::BAD_REQUEST, "boom");