sqlite-hub 1.1.2 → 1.4.0

package/.github/workflows/ci.yml

@@ -1,36 +0,0 @@
-name: CI
-
-on:
-    pull_request:
-    push:
-        branches:
-            - main
-
-permissions:
-    contents: read
-
-jobs:
-    build-test-audit:
-        runs-on: ubuntu-latest
-
-        steps:
-            - name: Checkout
-              uses: actions/checkout@v4
-
-            - name: Setup Node
-              uses: actions/setup-node@v4
-              with:
-                  node-version: 26
-                  cache: npm
-
-            - name: Install dependencies
-              run: npm ci
-
-            - name: Build
-              run: npm run build
-
-            - name: Test
-              run: npm test
-
-            - name: Dependency audit
-              run: npm run audit

package/tests/api-token-auth.test.js

@@ -1,279 +0,0 @@
-const assert = require("node:assert/strict");
-const express = require("express");
-const fs = require("node:fs");
-const os = require("node:os");
-const path = require("node:path");
-const test = require("node:test");
-
-const { createExternalApiRouter } = require("../server/routes/externalApi");
-const { ApiTokenService } = require("../server/services/apiTokenService");
-const { AppStateStore } = require("../server/services/storage/appStateStore");
-const { ReadOnlyError } = require("../server/utils/errors");
-const { errorMiddleware } = require("../server/utils/errors");
-
-function createConnection(id, label, databasePath) {
-  return {
-    id,
-    label,
-    path: databasePath,
-    lastOpenedAt: new Date().toISOString(),
-    lastModifiedAt: new Date().toISOString(),
-    sizeBytes: 0,
-    readOnly: false,
-    logoPath: null,
-  };
-}
-
-async function startApi(t) {
-  const directory = fs.mkdtempSync(path.join(os.tmpdir(), "sqlite-hub-api-token-"));
-  const store = new AppStateStore(path.join(directory, "state.db"));
-  const databaseA = createConnection("db-a", "Database A", path.join(directory, "a.db"));
-  const databaseB = createConnection("db-b", "Database B", path.join(directory, "b.db"));
-
-  store.upsertRecentConnection(databaseA);
-  store.upsertRecentConnection(databaseB, { makeActive: false });
-
-  const tokenService = new ApiTokenService({ appStateStore: store });
-  const serviceCalls = [];
-  const databaseService = {
-    listTables(databaseId) {
-      serviceCalls.push(databaseId);
-      return [{ name: "companies" }];
-    },
-    executeRawQuery(databaseId, sql, options = {}) {
-      serviceCalls.push(
-        `${databaseId}:query:${sql}:${options.storeName ?? ""}:${options.executedBy ?? ""}`
-      );
-      if (sql === "READONLY") {
-        throw new ReadOnlyError("Cannot execute raw SQL against a read-only database.");
-      }
-      return {
-        result: {
-          sql,
-          statementCount: 1,
-          statements: [],
-          rows: [],
-          columns: [],
-          affectedRowCount: 0,
-          resultKind: "unknown",
-          timingMs: 2,
-          historyId: 42,
-          storedQuery: options.storeName
-            ? {
-                id: 42,
-                title: options.storeName,
-                isSaved: true,
-              }
-            : null,
-        },
-      };
-    },
-    executeSavedQuery(databaseId, queryName, options = {}) {
-      serviceCalls.push(`${databaseId}:saved:${queryName}:${options.executedBy ?? ""}`);
-      return {
-        query: {
-          id: 7,
-          title: queryName,
-          rawSql: "SELECT 1",
-        },
-        result: {
-          sql: "SELECT 1",
-          statementCount: 1,
-          statements: [],
-          rows: [],
-          columns: [],
-          affectedRowCount: 0,
-          resultKind: "resultSet",
-          timingMs: 3,
-          historyId: 7,
-        },
-      };
-    },
-  };
-  const app = express();
-
-  app.use(express.json());
-  app.use(
-    "/api/v1",
-    createExternalApiRouter({
-      databaseService,
-      tokenService,
-      appInfoService: async ({ port, url }) => ({
-        packageName: "sqlite-hub",
-        appVersion: "1.0.1",
-        sqliteVersion: "3.50.0",
-        port,
-        url,
-        versionCheck: {
-          packageName: "sqlite-hub",
-          currentVersion: "1.0.1",
-          latestVersion: "1.0.1",
-          updateAvailable: false,
-          checkedAt: "2026-06-20T10:00:00.000Z",
-          source: "npm",
-          releaseUrl: "https://www.npmjs.com/package/sqlite-hub/v/1.0.1",
-          status: "current",
-        },
-      }),
-    })
-  );
-  app.use(errorMiddleware);
-
-  const server = await new Promise((resolve) => {
-    const listener = app.listen(0, "127.0.0.1", () => resolve(listener));
-  });
-
-  t.after(async () => {
-    await new Promise((resolve, reject) => {
-      server.close((error) => (error ? reject(error) : resolve()));
-    });
-    store.db.close();
-    fs.rmSync(directory, { recursive: true, force: true });
-  });
-
-  return {
-    baseUrl: `http://127.0.0.1:${server.address().port}/api/v1`,
-    databaseA,
-    databaseB,
-    serviceCalls,
-    store,
-    tokenService,
-  };
-}
-
-test("tokens are hashed, deletable, and isolated per database", async (t) => {
-  const fixture = await startApi(t);
-  const created = fixture.tokenService.createToken(fixture.databaseA.id, "Automation");
-
-  assert.match(created.token, /^shub_[A-Za-z0-9_-]+$/);
-  assert.equal(fixture.tokenService.listTokens(fixture.databaseA.id)[0].token, undefined);
-
-  const stored = fixture.store.db
-    .prepare("SELECT token_hash, token_prefix FROM api_tokens WHERE id = ?")
-    .get(created.id);
-
-  assert.notEqual(stored.token_hash, created.token);
-  assert.equal(stored.token_prefix, created.tokenPrefix);
-  assert.equal(fixture.tokenService.authenticate(fixture.databaseA.id, created.token).id, created.id);
-  assert.throws(
-    () => fixture.tokenService.authenticate(fixture.databaseB.id, created.token),
-    /invalid for this database/
-  );
-
-  const validResponse = await fetch(
-    `${fixture.baseUrl}/databases/${fixture.databaseA.id}/tables`,
-    { headers: { Authorization: `Bearer ${created.token}` } }
-  );
-  const validPayload = await validResponse.json();
-
-  assert.equal(validResponse.status, 200);
-  assert.deepEqual(validPayload.data.items, [{ name: "companies" }]);
-  assert.deepEqual(fixture.serviceCalls, [fixture.databaseA.id]);
-
-  const invalidResponse = await fetch(
-    `${fixture.baseUrl}/databases/${fixture.databaseA.id}/tables`,
-    { headers: { Authorization: "Bearer invalid" } }
-  );
-  assert.equal(invalidResponse.status, 401);
-
-  const missingResponse = await fetch(
-    `${fixture.baseUrl}/databases/${fixture.databaseA.id}/tables`
-  );
-  assert.equal(missingResponse.status, 401);
-
-  const wrongDatabaseResponse = await fetch(
-    `${fixture.baseUrl}/databases/${fixture.databaseB.id}/tables`,
-    { headers: { Authorization: `Bearer ${created.token}` } }
-  );
-  assert.equal(wrongDatabaseResponse.status, 401);
-  assert.deepEqual(fixture.serviceCalls, [fixture.databaseA.id]);
-
-  fixture.tokenService.deleteToken(fixture.databaseA.id, created.id);
-  assert.equal(fixture.tokenService.listTokens(fixture.databaseA.id).length, 0);
-  assert.throws(
-    () => fixture.tokenService.authenticate(fixture.databaseA.id, created.token),
-    /invalid for this database/
-  );
-});
-
-test("public API info returns app and version status without a token", async (t) => {
-  const fixture = await startApi(t);
-  const response = await fetch(`${fixture.baseUrl}/info`);
-  const payload = await response.json();
-
-  assert.equal(response.status, 200);
-  assert.equal(payload.data.packageName, "sqlite-hub");
-  assert.equal(payload.data.appVersion, "1.0.1");
-  assert.equal(payload.data.sqliteVersion, "3.50.0");
-  assert.equal(payload.data.versionCheck.status, "current");
-  assert.equal(payload.data.versionCheck.updateAvailable, false);
-  assert.match(payload.data.url, /^http:\/\/127\.0\.0\.1:\d+$/);
-});
-
-test("query API executes raw SQL with a database token", async (t) => {
-  const fixture = await startApi(t);
-  const created = fixture.tokenService.createToken(fixture.databaseA.id, "Automation");
-  const response = await fetch(`${fixture.baseUrl}/query`, {
-    method: "POST",
-    headers: {
-      Authorization: `Bearer ${created.token}`,
-      "Content-Type": "application/json",
-    },
-    body: JSON.stringify({
-      databaseId: fixture.databaseA.id,
-      sql: "SELECT 1",
-      store: "Stored API Query",
-    }),
-  });
-  const payload = await response.json();
-
-  assert.equal(response.status, 200);
-  assert.equal(payload.data.sql, "SELECT 1");
-  assert.equal(payload.data.historyId, 42);
-  assert.equal(payload.data.storedQuery.title, "Stored API Query");
-  assert.equal(payload.metadata.stored, true);
-  assert.equal(payload.metadata.databaseId, fixture.databaseA.id);
-  assert.deepEqual(fixture.serviceCalls, [
-    `${fixture.databaseA.id}:query:SELECT 1:Stored API Query:api`,
-  ]);
-});
-
-test("query API rejects read-only raw SQL execution", async (t) => {
-  const fixture = await startApi(t);
-  const created = fixture.tokenService.createToken(fixture.databaseA.id, "Automation");
-  const response = await fetch(`${fixture.baseUrl}/query`, {
-    method: "POST",
-    headers: {
-      Authorization: `Bearer ${created.token}`,
-      "Content-Type": "application/json",
-    },
-    body: JSON.stringify({
-      databaseId: fixture.databaseA.id,
-      sql: "READONLY",
-    }),
-  });
-  const payload = await response.json();
-
-  assert.equal(response.status, 403);
-  assert.equal(payload.error.code, "SQLITE_READONLY");
-});
-
-test("saved query API records executions as api", async (t) => {
-  const fixture = await startApi(t);
-  const created = fixture.tokenService.createToken(fixture.databaseA.id, "Automation");
-  const response = await fetch(
-    `${fixture.baseUrl}/databases/${fixture.databaseA.id}/queries/Hype-Reversal/execute`,
-    {
-      method: "POST",
-      headers: { Authorization: `Bearer ${created.token}` },
-    }
-  );
-  const payload = await response.json();
-
-  assert.equal(response.status, 200);
-  assert.equal(payload.data.historyId, 7);
-  assert.equal(payload.metadata.query.title, "Hype-Reversal");
-  assert.deepEqual(fixture.serviceCalls, [
-    `${fixture.databaseA.id}:saved:Hype-Reversal:api`,
-  ]);
-});

package/tests/backup-manager.test.js

@@ -1,140 +0,0 @@
-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

@@ -1,64 +0,0 @@
-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",
-            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, /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

@@ -1,60 +0,0 @@
-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();
-  }
-});