@cloud-cli/d0 1.6.1 → 1.7.0

package/Dockerfile

@@ -9,6 +9,9 @@ RUN pnpm i && pnpm build && rm -rf node_modules/ src/ && pnpm store prune
 FROM ghcr.io/cloud-cli/node:latest
 
 ENV NODE_ENV=production
+ENV DATA_PATH=/home/app/data
 WORKDIR /home/app
-COPY --from=builder /home/app/ ./
-RUN pnpm install --prod
+COPY --from=builder --chown=node:node /home/app/ ./
+RUN pnpm install --prod --frozen-lockfile && pnpm rebuild better-sqlite3
+RUN mkdir -p /home/app/data && chown node:node /home/app/data
+VOLUME ["/home/app/data"]

package/README.md

@@ -4,6 +4,15 @@ SQLite server over HTTP
 
 ## Usage
 
+**GET /schema**
+
+Inspect the database schema without issuing SQL. The response includes table and view columns, indexes, foreign keys, original `sqlite_schema` objects, and an ordered `statements` array suitable for a basic schema dump or recreation script. SQLite internal objects are excluded by default; request `/schema?internal=1` to include them.
+
+```js
+const schema = await db.schema();
+console.log(schema.tables, schema.statements);
+```
+
 **POST /query**
 
 Run a prepared SQLite statement.
@@ -13,7 +22,7 @@ Accepts a JSON with these properties:
 |-|:-:|-|
 |`s` | string with the statement | **yes** |
 |`d` | data to bind on a statement | no |
-|`m` | method to execute: `all`, `run` or `get`. Run is the default | no |
+|`m` | method to execute: `all`, `run`, `get` or `exec`. Run is the default | no |
 |`p` | pragma statements as an array of strings. They run before the query | no |
 
 ```js
@@ -32,6 +41,15 @@ fetch('https://db.example.com/query', {
 import db from 'https://db.example.com/index.mjs';
 
 const user = await db.query('SELECT * FROM user WHERE id = ?', [123]);
+
+// Execute one or more SQL statements without preparing them
+await db.exec('CREATE TABLE IF NOT EXISTS user (id INTEGER PRIMARY KEY)');
+
+// Run several statements atomically; the server owns the transaction lifecycle
+await db.transaction([
+  { s: 'INSERT INTO user (id) VALUES (?)', d: [123] },
+  { s: 'UPDATE user SET id = ? WHERE id = ?', d: [456, 123] }
+]);
 ```
 
 ## Server address
@@ -45,5 +63,8 @@ Otherwise, it will be available at `http://localhost:PORT/` and serve a single d
 | Variable       | Description                                                  |
 |-|-|
 | PORT           | HTTP port                                                    |
-| DATA_PATH      | Path to a folder where the database files are stored         |
+| DATA_PATH      | Path to a folder where the database files are stored (default: `/home/app/data` in Docker) |
 | BASE_DOMAIN    | Root domain to use in a multi-db server, e.g. `.example.com` |
+| MAX_DATABASES  | Maximum number of database connections kept open (default: `32`) |
+| MAX_BODY_BYTES | Maximum JSON request size (default: `1048576`)                  |
+| SLOW_QUERY_MS  | Log slow queries in `DEBUG` mode (default: `1000`)             |

package/client.mjs

@@ -2,14 +2,15 @@ const baseURL = "https://__API_URL__";
 
 let pragmas = [];
 
