@cloud-cli/d0 1.7.4 → 1.8.0

package/Dockerfile

@@ -1,21 +1,10 @@
-FROM ghcr.io/cloud-cli/node:latest AS builder
-
-USER root
-WORKDIR /home/app
-COPY . /home/app
-ENV CI=true
-RUN npm install --global pnpm@12.3.4
-RUN pnpm i && pnpm build && rm -rf node_modules/ src/
-
-FROM ghcr.io/cloud-cli/node:latest
-
-USER root
+FROM ghcr.io/cloud-cli/image-node:latest AS builder
+COPY . .
+USER 0
+RUN pnpm i && pnpm build && rm -rf src/ && pnpm clean
 ENV NODE_ENV=production
+RUN pnpm i --prod --frozen-lockfile && pnpm rebuild better-sqlite3
 ENV DATA_PATH=/home/app/data
-WORKDIR /home/app
-COPY --from=builder --chown=node:node /home/app/ ./
-RUN npm install --global pnpm@12.3.4
-RUN pnpm install --prod --frozen-lockfile && pnpm rebuild better-sqlite3
 RUN mkdir -p /home/app/data && chown node:node /home/app/data
+USER 1000
 VOLUME ["/home/app/data"]
-USER node

package/README.md

@@ -13,6 +13,10 @@ const schema = await db.schema();
 console.log(schema.tables, schema.statements);
 ```
 
+**GET /api** returns an OpenAPI 3.1 description of the HTTP API.
+
+The web console uses an explicit method selector instead of guessing from SQL text. Use `all` or `get` for reads, `run` for one prepared statement, `exec` for DDL or multiple statements, and `transaction` to run the entered SQL atomically.
+
 **POST /query**
 
 Run a prepared SQLite statement.

package/console.html

@@ -16,6 +16,7 @@
         }
       }
     </script>
+    <script src="https://cdn.jsdelivr.net/npm/@tailwindcss/browser@4"></script>
     <style>
       :root {
         color-scheme: dark;
@@ -29,14 +30,27 @@
         --danger: #ff8f8f;
       }
 
-      * { box-sizing: border-box; }
-      html, body { height: 100%; margin: 0; }
+      * {
+        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;
+        font:
+          14px/1.4 ui-monospace,
+          SFMono-Regular,
+          Menlo,
+          monospace;
+      }
+      button,
+      input {
+        font: inherit;
       }
-      button, input { font: inherit; }
       button {
         border: 1px solid var(--border);
         border-radius: 6px;
@@ -45,8 +59,17 @@
         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; }
+      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);
@@ -54,192 +77,349 @@
         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; }
+      .brand {
+        color: var(--accent);
+        font-weight: 700;
+        letter-spacing: 0.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; }
+      .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: 0.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: 0.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; }
+        .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; }
+        .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>
+  <body class="h-full min-h-full bg-[#101316] font-mono text-sm leading-relaxed text-[#edf2f7]">
     <script type="module">
       import '@li3/web';
     </script>
     <app-main class="contents"></app-main>
 
     <template component="app-main">
-    <script setup>
-      import { hook, onInit } from '@li3/web';
+      <script setup>
+        import { hook, onInit } from '@li3/web';
+        import db from '@app/index.mjs';
 
-      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 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';
 
-        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`;
+          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';
           }
-          diagram += '    }\n';
-        }
 
-        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`;
+          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;
         }
-        return diagram;
-      }
 
-      function mermaidName(value) {
-        return String(value).replace(/[^a-zA-Z0-9_]/g, '_');
-      }
-
-      function mermaidType(value) {
-        return String(value || 'value').replace(/[^a-zA-Z0-9_]/g, '_').toLowerCase();
-      }
-
-      function pretty(value) {
-        return JSON.stringify(value, null, 2);
-      }
+        function mermaidName(value) {
+          return String(value).replace(/[^a-zA-Z0-9_]/g, '_');
+        }
 
-      function escapeQueryIdentifier(value) {
-        return String(value).replaceAll('"', '""');
-      }
+        function mermaidType(value) {
+          return String(value || 'value')
+            .replace(/[^a-zA-Z0-9_]/g, '_')
+            .toLowerCase();
+        }
 
-      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]);
+        function pretty(value) {
+          return JSON.stringify(value, null, 2);
+        }
 
-        async function database() {
-          return import(`https://${name.value}.db.apphor.de/index.mjs`);
+        function escapeQueryIdentifier(value) {
+          return String(value).replaceAll('"', '""');
         }
 
