sqlite-hub 0.17.2 → 1.1.0

package/tests/native-file-dialog.test.js

@@ -3,6 +3,8 @@ const test = require("node:test");
 const {
   NativeFileDialogService,
   buildDialogAttempts,
+  buildOpenDialogAttempts,
+  normalizeOpenedDatabasePath,
   normalizeSelectedDatabasePath,
 } = require("../server/services/nativeFileDialogService");
 
@@ -24,6 +26,21 @@ test("native database dialog builds platform-specific save commands", () => {
   assert.deepEqual(linuxAttempts.map((attempt) => attempt.command), ["zenity", "kdialog"]);
 });
 
+test("native database dialog builds platform-specific open commands", () => {
+  const macAttempt = buildOpenDialogAttempts({ platform: "darwin", homeDirectory: "/Users/test" })[0];
+  const windowsAttempt = buildOpenDialogAttempts({ platform: "win32", homeDirectory: "C:\\Users\\test" })[0];
+  const linuxAttempts = buildOpenDialogAttempts({ platform: "linux", homeDirectory: "/home/test" });
+
+  assert.match(macAttempt.args.join(" "), /choose file with prompt/);
+  assert.match(windowsAttempt.args.at(-1), /OpenFileDialog/);
+  assert.deepEqual(linuxAttempts.map((attempt) => attempt.command), ["zenity", "kdialog"]);
+});
+
+test("open database dialog preserves the selected filename", () => {
+  assert.equal(normalizeOpenedDatabasePath("/tmp/catalog\n"), "/tmp/catalog");
+  assert.equal(normalizeOpenedDatabasePath(""), null);
+});
+
 test("native database dialog returns null when the user cancels", async () => {
   const service = new NativeFileDialogService({
     platform: "darwin",
@@ -76,3 +93,13 @@ test("native database dialog falls back from zenity to kdialog", async () => {
   assert.equal(await service.chooseCreateDatabasePath(), "/home/test/catalog.sqlite3");
   assert.deepEqual(commands, ["zenity", "kdialog"]);
 });
+
+test("native open database dialog returns the selected existing path", async () => {
+  const service = new NativeFileDialogService({
+    platform: "linux",
+    homeDirectory: "/home/test",
+    executeFile: async () => ({ stdout: "/home/test/catalog.db\n" }),
+  });
+
+  assert.equal(await service.chooseOpenDatabasePath(), "/home/test/catalog.db");
+});

package/tests/settings-api-tokens-route.test.js

@@ -0,0 +1,97 @@
+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 { createSettingsRouter } = require("../server/routes/settings");
+const { ApiTokenService } = require("../server/services/apiTokenService");
+const { AppStateStore } = require("../server/services/storage/appStateStore");
+const { errorMiddleware } = require("../server/utils/errors");
+
+test("settings routes create and delete tokens for the active database", async (t) => {
+  const directory = fs.mkdtempSync(path.join(os.tmpdir(), "sqlite-hub-settings-token-"));
+  const store = new AppStateStore(path.join(directory, "state.db"));
+  const connection = {
+    id: "db-active",
+    label: "Active Database",
+    path: path.join(directory, "active.db"),
+    lastOpenedAt: new Date().toISOString(),
+    lastModifiedAt: new Date().toISOString(),
+    sizeBytes: 0,
+    readOnly: false,
+    logoPath: null,
+  };
+
+  store.upsertRecentConnection(connection);
+
+  const tokenService = new ApiTokenService({ appStateStore: store });
+  const connectionManager = {
+    getActiveConnection: () => connection,
+  };
+  const app = express();
+
+  app.use(express.json());
+  app.use(
+    "/api/settings",
+    createSettingsRouter({
+      appStateStore: store,
+      connectionManager,
+      tokenService,
+      versionCheckService: async () => ({
+        packageName: "sqlite-hub",
+        currentVersion: "1.0.1",
+        latestVersion: "1.1.0",
+        updateAvailable: true,
+        checkedAt: "2026-06-19T20:00:00.000Z",
+        source: "npm",
+        releaseUrl: "https://www.npmjs.com/package/sqlite-hub/v/1.1.0",
+      }),
+    })
+  );
+  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 });
+  });
+
+  const baseUrl = `http://127.0.0.1:${server.address().port}/api/settings`;
+  const createResponse = await fetch(`${baseUrl}/api-tokens`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ name: "Settings token" }),
+  });
+  const created = await createResponse.json();
+
+  assert.equal(createResponse.status, 201);
+  assert.equal(created.data.databaseKey, connection.id);
+  assert.match(created.data.token, /^shub_/);
+  assert.equal(created.metadata.apiTokens.length, 1);
+  assert.equal(created.metadata.apiTokens[0].token, undefined);
+
+  const deleteResponse = await fetch(`${baseUrl}/api-tokens/${created.data.id}`, {
+    method: "DELETE",
+  });
+  const deleted = await deleteResponse.json();
+
+  assert.equal(deleteResponse.status, 200);
+  assert.deepEqual(deleted.data, { id: created.data.id, deleted: true });
+  assert.equal(deleted.metadata.apiTokens.length, 0);
+
+  const versionResponse = await fetch(`${baseUrl}/version-check`);
+  const versionCheck = await versionResponse.json();
+
+  assert.equal(versionResponse.status, 200);
+  assert.equal(versionCheck.data.latestVersion, "1.1.0");
+  assert.equal(versionCheck.data.updateAvailable, true);
+  assert.equal(versionCheck.metadata.appVersion, require("../package.json").version);
+});