-async function query(method, statement, data, pragma = pragmas) {
+async function query(method, statement, data, pragma = pragmas, transaction) {
   const req = await fetch(new URL("/query", baseURL), {
     method: "POST",
     body: JSON.stringify({
       s: statement,
       d: data,
       m: method,
-      p: pragma
+      p: pragma,
+      t: transaction
     }),
   });
 
@@ -20,9 +21,23 @@ async function query(method, statement, data, pragma = pragmas) {
   throw new Error(await req.text());
 }
 
+export async function schema({ internal = false } = {}) {
+  const url = new URL('/schema', baseURL);
+  if (internal) url.searchParams.set('internal', '1');
+
+  const req = await fetch(url);
+  if (req.ok) return req.json();
+  throw new Error(await req.text());
+}
+
+export async function transaction(statements, pragma = pragmas) {
+  return query('transaction', undefined, undefined, pragma, statements);
+}
+
 export const get = query.bind(null, 'get');
 export const run = query.bind(null, 'run');
 export const all = query.bind(null, 'all');
+export const exec = query.bind(null, 'exec');
 
 export function pragma(p) {
   if (Array.isArray(p) && p.every(s => typeof s === 'string')) {
@@ -30,4 +45,4 @@ export function pragma(p) {
   }
 }
 
-export default { query, get, run, all, pragma };
+export default { query, get, run, all, exec, transaction, schema, pragma };

package/console.html

@@ -2,11 +2,11 @@
 <html lang="en">
   <head>
     <meta charset="UTF-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
     <link rel="component" href="https://sodium.static.apphor.de/code-editor.html" />
     <link rel="component" href="https://sodium.static.apphor.de/code-block.html" />
     <link rel="component" href="https://sodium.static.apphor.de/mermaid-graph.html" />
-    <title></title>
+    <title>D0 Console</title>
     <script type="importmap">
       {
         "imports": {
@@ -16,175 +16,266 @@
         }
       }
     </script>
-    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/tailwindcss/2.2.19/tailwind.min.css" />
-  </head>
-  <body class="bg-gray-900 text-white font-sans h-screen flex flex-col overflow-hidden">
-    <app-main class="contents"></app-main>
+    <style>
+      :root {
+        color-scheme: dark;
+        --background: #101316;
+        --panel: #171b20;
+        --panel-raised: #1d232a;
+        --border: #303943;
+        --muted: #8d99a8;
+        --text: #edf2f7;
+        --accent: #8bd5ca;
+        --danger: #ff8f8f;
+      }
+
+      * { box-sizing: border-box; }
+      html, body { height: 100%; margin: 0; }
+      body {
+        background: var(--background);
+        color: var(--text);
+        font: 14px/1.4 ui-monospace, SFMono-Regular, Menlo, monospace;
+      }
+      button, input { font: inherit; }
+      button {
+        border: 1px solid var(--border);
+        border-radius: 6px;
+        background: var(--panel-raised);
+        color: var(--text);
+        cursor: pointer;
+        padding: 7px 11px;
+      }
+      button:hover, button:focus-visible { border-color: var(--accent); color: var(--accent); }
+      .shell { display: grid; grid-template-rows: auto 1fr; height: 100%; min-height: 0; }
+      .topbar {
+        align-items: center;
+        border-bottom: 1px solid var(--border);
+        display: flex;
+        gap: 10px;
+        padding: 10px 14px;
+      }
+      .brand { color: var(--accent); font-weight: 700; letter-spacing: .08em; }
+      .brand-mark { border-radius: 5px; height: 24px; width: 24px; }
+      .db-name { color: var(--muted); overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+      .spacer { flex: 1; }
+      .workspace {
+        display: grid;
+        grid-template-columns: 245px minmax(360px, 1fr) minmax(360px, 1.15fr);
+        min-height: 0;
+      }
+      .panel { min-width: 0; min-height: 0; overflow: hidden; }
+      .schema-panel { border-right: 1px solid var(--border); display: flex; flex-direction: column; }
+      .editor-panel { border-right: 1px solid var(--border); display: grid; grid-template-rows: minmax(190px, 38%) minmax(0, 1fr); }
+      .graph-panel { display: grid; grid-template-rows: auto minmax(0, 1fr); padding: 12px; gap: 10px; }
+      .panel-header { align-items: center; display: flex; gap: 8px; padding: 12px; }
+      .panel-title { color: var(--muted); font-size: 11px; letter-spacing: .1em; text-transform: uppercase; }
+      .schema-count { color: var(--accent); margin-left: auto; }
+      .schema-list { border-top: 1px solid var(--border); flex: 1; overflow: auto; padding: 7px; }
+      .schema-item { background: transparent; border: 0; display: block; padding: 9px; text-align: left; width: 100%; }
+      .schema-item:hover { background: var(--panel-raised); }
+      .schema-kind { color: var(--muted); font-size: 11px; margin-left: 5px; }
+      .schema-columns { color: var(--muted); display: block; font-size: 11px; margin-top: 3px; }
+      .editor, .results { min-height: 0; padding: 12px; }
+      .editor { border-bottom: 1px solid var(--border); display: grid; grid-template-rows: auto minmax(0, 1fr) auto; gap: 8px; }
+      .editor-actions { display: flex; gap: 8px; justify-content: flex-end; }
+      .run { background: var(--accent); border-color: var(--accent); color: #0d1918; font-weight: 700; }
+      .run:hover, .run:focus-visible { color: #0d1918; opacity: .85; }
+      code-editor { display: block; min-height: 0; }
+      .results { overflow: auto; }
+      .result { border-bottom: 1px solid var(--border); display: block; padding: 8px 0; white-space: pre-wrap; }
+      .error { color: var(--danger); padding: 8px 0; white-space: pre-wrap; }
+      .graph-wrap { background: #f8fafc; border-radius: 8px; min-height: 0; overflow: auto; }
+      mermaid-graph { display: block; min-height: 100%; min-width: 100%; }
+      .hint { color: var(--muted); font-size: 12px; padding: 12px; }
 
+      @media (max-width: 1050px) {
+        .workspace { grid-template-columns: 210px minmax(330px, 1fr); }
+        .graph-panel { border-top: 1px solid var(--border); grid-column: 1 / -1; min-height: 420px; }
+        .editor-panel { border-right: 0; }
+      }
+      @media (max-width: 680px) {
+        .workspace { display: block; overflow: auto; }
+        .schema-panel, .editor-panel { border-right: 0; border-bottom: 1px solid var(--border); }
+        .schema-panel { max-height: 220px; }
+        .editor-panel { height: 560px; }
+        .graph-panel { min-height: 420px; }
+        .db-name { display: none; }
+      }
+    </style>
+  </head>
+  <body>
     <script type="module">
       import '@li3/web';
     </script>
+    <app-main class="contents"></app-main>
 
     <template component="app-main">
-      <div class="flex flex-col items-stretch justify-between space-y-2 p-4 h-full">
-        <div class="p-2 overflow-auto font-mono text-xs h-full">
-          <template for="r of responses">
-            <code-block
-              bind-source="r || ''"
-              language="json"
-              class="py-1 border-b block w-full whitespace-pre-wrap overflow-auto"
-              style="max-height: 10rem"
-            ></code-block>
-          </template>
-          <div class="text-red-400 text-sm">{{ error || '' }}</div>
-        </div>
-        <div class="flex-1">
-          <input
-            bind-value="name"
-            placeholder="Name"
-            class="block w-full p-2 rounded-md bg-gray-300 border text-black text-xs font-mono"
-            on-change="setName($event.target.value)"
-          />
-        </div>
-        <div class="flex-1">
-          <form on-submit.prevent="onRun()">
-            <code-editor
-              nolines="1"
-              nostatus="1"
-              language="sql"
-              bind-value="query"
-              on-change="setQuery($event.target.value)"
-              on-keyup="onKeyUp($event)"
-              class="font-mono text-xs border rounded-md w-full block h-32"
-            ></code-editor>
-            <div class="flex items-center justify-end mt-2">
-              <button
-                type="submit"
-                bind-disabled="!name || !query"
-                class="bg-gray-400 text-black px-4 py-2 rounded focus:bg-white hover:bg-white"
-              >
-                Run
-              </button>
-
-              <button
-                type="button"
-                on-click="onUpdateGraph()"
-                bind-disabled="!name"
-                class="bg-gray-400 text-black px-4 py-2 rounded focus:bg-white hover:bg-white"
-              >
-                Graph
-              </button>
-            </div>
-          </form>
-        </div>
-        <mermaid-graph class="flex-1 h-64 overflow-auto" bind-input="diagram"></mermaid-graph>
-      </div>
-
-      <script setup>
-        import { hook, onInit } from '@li3/web';
+    <script setup>
+      import { hook, onInit } from '@li3/web';
 
-        export default function () {
-          const [diagram, setDiagram] = hook(null);
-          const url = new URL(location.href);
-          const [name, setName] = hook(url.hostname.replace('.db.apphor.de', ''));
-          const [query, setQuery] = hook('');
-          const [responses] = hook('');
-          const [error, setError] = hook('');
+      function schemaToMermaid(schema) {
+        const tables = schema.tables.filter((table) => table.type === 'table' && table.sql);
+        const names = new Map(tables.map((table) => [table.name, mermaidName(table.name)]));
+        let diagram = 'erDiagram\n';
 
-          function append(r) {
-            responses.value = [...responses.value, r];
+        for (const table of tables) {
+          const name = names.get(table.name);
+          diagram += `    ${name} {\n`;
+          for (const column of table.columns.filter((column) => !column.hidden)) {
+            const type = mermaidType(column.type);
+            const key = column.pk ? ' PK' : '';
+            diagram += `        ${type} ${mermaidName(column.name)}${key}\n`;
           }
+          diagram += '    }\n';
+        }
 
-          function onKeyUp(event) {
-            if ((event.metaKey || event.ctrlKey) && event.key === 'Enter') {
-              event.preventDefault();
-              onRun();
-            }
+        for (const table of tables) {
+          for (const foreignKey of table.foreignKeys) {
+            const parent = names.get(foreignKey.table);
+            const child = names.get(table.name);
+            if (parent && child) diagram += `    ${parent} ||--o{ ${child} : references\n`;
           }
+        }
+        return diagram;
+      }
 
-          async function runQuery(q) {
-            const db = await import(`https://${name}.db.apphor.de/index.mjs`);
-            if (!q.endsWith(';')) {
-              q += ';';
-            }
+      function mermaidName(value) {
+        return String(value).replace(/[^a-zA-Z0-9_]/g, '_');
+      }
 
-            const s = await (q.toLowerCase().includes('select ') ? db.all(q) : db.run(q));
-            return s;
-          }
+      function mermaidType(value) {
+        return String(value || 'value').replace(/[^a-zA-Z0-9_]/g, '_').toLowerCase();
+      }
 
-          async function onRun() {
-            if (!name.value) return;
-
-            try {
-              setError('');
-              const q = query.value.trim();
-              const s = await runQuery(q);
-              append(JSON.stringify(s, null, 2));
-            } catch (e) {
-              setError(e);
-            }
-          }
+      function pretty(value) {
+        return JSON.stringify(value, null, 2);
+      }
 
-          async function onUpdateGraph() {
-            if (!name.value) return;
-            const schema = await runQuery('select * from sqlite_schema;');
-            setDiagram(schemaToMermaid(schema));
-          }
+      function escapeQueryIdentifier(value) {
+        return String(value).replaceAll('"', '""');
+      }
+
+      function appMain() {
+        const [schemaData, setSchemaData] = hook(null);
+        const [schemaTables, setSchemaTables] = hook([]);
+        const [diagram, setDiagram] = hook('erDiagram\n');
+        const [query, setQuery] = hook('');
+        const [responses, setResponses] = hook([]);
+        const [error, setError] = hook('');
+        const [loading, setLoading] = hook(false);
+        const [name] = hook(new URL(location.href).hostname.split('.')[0]);
 
-          onInit(onUpdateGraph);
+        async function database() {
+          return import(`https://${name.value}.db.apphor.de/index.mjs`);
+        }
 
-          return { name, diagram, query, responses, setName, setQuery, error, onRun, onKeyUp, onUpdateGraph };
+        async function loadSchema() {
+          try {
+            setError('');
+            setLoading(true);
+            const db = await database();
+            const value = await db.schema();
+            setSchemaData(value);
+            setSchemaTables(value.tables.filter((table) => !table.name.startsWith('sqlite_')));
+            setDiagram(schemaToMermaid(value));
+          } catch (e) {
+            setError(String(e));
+          } finally {
+            setLoading(false);
+          }
         }
 
-        function schemaToMermaid(schema) {
-          let diagram = 'erDiagram\n';
-
-          for (const row of schema) {
-            // 1. Ignore indexes, views, and system tables
-            if (row.type !== 'table' || row.name.startsWith('sqlite_') || !row.sql) continue;
-
-            const tableName = row.name;
-            const sql = row.sql;
-
-            // 2. Extract relationships (matches both inline 'REFERENCES tbl' and 'FOREIGN KEY (...) REFERENCES tbl')
-            const fkRegex = /REFERENCES\s+([^\s(;]+)/gi;
-            let match;
-            const referencedTables = new Set();
-
-            while ((match = fkRegex.exec(sql)) !== null) {
-              // Clean up target table name (strip quotes/brackets)
-              const parentTable = match[1].replace(/[`"'[\]]/g, '').split('(')[0];
-              referencedTables.add(parentTable);
-            }
-
-            referencedTables.forEach((parentTable) => {
-              diagram += `    ${parentTable} ||--o{ ${tableName} : "references"\n`;
-            });
-
-            // 3. Extract columns
-            diagram += `    ${tableName} {\n`;
-            const bodyMatch = sql.match(/\(([\s\S]+)\)/);
-
-            if (bodyMatch) {
-              const definitions = bodyMatch[1].split(/,\s*(?![^()]*\))/);
-              definitions.forEach((def) => {
-                const parts = def.trim().split(/\s+/);
-                const keyword = parts[0] ? parts[0].toUpperCase() : '';
-
-                // Skip table-level constraints
-                if (parts[0] && !['CONSTRAINT', 'PRIMARY', 'FOREIGN', 'UNIQUE', 'CHECK'].includes(keyword)) {
-                  const colName = parts[0].replace(/[`"'[\]]/g, '');
-                  const colType = parts[1] ? parts[1].replace(/,/g, '') : 'TEXT';
-                  diagram += `        ${colType} ${colName}\n`;
-                }
-              });
-            }
-            diagram += `    }\n`;
+        async function runQuery() {
+          if (!query.value.trim()) return;
+          try {
+            setError('');
+            const db = await database();
+            const method = /^\s*(select|pragma|with)\b/i.test(query.value) ? 'all' : 'run';
+            const result = await db.query(method, query.value);
+            setResponses([...responses.value, pretty(result)]);
+          } catch (e) {
+            setError(String(e));
           }
+        }
+
+        function selectTable(tableName) {
+          setQuery(`SELECT * FROM "${escapeQueryIdentifier(tableName)}" LIMIT 100;`);
+        }
 
-          return diagram;
+        function onKeyUp(event) {
+          if ((event.metaKey || event.ctrlKey) && event.key === 'Enter') {
+            event.preventDefault();
+            runQuery();
+          }
         }
-      </script>
+
+        onInit(loadSchema);
+
+        return {
+          name, schemaData, schemaTables, diagram, query, responses, error, loading,
+          setQuery, loadSchema, runQuery, selectTable, onKeyUp,
+        };
+      }
+
+      export default appMain;
+
+    </script>
+      <div class="shell">
+        <header class="topbar">
+          <img class="brand-mark" src="./logo.svg" alt="d0" />
+          <span class="brand">D0</span>
+          <span class="db-name">{{ name || 'database' }}</span>
+          <span class="spacer"></span>
+          <button type="button" on-click="loadSchema()">{{ loading ? 'Loading...' : 'Refresh schema' }}</button>
+        </header>
+        <main class="workspace">
+          <aside class="panel schema-panel">
+            <div class="panel-header">
+              <span class="panel-title">Schema</span>
+              <span class="schema-count">{{ schemaTables.length }}</span>
+            </div>
+            <div class="schema-list">
+              <template if="!schemaTables.length">
+                <div class="hint">No tables discovered.</div>
+              </template>
+              <template for="table of schemaTables">
+                <button class="schema-item" type="button" on-click="selectTable(table.name)">
+                  {{ table.name }} <span class="schema-kind">{{ table.type }}</span>
+                  <span class="schema-columns">{{ table.columns.length }} columns</span>
+                </button>
+              </template>
+            </div>
+          </aside>
+
+          <section class="panel editor-panel">
+            <div class="editor">
+              <div class="panel-title">Query</div>
+              <code-editor nolines="1" nostatus="1" theme="a11y-dark" language="sql" bind-value="query" on-change="setQuery($event.target.value)" on-keyup="onKeyUp($event)"></code-editor>
+              <div class="editor-actions">
+                <button class="run" type="button" on-click="runQuery()">Run query</button>
+              </div>
+            </div>
+            <div class="results">
+              <div class="panel-title">Results</div>
+              <template for="result of responses">
+                <code-block class="result" bind-source="result" language="json"></code-block>
+              </template>
+              <div class="error">{{ error || '' }}</div>
+            </div>
+          </section>
+
+          <section class="panel graph-panel">
+            <div class="panel-header" style="padding: 0">
+              <span class="panel-title">Relationships</span>
+              <span class="spacer"></span>
+              <button type="button" on-click="loadSchema()">Redraw</button>
+            </div>
+            <div class="graph-wrap">
+              <mermaid-graph class="h-full w-full" bind-input="diagram"></mermaid-graph>
+            </div>
+          </section>
+        </main>
+      </div>
     </template>
   </body>
 </html>

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 import { IncomingMessage, ServerResponse } from 'node:http';
 import { Database } from 'better-sqlite3';
 export declare function getDatabase(file: string): Database;
+export declare function closeDatabases(): void;
 export declare function serve(): any;
 export declare function handleRequest(request: IncomingMessage, response: ServerResponse, db: string): Promise<void>;
 export declare function onQuery(request: IncomingMessage, response: ServerResponse, db: string): Promise<void>;

package/dist/index.js

@@ -1,17 +1,46 @@
 import { createServer } from 'node:http';
+import { mkdirSync } from 'node:fs';
 import { readFile } from 'node:fs/promises';
 import SQLite from 'better-sqlite3';
 import { join } from 'node:path';
+import { performance } from 'node:perf_hooks';
 const DEBUG = !!process.env.DEBUG;
 const methods = ['all', 'run', 'get', 'exec'];
 const baseDomain = process.env.BASE_DOMAIN;
 const dataPath = process.env.DATA_PATH || join(import.meta.dirname, 'data');
+const maxDatabases = Math.max(1, Number.parseInt(process.env.MAX_DATABASES || '32', 10) || 32);
+const maxBodyBytes = Math.max(1, Number.parseInt(process.env.MAX_BODY_BYTES || '1048576', 10) || 1048576);
+const slowQueryMs = Math.max(0, Number.parseInt(process.env.SLOW_QUERY_MS || '1000', 10) || 1000);
+const databases = new Map();
+mkdirSync(dataPath, { recursive: true });
 export function getDatabase(file) {
     const fullPath = join(dataPath, file);
+    const cached = databases.get(fullPath);
+    if (cached) {
+        // Map insertion order provides a small LRU without another dependency.
+        databases.delete(fullPath);
+        databases.set(fullPath, cached);
+        return cached;
+    }
     const db = new SQLite(fullPath);
     db.pragma('journal_mode = WAL');
+    db.pragma('busy_timeout = 5000');
+    db.pragma('foreign_keys = ON');
+    databases.set(fullPath, db);
+    while (databases.size > maxDatabases) {
+        const oldest = databases.keys().next().value;
+        if (!oldest)
+            break;
+        databases.get(oldest)?.close();
+        databases.delete(oldest);
+    }
     return db;
 }
+export function closeDatabases() {
+    for (const db of databases.values())
+        db.close();
+    databases.clear();
+}
 export function serve() {
     let server;
     if (baseDomain) {
@@ -33,6 +62,7 @@ export function serve() {
     server.listen(+process.env.PORT, () => {
         console.log(`Started on ${process.env.PORT}`);
     });
+    server.once('close', closeDatabases);
     return server;
 }
 export async function handleRequest(request, response, db) {
@@ -47,22 +77,93 @@ export async function handleRequest(request, response, db) {
             const consolePage = await readFile('./console.html', 'utf8');
             response.writeHead(200, { 'content-type': 'text/html' }).end(consolePage);
             return;
+        case 'GET /logo.svg':
+            const logo = await readFile('./logo.svg', 'utf8');
+            response.writeHead(200, { 'content-type': 'image/svg+xml' }).end(logo);
+            return;
         case 'GET /index.mjs':
             return onEsModule(request, response);
+        case 'GET /schema':
+            return onSchema(response, db, url.searchParams.get('internal') === '1');
         case 'POST /query':
             return onQuery(request, response, db);
         default:
             response.writeHead(404).end();
     }
 }
+async function onSchema(response, db, includeInternal) {
+    try {
+        const sqlite = getDatabase(db);
+        const schema = getSchema(sqlite, includeInternal);
+        response.writeHead(200, { 'content-type': 'application/json' });
+        response.end(JSON.stringify(schema));
+    }
+    catch (error) {
+        DEBUG && console.error(error);
+        response.writeHead(400).end(String(error));
+    }
+}
+function getSchema(sqlite, includeInternal) {
+    const objects = sqlite
+        .prepare(`SELECT type, name, tbl_name, sql
+       FROM sqlite_schema
+       WHERE sql IS NOT NULL
+       ORDER BY CASE type WHEN 'table' THEN 0 WHEN 'index' THEN 1 WHEN 'trigger' THEN 2 ELSE 3 END, name`)
+        .all();
+    const tables = sqlite.pragma('table_list');
+    const visibleTables = tables.filter((table) => includeInternal || !table.name.startsWith('sqlite_'));
+    const details = visibleTables.map((table) => {
+        const columns = sqlite.pragma(`table_xinfo(${quotePragmaValue(table.name)})`);
+        const tableObjects = objects.filter((object) => object.tbl_name === table.name);
+        const indexes = table.type === 'table'
+            ? sqlite.pragma(`index_list(${quotePragmaValue(table.name)})`).map((index) => ({
+                ...index,
+                columns: sqlite.pragma(`index_info(${quotePragmaValue(index.name)})`),
+                sql: objects.find((object) => object.type === 'index' && object.name === index.name)?.sql || null,
+            }))
+            : [];
+        return {
+            ...table,
+            sql: objects.find((object) => object.type === 'table' && object.name === table.name)?.sql || null,
+            columns,
+            indexes,
+            foreignKeys: table.type === 'table' ? sqlite.pragma(`foreign_key_list(${quotePragmaValue(table.name)})`) : [],
+            objects: tableObjects,
+        };
+    });
+    return {
+        tables: details,
+        objects: includeInternal ? objects : objects.filter((object) => !object.name.startsWith('sqlite_')),
+        statements: (includeInternal ? objects : objects.filter((object) => !object.name.startsWith('sqlite_'))).map((object) => object.sql),
+    };
+}
+function quotePragmaValue(value) {
+    return `'${value.replaceAll("'", "''")}'`;
+}
 export async function onQuery(request, response, db) {
-    const query = Buffer.concat(await request.toArray());
+    const query = await readBody(request);
+    if (!query) {
+        response.writeHead(413).end('Request body too large.');
+        return;
+    }
     if (!query.length) {
         response.writeHead(400).end();
         return;
     }
     try {
-        const { s = '', d, m = 'run', p } = JSON.parse(query.toString('utf-8'));
+        const { s = '', d, m = 'run', p, t } = JSON.parse(query.toString('utf-8'));
+        if (t !== undefined) {
+            if (!Array.isArray(t) || !t.length)
+                throw new Error('Invalid transaction.');
+            const sqlite = getDatabase(db);
+            applyPragmas(sqlite, p);
+            const started = performance.now();
+            const result = sqlite.transaction(() => t.map((statement) => executeStatement(sqlite, statement)))();
+            logSlowQuery(started, `transaction (${t.length} statements)`);
+            response.writeHead(200, { 'content-type': 'application/json' });
+            response.end(JSON.stringify(result));
+            return;
+        }
         if (!s.trim()) {
             throw new Error('Invalid statement.');
         }
@@ -70,25 +171,56 @@ export async function onQuery(request, response, db) {
             throw new Error('Invalid method. Must be one of ' + methods.join(', '));
         }
         const sqlite = getDatabase(db);
-        if (p && Array.isArray(p) && p.every((s) => typeof s === 'string')) {
-            for (const s of p) {
-                sqlite.pragma(s);
-            }
-        }
-        let result;
-        if (m === 'exec') {
-            result = sqlite.exec(s.trim());
-        }
-        else {
-            const runner = sqlite.prepare(s.trim());
-            result = d ? runner[m](d) : runner[m]();
-        }
-        response.end(JSON.stringify(result || null));
+        applyPragmas(sqlite, p);
+        const started = performance.now();
+        const result = executeStatement(sqlite, { s, d, m });
+        logSlowQuery(started, s.trim());
+        response.writeHead(200, { 'content-type': 'application/json' });
+        response.end(JSON.stringify(result ?? null));
         DEBUG && console.log(s.trim(), d, result);
     }
     catch (error) {
         DEBUG && console.error(error);
-        response.writeHead(400).end(String(error));
+        const status = error.code === 'SQLITE_BUSY' ? 503 : 400;
+        response.writeHead(status).end(String(error));
+    }
+}
+async function readBody(request) {
+    const chunks = [];
+    let size = 0;
+    for await (const chunk of request) {
+        const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        size += buffer.length;
+        if (size > maxBodyBytes) {
+            request.resume();
+            return null;
+        }
+        chunks.push(buffer);
+    }
+    return Buffer.concat(chunks);
+}
+function applyPragmas(sqlite, pragmas) {
+    if (Array.isArray(pragmas) && pragmas.every((value) => typeof value === 'string')) {
+        for (const pragma of pragmas)
+            sqlite.pragma(pragma);
+    }
+}
+function executeStatement(sqlite, statement) {
+    const sql = statement.s;
+    const method = String(statement.m || 'run');
+    if (typeof sql !== 'string' || !sql.trim() || !methods.includes(String(method))) {
+        throw new Error('Invalid transaction statement.');
+    }
+    if (method === 'exec')
+        return sqlite.exec(sql.trim());
+    const runner = sqlite.prepare(sql.trim());
+    const execute = runner[method];
+    return statement.d === undefined ? execute.call(runner) : execute.call(runner, statement.d);
+}
+function logSlowQuery(started, statement) {
+    const duration = performance.now() - started;
+    if (DEBUG && duration >= slowQueryMs) {
+        console.log(`Slow query (${Math.round(duration)}ms):`, statement);
     }
 }
 async function onEsModule(request, response) {

package/logo.svg

@@ -0,0 +1,8 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 256 256" role="img" aria-labelledby="title desc">
+  <title id="title">d0</title>
+  <desc id="desc">A simple stacked database mark with a zero-shaped center.</desc>
+  <rect width="256" height="256" rx="56" fill="#101316" />
+  <path fill="#8bd5ca" d="M48 72c0-24 36-40 80-40s80 16 80 40v112c0 24-36 40-80 40s-80-16-80-40V72Zm24 0v112c0 8 22 16 56 16s56-8 56-16V72c-16 10-38 16-56 16S88 82 72 72Zm56-16c-34 0-56 10-56 16s22 16 56 16 56-10 56-16-22-16-56-16Z" />
+  <path fill="#101316" d="M104 120h24c22 0 36 12 36 32s-14 32-36 32h-24v-16h24c11 0 18-5 18-16s-7-16-18-16h-24v-16Z" />
+  <path fill="#101316" d="M88 120h16v64H88z" />
+</svg>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cloud-cli/d0",
-  "version": "1.6.1",
+  "version": "1.7.0",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "type": "module",