sqlite-hub 1.1.1 → 1.2.0

package/tests/backup-manager.test.js

@@ -0,0 +1,140 @@
+const assert = require("node:assert/strict");
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+const test = require("node:test");
+const Database = require("better-sqlite3");
+
+const { BackupService } = require("../server/services/sqlite/backupService");
+const { ConnectionManager } = require("../server/services/sqlite/connectionManager");
+const { AppStateStore } = require("../server/services/storage/appStateStore");
+
+function createFixture(t) {
+  const directory = fs.mkdtempSync(path.join(os.tmpdir(), "sqlite-hub-backups-"));
+  const databasePath = path.join(directory, "source.sqlite");
+  const db = new Database(databasePath);
+
+  db.exec(`
+    CREATE TABLE companies (id INTEGER PRIMARY KEY, name TEXT NOT NULL);
+    INSERT INTO companies (name) VALUES ('Acme'), ('Globex');
+  `);
+  db.close();
+
+  const store = new AppStateStore(path.join(directory, "state.db"));
+  const connectionManager = new ConnectionManager({ appStateStore: store });
+  const connection = connectionManager.openConnection({
+    filePath: databasePath,
+    label: "Source",
+    id: "conn_source",
+    makeActive: true,
+  });
+  const backupService = new BackupService({
+    appStateStore: store,
+    connectionManager,
+    backupRootDirectory: path.join(directory, "SQLite Hub", "backups"),
+  });
+
+  t.after(() => {
+    connectionManager.closeCurrent();
+    store.db.close();
+    fs.rmSync(directory, { recursive: true, force: true });
+  });
+
+  return {
+    backupService,
+    connection,
+    connectionManager,
+    directory,
+    store,
+  };
+}
+
+test("backups table is created with recent_connections foreign key and checks", (t) => {
+  const { store } = createFixture(t);
+  const tables = new Set(
+    store.db.prepare("SELECT name FROM sqlite_schema WHERE type = 'table'").all().map(row => row.name)
+  );
+  const foreignKeys = store.db.prepare("PRAGMA foreign_key_list(backups)").all();
+
+  assert.equal(tables.has("backups"), true);
+  assert.equal(foreignKeys[0].table, "recent_connections");
+  assert.equal(foreignKeys[0].from, "connectionId");
+  assert.equal(foreignKeys[0].on_delete, "SET NULL");
+
+  assert.throws(
+    () =>
+      store.createBackupRecord({
+        id: "invalid",
+        connectionId: "conn_source",
+        name: "Invalid",
+        path: path.join(os.tmpdir(), "invalid.sqlite"),
+        status: "unknown",
+        type: "manual",
+        sourcePath: path.join(os.tmpdir(), "source.sqlite"),
+        createdAt: new Date().toISOString(),
+      }),
+    /CHECK constraint failed/
+  );
+});
+
+test("manual backup creates file, metadata, manifest, and survives connection removal", async (t) => {
+  const { backupService, connection, store } = createFixture(t);
+
+  const backup = await backupService.createActiveBackup({
+    name: "Before migration",
+    notes: "Schema update",
+  });
+  const manifestPath = path.join(
+    backupService.backupRootDirectory,
+    connection.id,
+    "manifest.json"
+  );
+  const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
+  const stored = store.getBackup(backup.id);
+
+  assert.equal(backup.status, "verified");
+  assert.equal(backup.connectionId, connection.id);
+  assert.equal(backup.notes, "Schema update");
+  assert.equal(fs.existsSync(backup.path), true);
+  assert.match(path.relative(backupService.backupRootDirectory, backup.path), /^conn_source\//);
+  assert.equal(stored.checksumSha256.length, 64);
+  assert.equal(stored.tableCount, 1);
+  assert.equal(stored.rowCount, 2);
+  assert.equal(manifest.databaseId, connection.id);
+  assert.equal(manifest.backups[0].id, backup.id);
+  assert.equal(manifest.backups[0].status, "verified");
+
+  store.removeRecentConnection(connection.id);
+  assert.equal(store.getBackup(backup.id).connectionId, null);
+});
+
+test("backup notes can be updated after creation and manifest stays in sync", async (t) => {
+  const { backupService, connection, store } = createFixture(t);
+
+  const backup = await backupService.createActiveBackup({
+    name: "Before migration",
+    notes: "Initial note",
+  });
+  const updated = backupService.updateBackupNotes(backup.id, "Reviewed after restore test");
+  const manifestPath = path.join(
+    backupService.backupRootDirectory,
+    connection.id,
+    "manifest.json"
+  );
+  const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
+
+  assert.equal(updated.notes, "Reviewed after restore test");
+  assert.equal(store.getBackup(backup.id).notes, "Reviewed after restore test");
+  assert.equal(manifest.backups[0].notes, "Reviewed after restore test");
+});
+
+test("delete backup removes file, record, and manifest entry", async (t) => {
+  const { backupService, store } = createFixture(t);
+  const backup = await backupService.createActiveBackup({ name: "Manual backup" });
+  const backupPath = backup.path;
+
+  backupService.deleteBackup(backup.id);
+
+  assert.equal(fs.existsSync(backupPath), false);
+  assert.equal(store.getBackup(backup.id), null);
+});

package/tests/backups-view.test.js

@@ -0,0 +1,70 @@
+const assert = require("node:assert/strict");
+const path = require("node:path");
+const { pathToFileURL } = require("node:url");
+const test = require("node:test");
+
+async function loadModule() {
+  return import(pathToFileURL(path.resolve(__dirname, "../frontend/js/views/backups.js")).href);
+}
+
+function createState(overrides = {}) {
+  return {
+    connections: {
+      active: { id: "db-one", label: "Customers", readOnly: false },
+    },
+    backups: {
+      items: [],
+      loading: false,
+      operationLoading: false,
+      error: null,
+    },
+    ...overrides,
+  };
+}
+
+test("backup manager renders empty state and create action", async () => {
+  const { renderBackupsView } = await loadModule();
+  const rendered = renderBackupsView(createState()).main;
+
+  assert.match(rendered, /No backups yet/);
+  assert.match(rendered, /data-action="open-create-backup-modal"/);
+});
+
+test("backup manager renders backup rows with status and actions", async () => {
+  const { renderBackupsView } = await loadModule();
+  const rendered = renderBackupsView(
+    createState({
+      backups: {
+        items: [
+          {
+            id: "backup-one",
+            name: "Before migration",
+            notes: "Schema update",
+            sizeBytes: 1024,
+            status: "verified",
+            sqliteHubVersion: "1.1.2",
+            sqliteVersion: "3.50.0",
+            fileExists: true,
+            fileName: "backup.sqlite",
+            path: "/tmp/backup.sqlite",
+            createdAt: "2026-06-21T11:42:18.000Z",
+          },
+        ],
+        loading: false,
+        operationLoading: false,
+        error: null,
+      },
+    })
+  ).main;
+
+  assert.match(rendered, /Before migration/);
+  assert.match(rendered, /Verified/);
+  assert.match(rendered, /SQLite Hub/);
+  assert.match(rendered, /v1\.1\.2/);
+  assert.match(rendered, /SQLite/);
+  assert.match(rendered, /v3\.50\.0/);
+  assert.match(rendered, /data-action="open-edit-backup-notes-modal"/);
+  assert.match(rendered, /data-action="open-restore-backup-modal"/);
+  assert.match(rendered, /data-action="download-backup"/);
+  assert.match(rendered, /data-action="open-delete-backup-modal"/);
+});

package/tests/charts-height-preset-storage.test.js

@@ -0,0 +1,60 @@
+const assert = require("node:assert/strict");
+const path = require("node:path");
+const { pathToFileURL } = require("node:url");
+const test = require("node:test");
+
+const CHARTS_HEIGHT_STORAGE_KEY = "sqlite_hub_charts_height_preset";
+
+function createMockStorage(initialValues = {}) {
+  const entries = new Map(Object.entries(initialValues));
+
+  return {
+    getItem(key) {
+      return entries.has(key) ? entries.get(key) : null;
+    },
+    setItem(key, value) {
+      entries.set(key, String(value));
+    },
+  };
+}
+
+async function importStoreWithMockStorage(storage) {
+  const originalDescriptor = Object.getOwnPropertyDescriptor(globalThis, "localStorage");
+
+  Object.defineProperty(globalThis, "localStorage", {
+    configurable: true,
+    value: storage,
+  });
+
+  const moduleUrl = pathToFileURL(path.resolve(__dirname, "../frontend/js/store.js")).href;
+  const store = await import(`${moduleUrl}?charts-height=${Date.now()}`);
+
+  return {
+    restore() {
+      if (originalDescriptor) {
+        Object.defineProperty(globalThis, "localStorage", originalDescriptor);
+      } else {
+        delete globalThis.localStorage;
+      }
+    },
+    store,
+  };
+}
+
+test("charts height preset is read from and written to localStorage", async () => {
+  const storage = createMockStorage({
+    [CHARTS_HEIGHT_STORAGE_KEY]: "large",
+  });
+  const { restore, store } = await importStoreWithMockStorage(storage);
+
+  try {
+    assert.equal(store.getState().charts.chartHeightPreset, "large");
+
+    store.setChartsHeightPreset("small");
+
+    assert.equal(store.getState().charts.chartHeightPreset, "small");
+    assert.equal(storage.getItem(CHARTS_HEIGHT_STORAGE_KEY), "small");
+  } finally {
+    restore();
+  }
+});

package/tests/charts-route-state.test.js

@@ -0,0 +1,144 @@
+const assert = require("node:assert/strict");
+const path = require("node:path");
+const { pathToFileURL } = require("node:url");
+const test = require("node:test");
+
+function jsonResponse(payload) {
+  return new Response(JSON.stringify({ success: true, ...payload }), {
+    headers: { "content-type": "application/json" },
+    status: 200,
+  });
+}
+
+function createChartsFetchMock() {
+  const activeConnection = {
+    id: "db-one",
+    label: "Database One",
+    readOnly: false,
+  };
+  const chartableQuery = {
+    id: 10,
+    displayTitle: "Revenue Chart",
+    previewSql: "select revenue from metrics",
+    rawSql: "select revenue from metrics",
+    queryType: "select",
+    isSaved: false,
+    isDestructive: false,
+    chartTypes: ["bar"],
+  };
+
+  return async function fetchMock(input, options = {}) {
+    const url = typeof input === "string" ? input : input.url;
+    const method = String(options.method ?? "GET").toUpperCase();
+
+    if (method === "GET" && url === "/api/connections/recent") {
+      return jsonResponse({ data: [activeConnection] });
+    }
+
+    if (method === "GET" && url === "/api/connections/active") {
+      return jsonResponse({ data: activeConnection });
+    }
+
+    if (method === "GET" && url === "/api/settings") {
+      return jsonResponse({
+        data: {},
+        metadata: {
+          activeDatabase: activeConnection,
+          apiTokens: [],
+          appVersion: "1.1.2",
+          sqliteVersion: "3.50.0",
+        },
+      });
+    }
+
+    if (method === "GET" && url.startsWith("/api/sql/history")) {
+      return jsonResponse({ data: { items: [], total: 0, hasMore: false } });
+    }
+
+    if (method === "GET" && url === "/api/db/overview") {
+      return jsonResponse({ data: { tables: [] } });
+    }
+
+    if (method === "GET" && url === "/api/charts/query-history") {
+      return jsonResponse({ data: [chartableQuery] });
+    }
+
+    if (method === "GET" && url === "/api/charts/query-history/10") {
+      return jsonResponse({
+        data: {
+          item: chartableQuery,
+          charts: [],
+        },
+      });
+    }
+
+    if (method === "POST" && url === "/api/charts/query-history/10/execute") {
+      return jsonResponse({
+        data: {
+          columns: ["revenue"],
+          rows: [{ revenue: 100 }],
+          sql: chartableQuery.rawSql,
+        },
+      });
+    }
+
+    return new Response(
+      JSON.stringify({
+        success: false,
+        error: { code: "UNEXPECTED_REQUEST", message: `${method} ${url}` },
+      }),
+      {
+        headers: { "content-type": "application/json" },
+        status: 500,
+      },
+    );
+  };
+}
+
+async function importStoreWithFetch(fetchMock) {
+  const originalFetch = globalThis.fetch;
+
+  globalThis.fetch = fetchMock;
+
+  const moduleUrl = pathToFileURL(path.resolve(__dirname, "../frontend/js/store.js")).href;
+  const store = await import(`${moduleUrl}?charts-route-state=${Date.now()}`);
+
+  return {
+    restore() {
+      globalThis.fetch = originalFetch;
+    },
+    store,
+  };
+}
+
+test("charts route preserves the selected chart when returning from another menu", async () => {
+  const { restore, store } = await importStoreWithFetch(createChartsFetchMock());
+
+  try {
+    await store.initializeApp();
+    await store.setRoute({
+      name: "charts",
+      params: { historyId: "10" },
+      path: "/charts/10",
+    });
+
+    assert.equal(store.getState().charts.selectedHistoryId, 10);
+    assert.equal(store.getState().charts.detail?.item?.id, 10);
+
+    await store.setRoute({
+      name: "overview",
+      params: {},
+      path: "/overview",
+    });
+    await store.setRoute({
+      name: "charts",
+      params: { historyId: null },
+      path: "/charts",
+    });
+
+    assert.equal(store.getState().charts.selectedHistoryId, 10);
+    assert.equal(store.getState().charts.detail?.item?.id, 10);
+  } finally {
+    restore();
+  }
+});

package/tests/cli-service-delegation.test.js

@@ -41,3 +41,100 @@ test("CLI delegates database operations to the shared command service", async ()
   ]);
   assert.match(output.join("\n"), /companies/);
 });