-        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 appMain() {
+          const [schemaData, setSchemaData] = hook(null);
+          const [schemaTables, setSchemaTables] = hook([]);
+          const [diagram, setDiagram] = hook('erDiagram\n');
+          const [query, setQuery] = hook('');
+          const [method, setMethod] = hook('all');
+          const [responses, setResponses] = hook([]);
+          const [error, setError] = hook('');
+          const [loading, setLoading] = hook(false);
+          const name = new URL(location.href).hostname.split('.')[0];
+
+          async function loadSchema() {
+            try {
+              setError('');
+              setLoading(true);
+              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);
+            }
           }
-        }
 
-        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));
+          async function runQuery() {
+            if (!query.value.trim()) return;
+            try {
+              setError('');
+              const result = method.value === 'transaction'
+                ? await db.transaction([{ s: query.value, m: 'exec' }])
+                : await db.query(method.value, query.value);
+              setResponses([...responses.value, pretty(result)]);
+            } catch (e) {
+              setError(String(e));
+            }
           }
-        }
 
-        function selectTable(tableName) {
-          setQuery(`SELECT * FROM "${escapeQueryIdentifier(tableName)}" LIMIT 100;`);
-        }
+          function selectTable(tableName) {
+            setMethod('all');
+            setQuery(`SELECT * FROM "${escapeQueryIdentifier(tableName)}" LIMIT 100;`);
+          }
 
-        function onKeyUp(event) {
-          if ((event.metaKey || event.ctrlKey) && event.key === 'Enter') {
-            event.preventDefault();
-            runQuery();
+          function clearResponses() {
+            setResponses([]);
           }
-        }
 
-        onInit(loadSchema);
+          function onKeyUp(event) {
+            if ((event.metaKey || event.ctrlKey) && event.key === 'Enter') {
+              event.preventDefault();
+              runQuery();
+            }
+          }
 
-        return {
-          name, schemaData, schemaTables, diagram, query, responses, error, loading,
-          setQuery, loadSchema, runQuery, selectTable, onKeyUp,
-        };
-      }
+          onInit(loadSchema);
 
-      export default appMain;
+          return {
+            name,
+            schemaData,
+            schemaTables,
+            diagram,
+            query,
+            method,
+            responses,
+            error,
+            loading,
+            setQuery,
+            setMethod,
+            loadSchema,
+            runQuery,
+            selectTable,
+            clearResponses,
+            onKeyUp,
+          };
+        }
 
-    </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>
+        export default appMain;
+      </script>
+      <div class="shell h-full min-h-0 grid-rows-[auto_1fr]">
+        <header class="topbar flex items-center gap-2.5 border-b border-[#303943] px-3.5 py-2.5">
+          <img class="brand-mark h-6 w-6 rounded-[5px]" src="./logo.svg" alt="d0" />
+          <span class="brand font-bold tracking-[.08em] text-[#8bd5ca]">D0</span>
+          <span class="db-name max-w-[40vw] overflow-hidden text-ellipsis whitespace-nowrap text-[#8d99a8]">{{ name || 'database' }}</span>
+          <span class="spacer flex-1"></span>
+          <button class="rounded-md border border-[#303943] bg-[#1d232a] px-2.5 py-1.5 text-[#edf2f7] hover:border-[#8bd5ca] hover:text-[#8bd5ca]" 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>
+        <main class="workspace grid min-h-0 grid-cols-[245px_minmax(360px,1fr)_minmax(360px,1.15fr)] max-[1050px]:grid-cols-[210px_minmax(330px,1fr)] max-[1050px]:grid-rows-[minmax(0,1fr)_minmax(420px,auto)] max-[680px]:block max-[680px]:overflow-auto">
+          <aside class="panel schema-panel flex min-h-0 min-w-0 flex-col overflow-hidden border-r border-[#303943] max-[1050px]:row-span-1 max-[680px]:max-h-[220px] max-[680px]:border-b max-[680px]:border-r-0">
+            <div class="panel-header flex items-center gap-2 px-3 py-3">
+              <span class="panel-title text-[11px] uppercase tracking-[.1em] text-[#8d99a8]">Schema</span>
+              <span class="schema-count ml-auto text-[#8bd5ca]">{{ schemaTables.length }}</span>
             </div>
-            <div class="schema-list">
+            <div class="schema-list flex-1 overflow-auto border-t border-[#303943] p-1.5">
               <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)">
