sqlite-hub 1.1.1 → 1.2.0

package/README.md

@@ -23,7 +23,7 @@ SQLite Hub keeps that workflow sharp:
 - copy result columns with formatting, headers, first-10 previews, TXT export, and Markdown todo export
 - keep database-scoped Markdown documents with previews, autosave, imports, exports, and saved-query inserts
 - switch between recent databases with sidebar quick picks
-- create simple local backups of the active database
+- create verified local backups of the active database and get safety prompts before risky operations
 - run and format SQL in a syntax-highlighted editor with history, messages, and performance metrics
 - keep large interactive query results bounded while full exports remain available
 - turn query-history results into local charts
@@ -176,9 +176,18 @@ The Settings view reports the installed SQLite Hub version and the actual SQLite
 
 The active database footer in the sidebar opens a quick-pick panel with the five most recent databases, so you can switch databases without going back to the Connections view.
 
-### Simple backups
+### Backup Manager
 
-Create timestamped local backups of the active SQLite database in one click. Backups are stored as plain file copies in a local `backups` folder next to the database.
+Create verified local backups of the active SQLite database, review backup metadata, edit backup notes, download backup files, restore verified backups, and delete managed backups from the Backups view. SQLite Hub stores backup files under its local app-state backup directory by connection id and keeps a `manifest.json` beside each database's backup files. Each backup is created through SQLite's backup API, hashed with SHA-256, and verified with `PRAGMA quick_check` before it is marked as verified.
+
+SQLite Hub also proposes a safety backup before operations that can be hard to undo:
+
+- SQL Editor execution when the statement set contains `DROP TABLE`, `ALTER TABLE`, `CREATE TABLE`, `CREATE INDEX`, `CREATE VIEW`, `CREATE TRIGGER`, `DROP INDEX`, `DROP VIEW`, `DROP TRIGGER`, `REINDEX`, or `VACUUM`.
+- SQL Editor execution with multiple schema-affecting statements in one run; this is treated as a migration and suggests a `Before migration` backup.
+- SQL import into the currently active database when the dump is larger than 5 MB or contains more than 1,000 parsed SQL statements.
+- Restore from a managed backup, because the current active database file will be replaced.
+
+The safety dialog lets you create the backup and continue, continue without creating one, or cancel the operation.
 
 ### Local-first
 