+
+test("CLI marks raw query executions as cli", async () => {
+  const calls = [];
+  const connection = {
+    id: "db-one",
+    label: "Database One",
+  };
+  const databaseService = {
+    getDatabase(reference) {
+      calls.push(["getDatabase", reference]);
+      return connection;
+    },
+    listDatabases() {
+      calls.push(["listDatabases"]);
+      return [connection];
+    },
+    executeRawQuery(reference, sql, options = {}) {
+      calls.push(["executeRawQuery", reference, sql, options]);
+      return {
+        result: {
+          statementCount: 1,
+          timingMs: 1,
+          statements: [],
+          historyId: 7,
+        },
+        storedQuery: null,
+      };
+    },
+  };
+  const output = [];
+  const originalLog = console.log;
+
+  console.log = (...values) => output.push(values.join(" "));
+
+  try {
+    await main(["--database:Database One", "--query:SELECT 1"], { databaseService });
+  } finally {
+    console.log = originalLog;
+  }
+
+  assert.deepEqual(calls, [
+    ["listDatabases"],
+    ["getDatabase", "Database One"],
+    ["executeRawQuery", "db-one", "SELECT 1", { storeName: null, executedBy: "cli" }],
+  ]);
+  assert.match(output.join("\n"), /History ID: 7/);
+});
+
+test("CLI marks saved query executions as cli", async () => {
+  const calls = [];
+  const connection = {
+    id: "db-one",
+    label: "Database One",
+  };
+  const databaseService = {
+    getDatabase(reference) {
+      calls.push(["getDatabase", reference]);
+      return connection;
+    },
+    listDatabases() {
+      calls.push(["listDatabases"]);
+      return [connection];
+    },
+    executeSavedQuery(reference, queryName, options = {}) {
+      calls.push(["executeSavedQuery", reference, queryName, options]);
+      return {
+        query: {
+          title: queryName,
+          rawSql: "SELECT 1",
+        },
+        result: {
+          statementCount: 1,
+          timingMs: 1,
+          statements: [],
+          historyId: 8,
+        },
+      };
+    },
+  };
+  const output = [];
+  const originalLog = console.log;
+
+  console.log = (...values) => output.push(values.join(" "));
+
+  try {
+    await main(["--database:Database One", "--execute:Hype-Reversal"], { databaseService });
+  } finally {
+    console.log = originalLog;
+  }
+
+  assert.deepEqual(calls, [
+    ["listDatabases"],
+    ["getDatabase", "Database One"],
+    ["executeSavedQuery", "db-one", "Hype-Reversal", { executedBy: "cli" }],
+  ]);
+  assert.match(output.join("\n"), /Executing: Hype-Reversal/);
+});