+                <button class="schema-item block w-full rounded-md border-0 bg-transparent p-2.5 text-left hover:bg-[#1d232a]" 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>
@@ -247,16 +427,36 @@
             </div>
           </aside>
 
-          <section class="panel editor-panel">
+          <section class="panel editor-panel grid min-h-0 min-w-0 grid-rows-[minmax(190px,38%)_minmax(0,1fr)] overflow-hidden border-r border-[#303943] max-[1050px]:border-r-0 max-[680px]:h-[560px] max-[680px]:border-b">
             <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="flex items-center justify-between gap-2">
+                <div class="panel-title">Query</div>
+                <select class="rounded-md border border-[#303943] bg-[#1d232a] px-2 py-1 text-xs text-[#edf2f7] outline-none focus:border-[#8bd5ca]" bind-value="method" on-change="setMethod($event.target.value)" aria-label="Query method">
+                  <option value="all">all rows</option>
+                  <option value="get">one row</option>
+                  <option value="run">run statement</option>
+                  <option value="exec">execute SQL</option>
+                  <option value="transaction">transaction</option>
+                </select>
+              </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>
+            <div class="results min-h-0 overflow-auto p-3">
+              <div class="flex items-center justify-between">
+                <div class="panel-title text-[11px] uppercase tracking-[.1em] text-[#8d99a8]">Results</div>
+                <button class="rounded border border-[#303943] bg-transparent px-1.5 py-0.5 text-xs text-[#8d99a8] hover:border-[#ff8f8f] hover:text-[#ff8f8f]" type="button" title="Clear results" aria-label="Clear results" on-click="clearResponses()">X</button>
+              </div>
               <template for="result of responses">
                 <code-block class="result" bind-source="result" language="json"></code-block>
               </template>
@@ -264,11 +464,11 @@
             </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>
+          <section class="panel graph-panel grid min-h-0 min-w-0 grid-rows-[auto_minmax(0,1fr)] gap-2.5 overflow-hidden p-3 max-[1050px]:col-span-2 max-[1050px]:border-t max-[1050px]:border-[#303943] max-[680px]:min-h-[420px]">
+            <div class="panel-header flex items-center gap-2 p-0">
+              <span class="panel-title text-[11px] uppercase tracking-[.1em] text-[#8d99a8]">Relationships</span>
+              <span class="spacer flex-1"></span>
+              <button class="rounded-md border border-[#303943] bg-[#1d232a] px-2.5 py-1.5 hover:border-[#8bd5ca] hover:text-[#8bd5ca]" type="button" on-click="loadSchema()">Redraw</button>
             </div>
             <div class="graph-wrap">
               <mermaid-graph class="h-full w-full" bind-input="diagram"></mermaid-graph>

package/dist/index.js

@@ -81,6 +81,8 @@ export async function handleRequest(request, response, db) {
             const logo = await readFile('./logo.svg', 'utf8');
             response.writeHead(200, { 'content-type': 'image/svg+xml' }).end(logo);
             return;
+        case 'GET /api':
+            return onApi(request, response);
         case 'GET /index.mjs':
             return onEsModule(request, response);
         case 'GET /schema':
@@ -91,16 +93,88 @@ export async function handleRequest(request, response, db) {
             response.writeHead(404).end();
     }
 }