@@ -205,200 +214,12 @@ npm install -g sqlite-hub
 sqlite-hub --port:4174
 ```
 
-## CLI Interface
-
-SQLite Hub ships with a built-in CLI that lets you start the app or query information about your imported databases directly from the terminal.
-
-### Start the app
-
-```bash
-sqlite-hub                  # start on default port 4173
-sqlite-hub --port:4174      # start on a custom port
-sqlite-hub --open           # open SQLite Hub in the browser
-sqlite-hub --info           # show port, URL, versions, and update status
-sqlite-hub --help           # show help text
-sqlite-hub --version        # show version number
-```
-
-### List all imported databases
-
-```bash
-sqlite-hub --database
-sqlite-hub -d
-```
-
-Shows an overview of all databases that have been opened in SQLite Hub, including:
-
-- database name/label
-- file path
-- file size
-- last opened timestamp
-- read-only status
-
-### Query specific database details
-
-Retrieve details about a single database by its name (case-insensitive):
-
-```bash
-sqlite-hub --database:Billly --path        # get the file path
-sqlite-hub --database:Billly --size        # get the file size
-sqlite-hub --database:Billly --lastopened  # get last opened timestamp
-```
-
-### List all tables in a database
-
-```bash
-sqlite-hub --database:Billly --tables
-```
-
-Opens the database in read-only mode and prints all table names, sorted alphabetically.
-
-### Inspect a table
-
-```bash
-sqlite-hub --database:Billly --table:companies
-```
-
-Prints table metadata such as columns, primary keys, foreign keys, indexes, row count, and row identity strategy.
-
-### SQL Editor - Raw SQL And Saved Queries
-
-Execute raw SQL through the same SQL Editor execution path used by the app:
-
-```bash
-sqlite-hub --database:Unit-00 --query:"SELECT * FROM companies LIMIT 10"
-sqlite-hub --database:Unit-00 --query:"SELECT * FROM companies LIMIT 10" --store:"Company Sample"
-```
-
-Raw CLI queries are recorded in Query History. Add `--store:"name"` to title the
-history item and mark it as saved. Raw SQL execution is rejected when the target
-database is marked read-only.
-
-List all saved queries for a database:
-
-```bash
-sqlite-hub --database:Unit-00 --queries
-```
-
-Execute a specific saved query by name:
-
-```bash
-sqlite-hub --database:Unit-00 --execute:"15min Posting Buckets without id 96"
-```
-
-This searches the query history for the given database, finds the matching saved query by title, executes it, and returns all results with metadata (row count, columns, timing, and data).
-
-Show the saved query SQL without executing it:
-
-```bash
-sqlite-hub --database:Unit-00 --saved-query:"Stock Winners"
-```
-
-Show the saved notes for a query:
-
-```bash
-sqlite-hub --database:Unit-00 --notes:"TOP25 Loser and Winner EOD, T1, T3, T5"
-```
-
-Export a saved query using the same CSV, TSV, Markdown, and JSON export logic as the SQL Editor:
-
-```bash
-sqlite-hub --database:Unit-00 --export:"Stock Winners" --format:csv
-sqlite-hub --database:Unit-00 --export:"Stock Winners" --format:tsv
-sqlite-hub --database:Unit-00 --export:"Stock Winners" --format:md
-sqlite-hub --database:Unit-00 --export:"Stock Winners" --format:json
-```
-
-The export is written to the current working directory using the generated query export filename.
+## CLI
 
-### Documents CLI
-
-List all Markdown documents stored for a database:
-
-```bash
-sqlite-hub --database:Unit-00 --documents
-```
-
-Print one document's Markdown content:
-
-```bash
-sqlite-hub --database:Unit-00 --documents:"Research Notes"
-```
-
-Export one document as a `.md` file into the current working directory:
-
-```bash
-sqlite-hub --database:Unit-00 --documents:"Research Notes" --export
-sqlite-hub --database:Unit-00 --documents:"Research Notes--export"
-```
-
-Documents can be matched by id, filename, title, or a partial filename/title match.
-
-### Row JSON export
-
-Export a single row as JSON by primary key or rowid, using the same row-shaping logic as the Row Editor:
-
-```bash
-sqlite-hub --database:Unit-00 --table:companies --export:0a754aba373d34972998792a0be4333c
-```
-
-### Available flags
-
-| Flag                                                            | Description                                     |
-| --------------------------------------------------------------- | ----------------------------------------------- |
-| `--help`, `-h`                                                  | Show help text                                  |
-| `--version`, `-v`                                               | Show version number                             |
-| `--info`                                                        | Show port, URL, versions, and update status     |
-| `--open`                                                        | Open SQLite Hub in the browser                  |
-| `--port:PORT`                                                   | Start the server on a custom port               |
-| `--database`, `-d`                                              | List all imported databases                     |
-| `--database:name`                                               | Select a database by name or id                 |
-| `--database:name --path`                                        | Get the file path of a database                 |
-| `--database:name --size`                                        | Get the size of a database                      |
-| `--database:name --lastopened`                                  | Get the last opened timestamp                   |
-| `--database:name --tables`                                      | Get all table names from a database             |
-| `--database:name --queries`                                     | List saved queries for a database               |
-| `--database:name --query:"sql"`                                 | Execute raw SQL and record it in Query History  |
-| `--database:name --query:"sql" --store:"name"`                  | Save a raw query in Query History with a name   |
-| `--database:name --execute:"query"`                             | Execute a saved query by name                   |
-| `--database:name --saved-query:"query"`                         | Print a saved query by name                     |
-| `--database:name --notes:"query"`                               | Print saved notes for a query                   |
-| `--database:name --export:"query" --format:csv\|tsv\|md\|json` | Set query export format                         |
-| `--database:name --documents`                                   | List Markdown documents for a database          |
-| `--database:name --documents:"document"`                        | Print a document's Markdown content             |
-| `--database:name --documents:"document" --export`               | Export a document as Markdown                   |
-| `--database:name --table:"table"`                               | Print table metadata                            |
-| `--database:name --table:"table" --export:"pk"`                 | Export one row as JSON                          |
-
-Legacy aliases such as `--database-path:name`, `--database-size:name`, `--database-lastopened:name`, `--database-tables:name`, and `--database:name --sqleditor:"query"` still work.
-
-### SQL editor CLI example
-
-Saved queries created in the graphical SQL Editor can also be executed through the CLI. To execute one, run:
-
-```bash
-sqlite-hub --database:Unit-00 --execute:"Group by creation Year"
-```
-
-Example output:
-
-```bash
-Executing: Group by creation Year
-SQL: SELECT STRFTIME('%Y', creation_time, 'unixepoch') AS creation_year, COUNT(*) AS channel_count FROM channels WHERE creation_time IS NOT NU...
-────────────────────────────────────────────────────────────
-
-Statement count: 1
-Timing: 1ms
-
-Statement 1 (resultSet):
-Rows: 3
-Columns: creation_year, channel_count
-
-Results:
-  [0] 2024 | 11
-  [1] 2025 | 47
-  [2] 2026 | 40
-```
+SQLite Hub ships with a built-in CLI for starting the app, inspecting imported
+databases, executing raw or saved SQL, exporting query results, exporting single
+rows as JSON, and working with Markdown documents. See the
+[CLI documentation](./docs/CLI.md) for commands, flags, and examples.
 
 ## API
 

package/bin/sqlite-hub.js

@@ -566,7 +566,9 @@ function printExecutionResult(result) {
 }
 
 function executeSavedQuery({ databaseService, conn, queryName }) {
-    const { query: matchingQuery, result } = databaseService.executeSavedQuery(conn.id, queryName);
+    const { query: matchingQuery, result } = databaseService.executeSavedQuery(conn.id, queryName, {
+        executedBy: "cli",
+    });
 
     console.log(`\nExecuting: ${getQueryTitle(matchingQuery)}`);
     console.log(`SQL: ${matchingQuery.previewSql || matchingQuery.rawSql}`);
@@ -576,7 +578,10 @@ function executeSavedQuery({ databaseService, conn, queryName }) {
 }
 
 function executeRawQuery({ databaseService, conn, sql, storeName = null }) {
-    const { result, storedQuery } = databaseService.executeRawQuery(conn.id, sql, { storeName });
+    const { result, storedQuery } = databaseService.executeRawQuery(conn.id, sql, {
+        storeName,
+        executedBy: "cli",
+    });
 
     console.log(`\nExecuting raw SQL against: ${conn.label}`);
     console.log('─'.repeat(60));

package/frontend/js/api.js

@@ -105,6 +105,13 @@ export function importSql(payload) {
   });
 }
 
+export function previewImportSql(payload) {
+  return request("/api/connections/import-sql/preview", {
+    method: "POST",
+    body: payload,
+  });
+}
+
 export function selectActiveConnection(id) {
   return request("/api/connections/select-active", {
     method: "POST",
@@ -131,6 +138,59 @@ export function createActiveConnectionBackup() {
   });
 }
 
+export function getBackups(options = {}) {
+  const params = new URLSearchParams();
+
+  if (options.all) {
+    params.set("all", "true");
+  }
+
+  const query = params.toString();
+  return request(`/api/backups${query ? `?${query}` : ""}`);
+}
+
+export function getBackup(backupId) {
+  return request(`/api/backups/${encodeURIComponent(backupId)}`);
+}
+
+export function createBackup(payload = {}) {
+  return request("/api/backups", {
+    method: "POST",
+    body: payload,
+  });
+}
+
+export function updateBackup(backupId, payload = {}) {
+  return request(`/api/backups/${encodeURIComponent(backupId)}`, {
+    method: "PATCH",
+    body: payload,
+  });
+}
+
+export function restoreBackup(backupId) {
+  return request(`/api/backups/${encodeURIComponent(backupId)}/restore`, {
+    method: "POST",
+  });
+}
+
+export function verifyBackup(backupId) {
+  return request(`/api/backups/${encodeURIComponent(backupId)}/verify`, {
+    method: "POST",
+  });
+}
+
+export function deleteBackup(backupId) {
+  return request(`/api/backups/${encodeURIComponent(backupId)}`, {
+    method: "DELETE",
+  });
+}
+
+export function downloadBackup(backupId) {
+  return download(`/api/backups/${encodeURIComponent(backupId)}/download`, {
+    fallbackFilename: "backup.sqlite",
+  });
+}
+
 export function getOverview() {
   return request("/api/db/overview");
 }