package/tests/connection-removal.test.js

@@ -0,0 +1,52 @@
+const assert = require("node:assert/strict");
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+const test = require("node:test");
+
+const { ConnectionManager } = require("../server/services/sqlite/connectionManager");
+const { AppStateStore } = require("../server/services/storage/appStateStore");
+
+function createStore(t) {
+  const directory = fs.mkdtempSync(path.join(os.tmpdir(), "sqlite-hub-connection-remove-"));
+  const store = new AppStateStore(path.join(directory, "state.db"));
+
+  t.after(() => {
+    store.db.close();
+    fs.rmSync(directory, { recursive: true, force: true });
+  });
+
+  return { directory, store };
+}
+
+test("removing a recent connection does not require legacy sql_history", (t) => {
+  const { directory, store } = createStore(t);
+  const firstConnection = {
+    id: "db-one",
+    label: "One",
+    path: path.join(directory, "one.db"),
+    lastOpenedAt: "2026-06-21T10:00:00.000Z",
+    lastModifiedAt: null,
+    sizeBytes: 0,
+    readOnly: false,
+    logoPath: null,
+  };
+  const secondConnection = {
+    ...firstConnection,
+    id: "db-two",
+    label: "Two",
+    path: path.join(directory, "two.db"),
+  };
+  const manager = new ConnectionManager({ appStateStore: store });
+
+  store.upsertRecentConnection(firstConnection);
+  store.upsertRecentConnection(secondConnection, { makeActive: false });
+  store.db.exec("DROP TABLE sql_history");
+
+  const remaining = manager.removeRecentConnection(firstConnection.id);
+
+  assert.deepEqual(
+    remaining.map((connection) => connection.id),
+    ["db-two"]
+  );
+});

