sqlite-hub 1.0.0 → 1.1.0

package/tests/export-blob.test.js

@@ -1,10 +1,29 @@
 const Database = require("better-sqlite3");
 const assert = require("node:assert/strict");
+const parquet = require("parquetjs-lite");
 const test = require("node:test");
 const { ExportService } = require("../server/services/sqlite/exportService");
 const { SqlExecutor } = require("../server/services/sqlite/sqlExecutor");
 
-test("query and table exports include complete BLOB data", () => {
+async function readParquetRows(buffer) {
+  const reader = await parquet.ParquetReader.openBuffer(buffer);
+  const cursor = reader.getCursor();
+  const rows = [];
+
+  try {
+    let row;
+
+    while ((row = await cursor.next())) {
+      rows.push(row);
+    }
+  } finally {
+    await reader.close();
+  }
+
+  return rows;
+}
+
+test("query and table exports include complete BLOB data", async () => {
   const db = new Database(":memory:");
   const blob = Buffer.from(Array.from({ length: 100 }, (_, index) => index));
 
@@ -33,13 +52,47 @@ test("query and table exports include complete BLOB data", () => {
       "SELECT payload FROM files ORDER BY id",
       { format: "csv" }
     );
+    const queryJsonExport = exportService.exportQuery(
+      "SELECT payload FROM files ORDER BY id",
+      { format: "json" }
+    );
     const tableExport = exportService.exportTable("files", { format: "tsv" });
+    const jsonExport = exportService.exportTable("files", { format: "json" });
+    const queryParquetExport = await exportService.exportQueryDownload(
+      "SELECT id, payload FROM files ORDER BY id",
+      { format: "parquet" }
+    );
+    const tableParquetExport = await exportService.exportTableDownload("files", { format: "parquet" });
 
     for (const content of [queryExport.content, tableExport.content]) {
       assert.equal(content.includes(expectedBase64), true);
       assert.match(content, /""encoding"":""base64""/);
       assert.doesNotMatch(content, /base64Preview|hexPreview/);
     }
+
+    assert.equal(jsonExport.mimeType, "application/json; charset=utf-8");
+    assert.equal(jsonExport.filename, "files.json");
+
+    const [queryJsonRow] = JSON.parse(queryJsonExport.content);
+    const [jsonRow] = JSON.parse(jsonExport.content);
+    assert.equal(queryJsonExport.mimeType, "application/json; charset=utf-8");
+    assert.equal(queryJsonRow.payload.encoding, "base64");
+    assert.equal(queryJsonRow.payload.data, expectedBase64);
+    assert.equal(jsonRow.payload.encoding, "base64");
+    assert.equal(jsonRow.payload.data, expectedBase64);
+    assert.equal(jsonRow.payload.sizeBytes, blob.length);
+    assert.equal(jsonExport.content.includes("base64Preview"), false);
+    assert.equal(jsonExport.content.includes("hexPreview"), false);
+
+    assert.equal(queryParquetExport.mimeType, "application/vnd.apache.parquet");
+    assert.equal(queryParquetExport.filename.endsWith(".parquet"), true);
+    assert.equal(Buffer.isBuffer(queryParquetExport.content), true);
+    assert.equal(tableParquetExport.filename, "files.parquet");
+
+    const [queryParquetRow] = await readParquetRows(queryParquetExport.content);
+    const [tableParquetRow] = await readParquetRows(tableParquetExport.content);
+    assert.equal(queryParquetRow.payload.equals(blob), true);
+    assert.equal(tableParquetRow.payload.equals(blob), true);
   } finally {
     db.close();
   }

package/tests/export-filenames.test.js

@@ -24,6 +24,8 @@ test("text export filenames use the selected format extension", async () => {
 
   assert.equal(buildTextExportFilename("query-results.csv", { format: "tsv" }), "query-results.tsv");
   assert.equal(buildTextExportFilename("white_house_live_streams", { format: "md" }), "white_house_live_streams.md");
+  assert.equal(buildTextExportFilename("companies.tsv", { format: "json" }), "companies.json");
+  assert.equal(buildTextExportFilename("companies.json", { format: "parquet" }), "companies.parquet");
 });
 
 test("text export filenames sanitize unsafe names and fallback when empty", async () => {
@@ -31,4 +33,6 @@ test("text export filenames sanitize unsafe names and fallback when empty", asyn
 
   assert.equal(buildTextExportFilename("", { format: "csv", fallback: "table" }), "table.csv");
   assert.equal(buildTextExportFilename("../bad:name?.csv", { format: "csv", fallback: "table" }), "bad name.csv");
+  assert.equal(buildTextExportFilename("bad:name?.json", { format: "json", fallback: "table" }), "bad name.json");
+  assert.equal(buildTextExportFilename("bad:name?.parquet", { format: "parquet", fallback: "table" }), "bad name.parquet");
 });

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

@@ -35,7 +35,20 @@ test("settings routes create and delete tokens for the active database", async (
   app.use(express.json());
   app.use(
     "/api/settings",
-    createSettingsRouter({ appStateStore: store, connectionManager, tokenService })
+    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);
 
@@ -73,4 +86,12 @@ test("settings routes create and delete tokens for the active database", async (
   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,11 +29,39 @@ 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({