package/tests/settings-metadata.test.js

@@ -2,7 +2,14 @@ const assert = require("node:assert/strict");
 const test = require("node:test");
 
 const { version } = require("../package.json");
-const { readSettingsMetadata, readSqliteVersion } = require("../server/routes/settings");
+const {
+  checkLatestAppVersion,
+  compareSemver,
+  isNewerVersion,
+  readSettingsMetadata,
+  readSqliteVersion,
+} = require("../server/routes/settings");
+const { buildAppInfo } = require("../server/services/appInfoService");
 
 test("settings metadata exposes app and SQLite versions", () => {
   const metadata = readSettingsMetadata();
@@ -14,3 +21,94 @@ test("settings metadata exposes app and SQLite versions", () => {
 test("SQLite runtime version is readable", () => {
   assert.match(readSqliteVersion(), /^\d+\.\d+\.\d+$/);
 });
+
+test("settings version comparison detects newer releases", () => {
+  assert.equal(compareSemver("1.2.0", "1.1.9"), 1);
+  assert.equal(compareSemver("1.0.1", "1.0.1"), 0);
+  assert.equal(compareSemver("1.0.0", "1.0.1"), -1);
+  assert.equal(isNewerVersion("1.0.2", "1.0.1"), true);
+  assert.equal(isNewerVersion("1.0.1", "1.0.1"), false);
+});
+
+test("settings version check reads the npm latest version", async () => {
+  const result = await checkLatestAppVersion({
+    currentVersion: "1.0.1",
+    packageName: "sqlite-hub",
+    fetchImpl: async (url, options) => {
+      assert.equal(url, "https://registry.npmjs.org/sqlite-hub/latest");
+      assert.equal(options.headers.Accept, "application/json");
+
+      return {
+        ok: true,
+        json: async () => ({ version: "1.1.0" }),
+      };
+    },
+  });
+
+  assert.equal(result.packageName, "sqlite-hub");
+  assert.equal(result.currentVersion, "1.0.1");
+  assert.equal(result.latestVersion, "1.1.0");
+  assert.equal(result.updateAvailable, true);
+  assert.equal(result.source, "npm");
+  assert.equal(result.releaseUrl, "https://www.npmjs.com/package/sqlite-hub/v/1.1.0");
+  assert.match(result.checkedAt, /^\d{4}-\d{2}-\d{2}T/);
+});
+
+test("app info includes update status for CLI and API consumers", async () => {
+  const info = await buildAppInfo({
+    port: 4173,
+    url: "http://127.0.0.1:4173",
+    currentVersion: "1.0.1",
+    sqliteVersion: "3.50.0",
+    versionCheckService: async () => ({
+      packageName: "sqlite-hub",
+      currentVersion: "1.0.1",
+      latestVersion: "1.1.0",
+      updateAvailable: true,
+      checkedAt: "2026-06-20T10:00:00.000Z",
+      source: "npm",
+      releaseUrl: "https://www.npmjs.com/package/sqlite-hub/v/1.1.0",
+    }),
+  });
+
+  assert.equal(info.packageName, "sqlite-hub");
+  assert.equal(info.appVersion, "1.0.1");
+  assert.equal(info.sqliteVersion, "3.50.0");
+  assert.equal(info.port, 4173);
+  assert.equal(info.url, "http://127.0.0.1:4173");
+  assert.equal(info.versionCheck.status, "update_available");
+  assert.equal(info.versionCheck.updateAvailable, true);
+});
+
+test("app info reports unknown version status when registry lookup fails", async () => {
+  const info = await buildAppInfo({
+    currentVersion: "1.0.1",
+    sqliteVersion: "3.50.0",
+    versionCheckService: async () => {
+      throw new Error("offline");
+    },
+  });
+
+  assert.equal(info.versionCheck.status, "unknown");
+  assert.equal(info.versionCheck.updateAvailable, null);
+  assert.equal(info.versionCheck.error.message, "offline");
+});
+
+test("app info marks local builds newer than npm latest as ahead", async () => {
+  const info = await buildAppInfo({
+    currentVersion: "1.1.0",
+    sqliteVersion: "3.50.0",
+    versionCheckService: async () => ({
+      packageName: "sqlite-hub",
+      currentVersion: "1.1.0",
+      latestVersion: "1.0.0",
+      updateAvailable: false,
+      checkedAt: "2026-06-20T10:00:00.000Z",
+      source: "npm",
+      releaseUrl: "https://www.npmjs.com/package/sqlite-hub/v/1.0.0",
+    }),
+  });
+
+  assert.equal(info.versionCheck.status, "ahead");
+  assert.equal(info.versionCheck.updateAvailable, false);
+});

package/tests/settings-view.test.js

@@ -29,4 +29,79 @@ test("settings view shows SQLite runtime version and custom port command", async
   assert.match(rendered.main, /SQLite_Runtime/);
   assert.match(rendered.main, /3\.53\.1/);
   assert.match(rendered.main, /sqlite-hub --port:PORT/);
+  assert.match(rendered.main, /Version_Check/);
+  assert.match(rendered.main, /data-action="check-app-version"/);
+  assert.match(rendered.main, /Check Updates/);
+  assert.match(rendered.main, /No version check has been run yet\./);
+  assert.match(rendered.main, /data-section="information"/);
+  assert.match(rendered.main, /data-section="api-tokens"/);
+  assert.doesNotMatch(rendered.main, /data-form="create-api-token"/);
+});
+
+test("settings view shows available app updates", async () => {
+  const { renderSettingsView } = await loadSettingsViewModule();
+  const rendered = renderSettingsView({
+    settings: {
+      loading: false,
+      error: null,
+      appVersion: "1.0.1",
+      sqliteVersion: "3.53.1",
+      versionCheckLoading: false,
+      versionCheckError: null,
+      versionCheck: {
+        currentVersion: "1.0.1",
+        latestVersion: "1.1.0",
+        updateAvailable: true,
+        releaseUrl: "https://www.npmjs.com/package/sqlite-hub/v/1.1.0",
+      },
+    },
+  });
+
+  assert.match(rendered.main, /New Version Available/);
+  assert.match(rendered.main, /Current v1\.0\.1 · Latest v1\.1\.0/);
+  assert.match(rendered.main, /Open Release/);
+});
+
+test("settings view scopes API token controls to the active database", async () => {
+  const { renderSettingsView } = await loadSettingsViewModule();
+  const rendered = renderSettingsView({
+    settings: {
+      loading: false,
+      error: null,
+      appVersion: "1.2.3",
+      sqliteVersion: "3.53.1",
+      section: "api-tokens",
+      tokenDatabase: { id: "db-one", label: "Database One" },
+      apiTokens: [
+        {
+          id: "token-one",
+          name: "Automation",
+          tokenPrefix: "shub_example",
+          createdAt: "2026-06-15T10:00:00.000Z",
+        },
+      ],
+      createdApiToken: null,
+      tokenSaving: false,
+    },
+  });
+
+  assert.match(rendered.main, /API Tokens/);
+  assert.match(rendered.main, /Security \/\/ Database API access/);
+  assert.match(rendered.main, /Database One/);
+  assert.match(rendered.main, /Database ID/);
+  assert.match(rendered.main, /data-database-id/);
+  assert.match(rendered.main, /data-action="copy-database-id"/);
+  assert.match(rendered.main, /Copy ID/);
+  assert.match(rendered.main, /sm:grid-cols-\[minmax\(0,1fr\)_9rem\]/);
+  assert.equal((rendered.main.match(/w-full self-center justify-center/g) ?? []).length, 2);
+  assert.match(rendered.main, /shub_example\.\.\./);
+  assert.match(rendered.main, /data-api-token-name/);
+  assert.match(rendered.main, /data-form="create-api-token"/);
+  assert.match(rendered.main, /name="name"/);
+  assert.match(rendered.main, /type="submit"/);
+  assert.match(rendered.main, /data-action="open-delete-api-token-modal"/);
+  assert.match(rendered.main, /bg-surface-container-lowest/);
+  assert.doesNotMatch(rendered.main, /sqlite-hub --port:PORT/);
+  assert.doesNotMatch(rendered.main, /Open Github/);
+  assert.doesNotMatch(rendered.main, /token_hash/);
 });