+function onApi(request, response) {
+    const host = request.headers['x-forwarded-host'] || request.headers.host;
+    const protocol = request.headers['x-forwarded-proto'] || 'http';
+    const document = {
+        openapi: '3.1.0',
+        info: {
+            title: 'd0 SQLite API',
+            version: '1.0.0',
+            description: 'SQLite over HTTPS with prepared statements and schema introspection.',
+        },
+        ...(host ? { servers: [{ url: `${protocol}://${host}` }] } : {}),
+        paths: {
+            '/query': {
+                post: {
+                    summary: 'Execute SQL',
+                    requestBody: {
+                        required: true,
+                        content: { 'application/json': { schema: { $ref: '#/components/schemas/QueryRequest' } } },
+                    },
+                    responses: {
+                        '200': { description: 'SQLite result.' },
+                        '400': { description: 'Invalid SQL or request.' },
+                        '413': { description: 'Request body too large.' },
+                        '503': { description: 'SQLite is busy.' },
+                    },
+                },
+            },
+            '/schema': {
+                get: {
+                    summary: 'Inspect database schema',
+                    parameters: [
+                        {
+                            name: 'internal',
+                            in: 'query',
+                            required: false,
+                            schema: { type: 'string', enum: ['1'] },
+                            description: 'Include SQLite internal objects.',
+                        },
+                    ],
+                    responses: { '200': { description: 'Schema metadata.' } },
+                },
+            },
+            '/index.mjs': { get: { summary: 'Get the consumer ES module', responses: { '200': { description: 'JavaScript module.' } } } },
+            '/console.html': { get: { summary: 'Get the web console', responses: { '200': { description: 'HTML console.' } } } },
+            '/logo.svg': { get: { summary: 'Get the d0 logo', responses: { '200': { description: 'SVG image.' } } } },
+        },
+        components: {
+            schemas: {
+                QueryRequest: {
+                    type: 'object',
+                    properties: {
+                        s: { type: 'string', description: 'SQL statement.' },
+                        d: { description: 'Positional or named statement bindings.' },
+                        m: { type: 'string', enum: ['all', 'get', 'run', 'exec'], default: 'run' },
+                        p: { type: 'array', items: { type: 'string' }, description: 'Pragmas applied before execution.' },
+                        t: { type: 'array', items: { $ref: '#/components/schemas/TransactionStatement' } },
+                    },
+                    description: 'Use t instead of s to execute an atomic transaction.',
+                },
+                TransactionStatement: {
+                    type: 'object',
+                    required: ['s'],
+                    properties: {
+                        s: { type: 'string' },
+                        d: {},
+                        m: { type: 'string', enum: ['all', 'get', 'run', 'exec'], default: 'run' },
+                    },
+                },
+            },
+        },
+    };
+    sendJson(response, 200, document);
+}
 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));
+        sendJson(response, 200, schema);
     }
     catch (error) {
         DEBUG && console.error(error);
-        response.writeHead(400).end(String(error));
+        sendError(response, 400, error);
     }
 }
 function getSchema(sqlite, includeInternal) {
@@ -142,6 +216,7 @@ function quotePragmaValue(value) {
 }
 export async function onQuery(request, response, db) {
     const query = await readBody(request);
+    let isTransaction = false;
     if (!query) {
         response.writeHead(413).end('Request body too large.');
         return;
@@ -153,15 +228,15 @@ export async function onQuery(request, response, db) {
     try {
         const { s = '', d, m = 'run', p, t } = JSON.parse(query.toString('utf-8'));
         if (t !== undefined) {
+            isTransaction = true;
             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)))();
+            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));
+            sendJson(response, 200, { success: true });
             return;
         }
         if (!s.trim()) {
@@ -175,16 +250,25 @@ export async function onQuery(request, response, db) {
         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));
+        sendJson(response, 200, result ?? null);
         DEBUG && console.log(s.trim(), d, result);
     }
     catch (error) {
         DEBUG && console.error(error);
         const status = error.code === 'SQLITE_BUSY' ? 503 : 400;
-        response.writeHead(status).end(String(error));
+        sendError(response, status, error, isTransaction ? 'Transaction failed: ' : '');
     }
 }
+function redactDataPath(value) {
+    return value.replaceAll(dataPath, '***');
+}
+function sendJson(response, status, value) {
+    response.writeHead(status, { 'content-type': 'application/json' });
+    response.end(redactDataPath(JSON.stringify(value)));
+}
+function sendError(response, status, error, prefix = '') {
+    response.writeHead(status).end(redactDataPath(prefix + String(error)));
+}
 async function readBody(request) {
     const chunks = [];
     let size = 0;
@@ -211,8 +295,10 @@ function executeStatement(sqlite, statement) {
     if (typeof sql !== 'string' || !sql.trim() || !methods.includes(String(method))) {
         throw new Error('Invalid transaction statement.');
     }
-    if (method === 'exec')
-        return sqlite.exec(sql.trim());
+    if (method === 'exec') {
+        sqlite.exec(sql.trim());
+        return null;
+    }
     const runner = sqlite.prepare(sql.trim());
     const execute = runner[method];
     return statement.d === undefined ? execute.call(runner) : execute.call(runner, statement.d);
@@ -231,5 +317,5 @@ async function onEsModule(request, response) {
         'Content-Type': 'text/javascript',
         'Access-Control-Allow-Origin': '*',
     })
-        .end(code.replace('__API_URL__', hostname));
+        .end(redactDataPath(code.replace('__API_URL__', hostname)));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cloud-cli/d0",
-  "version": "1.7.4",
+  "version": "1.8.0",
   "packageManager": "pnpm@12.3.4",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",