package/tests/database-command-service.test.js

@@ -59,6 +59,29 @@ function createFixture(t, options = {}) {
       new Date().toISOString(),
       new Date().toISOString()
     );
+  store.db
+    .prepare(
+      `
+        INSERT INTO query_history (
+          database_key,
+          normalized_sql,
+          raw_sql,
+          query_type,
+          tables_detected,
+          is_saved,
+          first_executed_at,
+          last_used_at
+        )
+        VALUES (?, ?, ?, 'other', '[]', 0, ?, ?)
+      `
+    )
+    .run(
+      connection.id,
+      "company list",
+      "Company List",
+      new Date().toISOString(),
+      new Date().toISOString()
+    );
   store.createDatabaseDocument(connection.id, {
     filename: "Readme.md",
     content: "# Sample\n",
@@ -77,7 +100,7 @@ function createFixture(t, options = {}) {
 }
 
 test("database command service provides shared CLI and API operations", (t) => {
-  const { connection, service } = createFixture(t);
+  const { connection, service, store } = createFixture(t);
 
   assert.equal(service.getDatabase("sample").id, connection.id);
   assert.deepEqual(service.listTables(connection.id), [{ name: "companies", columnCount: 2 }]);
@@ -89,10 +112,18 @@ test("database command service provides shared CLI and API operations", (t) => {
 
   const queries = service.listSavedQueries(connection.id);
   assert.equal(queries.total, 1);
-  assert.equal(service.getSavedQuery(connection.id, "Company List").notes, "Used by CLI and API");
+  const savedQuery = service.getSavedQuery(connection.id, "Company List");
+  assert.equal(savedQuery.notes, "Used by CLI and API");
+  assert.equal(savedQuery.rawSql, "SELECT id, name FROM companies ORDER BY id");
 
   const execution = service.executeSavedQuery(connection.id, "Company List");
   assert.equal(execution.result.statements[0].rowCount, 2);
+  assert.equal(execution.result.historyId, savedQuery.id);
+
+  const savedRun = store.db
+    .prepare("SELECT executed_by, status FROM query_runs WHERE history_id = ? ORDER BY id DESC LIMIT 1")
+    .get(savedQuery.id);
+  assert.deepEqual(savedRun, { executed_by: "user", status: "success" });
 
   const exported = service.exportSavedQuery(connection.id, "Company List", "csv");
   assert.equal(exported.result.rowCount, 2);
@@ -118,6 +149,9 @@ test("raw query execution writes SQL Editor query history", (t) => {
   const historyRow = store.db
     .prepare("SELECT raw_sql, query_type, title, is_saved FROM query_history WHERE id = ?")
     .get(result.historyId);
+  const runRow = store.db
+    .prepare("SELECT executed_by FROM query_runs WHERE history_id = ? ORDER BY id DESC LIMIT 1")
+    .get(result.historyId);
 
   assert.equal(result.affectedRowCount, 1);
   assert.equal(afterCount, beforeCount + 1);
@@ -125,6 +159,7 @@ test("raw query execution writes SQL Editor query history", (t) => {
   assert.equal(historyRow.query_type, "insert");
   assert.equal(historyRow.title, "Add Initech");
   assert.equal(historyRow.is_saved, 1);
+  assert.equal(runRow.executed_by, "user");
   assert.equal(storedQuery.title, "Add Initech");
   assert.equal(storedQuery.isSaved, true);
 });