sqlite-hub 0.17.0 → 1.0.0

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

@@ -0,0 +1,102 @@
+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 { DatabaseCommandService } = require("../server/services/databaseCommandService");
+const { AppStateStore } = require("../server/services/storage/appStateStore");
+
+function createFixture(t) {
+  const directory = fs.mkdtempSync(path.join(os.tmpdir(), "sqlite-hub-command-service-"));
+  const databasePath = path.join(directory, "sample.db");
+  const targetDb = new Database(databasePath);
+
+  targetDb.exec(`
+    CREATE TABLE companies (id INTEGER PRIMARY KEY, name TEXT NOT NULL);
+    INSERT INTO companies (name) VALUES ('Acme'), ('Globex');
+  `);
+  targetDb.close();
+
+  const store = new AppStateStore(path.join(directory, "state.db"));
+  const connection = {
+    id: "db-sample",
+    label: "Sample",
+    path: databasePath,
+    lastOpenedAt: new Date().toISOString(),
+    lastModifiedAt: new Date().toISOString(),
+    sizeBytes: fs.statSync(databasePath).size,
+    readOnly: false,
+    logoPath: null,
+  };
+
+  store.upsertRecentConnection(connection);
+  store.db
+    .prepare(
+      `
+        INSERT INTO query_history (
+          database_key,
+          normalized_sql,
+          raw_sql,
+          title,
+          notes,
+          query_type,
+          tables_detected,
+          is_saved,
+          first_executed_at,
+          last_used_at
+        )
+        VALUES (?, ?, ?, ?, ?, 'select', '["companies"]', 1, ?, ?)
+      `
+    )
+    .run(
+      connection.id,
+      "select id, name from companies order by id",
+      "SELECT id, name FROM companies ORDER BY id",
+      "Company List",
+      "Used by CLI and API",
+      new Date().toISOString(),
+      new Date().toISOString()
+    );
+  store.createDatabaseDocument(connection.id, {
+    filename: "Readme.md",
+    content: "# Sample\n",
+  });
+
+  t.after(() => {
+    store.db.close();
+    fs.rmSync(directory, { recursive: true, force: true });
+  });
+
+  return {
+    connection,
+    service: new DatabaseCommandService({ appStateStore: store }),
+  };
+}
+
+test("database command service provides shared CLI and API operations", (t) => {
+  const { connection, service } = createFixture(t);
+
+  assert.equal(service.getDatabase("sample").id, connection.id);
+  assert.deepEqual(service.listTables(connection.id), [{ name: "companies" }]);
+  assert.equal(service.getTable(connection.id, "companies").rowCount, 2);
+
+  const row = service.getTableRow(connection.id, "companies", "1");
+  assert.deepEqual(row.data, { id: 1, name: "Acme" });
+  assert.equal(row.identity.kind, "primaryKey");
+
+  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 execution = service.executeSavedQuery(connection.id, "Company List");
+  assert.equal(execution.result.statements[0].rowCount, 2);
+
+  const exported = service.exportSavedQuery(connection.id, "Company List", "csv");
+  assert.equal(exported.result.rowCount, 2);
+  assert.match(exported.result.content, /Acme/);
+
+  assert.equal(service.listDocuments(connection.id).length, 1);
+  assert.equal(service.getDocument(connection.id, "Readme").content, "# Sample\n");
+});

package/tests/export-blob.test.js

@@ -0,0 +1,46 @@
+const Database = require("better-sqlite3");
+const assert = require("node:assert/strict");
+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", () => {
+  const db = new Database(":memory:");
+  const blob = Buffer.from(Array.from({ length: 100 }, (_, index) => index));
+
+  try {
+    db.exec("CREATE TABLE files (id INTEGER PRIMARY KEY, payload BLOB)");
+    db.prepare("INSERT INTO files (payload) VALUES (?)").run(blob);
+
+    const connection = { id: "blob-export-test", label: "Blob export" };
+    const connectionManager = {
+      getActiveConnection: () => connection,
+      getActiveDatabase: () => db,
+    };
+    const appStateStore = {
+      findQueryHistoryItemBySql: () => null,
+      getSettings: () => ({ csvDelimiter: "," }),
+      recordQueryExecution: () => 1,
+    };
+    const sqlExecutor = new SqlExecutor({ connectionManager, appStateStore });
+    const exportService = new ExportService({
+      appStateStore,
+      connectionManager,
+      sqlExecutor,
+    });
+    const expectedBase64 = blob.toString("base64");
+    const queryExport = exportService.exportQuery(
+      "SELECT payload FROM files ORDER BY id",
+      { format: "csv" }
+    );
+    const tableExport = exportService.exportTable("files", { format: "tsv" });
+
+    for (const content of [queryExport.content, tableExport.content]) {
+      assert.equal(content.includes(expectedBase64), true);
+      assert.match(content, /""encoding"":""base64""/);
+      assert.doesNotMatch(content, /base64Preview|hexPreview/);
+    }
+  } finally {
+    db.close();
+  }
+});

package/tests/form-controls.test.js

@@ -0,0 +1,34 @@
+const assert = require('node:assert/strict');
+const path = require('node:path');
+const { pathToFileURL } = require('node:url');
+const test = require('node:test');
+
+let formControlsModulePromise = null;
+
+function loadFormControlsModule() {
+    if (!formControlsModulePromise) {
+        formControlsModulePromise = import(
+            pathToFileURL(path.resolve(__dirname, '../frontend/js/components/formControls.js')).href
+        );
+    }
+
+    return formControlsModulePromise;
+}
+
+test('standard text input uses the shared application styling', async () => {
+    const { renderTextInput } = await loadFormControlsModule();
+    const markup = renderTextInput({
+        className: 'flex-1',
+        dataAttributes: { tokenName: true },
+        maxlength: 80,
+        placeholder: 'Token name',
+    });
+
+    assert.match(markup, /control-input/);
+    assert.match(markup, /border-outline-variant\/20/);
+    assert.match(markup, /bg-surface-container-lowest/);
+    assert.match(markup, /placeholder:text-on-surface-variant\/35/);
+    assert.match(markup, /focus:border-primary-container/);
+    assert.match(markup, /data-token-name/);
+    assert.match(markup, /maxlength="80"/);
+});

package/tests/json-preview.test.js

@@ -0,0 +1,49 @@
+const assert = require("node:assert/strict");
+const { readFileSync } = require("node:fs");
+const path = require("node:path");
+const test = require("node:test");
+
+let jsonPreviewModulePromise = null;
+
+function loadJsonPreviewModule() {
+  if (!jsonPreviewModulePromise) {
+    const source = readFileSync(
+      path.resolve(__dirname, "../frontend/js/utils/jsonPreview.js"),
+      "utf8"
+    );
+    const url = `data:text/javascript;base64,${Buffer.from(source).toString("base64")}`;
+
+    jsonPreviewModulePromise = import(url);
+  }
+
+  return jsonPreviewModulePromise;
+}
+
+test("JSON preview formats objects and arrays with line breaks and indentation", async () => {
+  const { formatJsonPreview } = await loadJsonPreviewModule();
+
+  assert.equal(
+    formatJsonPreview('{"event":"created","metadata":{"source":"api"}}'),
+    [
+      "{",
+      '  "event": "created",',
+      '  "metadata": {',
+      '    "source": "api"',
+      "  }",
+      "}",
+    ].join("\n")
+  );
+  assert.equal(
+    formatJsonPreview([1, { active: true }]),
+    ["[", "  1,", "  {", '    "active": true', "  }", "]"].join("\n")
+  );
+});
+
+test("JSON preview ignores invalid JSON and scalar values", async () => {
+  const { formatJsonPreview } = await loadJsonPreviewModule();
+
+  assert.equal(formatJsonPreview("plain text"), null);
+  assert.equal(formatJsonPreview("{invalid"), null);
+  assert.equal(formatJsonPreview("42"), null);
+  assert.equal(formatJsonPreview(null), null);
+});

package/tests/local-request-security.test.js

@@ -0,0 +1,85 @@
+const assert = require("node:assert/strict");
+const test = require("node:test");
+const {
+  LOOPBACK_HOST,
+  listenOnLoopback,
+  localRequestSecurity,
+} = require("../server/middleware/localRequestSecurity");
+
+function runMiddleware({ method = "GET", protocol = "http", headers = {} } = {}) {
+  const normalizedHeaders = Object.fromEntries(
+    Object.entries(headers).map(([name, value]) => [name.toLowerCase(), value])
+  );
+  const req = {
+    method,
+    protocol,
+    get(name) {
+      return normalizedHeaders[String(name).toLowerCase()];
+    },
+  };
+
+  return new Promise((resolve) => {
+    localRequestSecurity(req, {}, (error) => resolve(error ?? null));
+  });
+}
+
+test("server listener binds explicitly to the IPv4 loopback address", () => {
+  let receivedArguments = null;
+  const listener = {};
+  const app = {
+    listen(...args) {
+      receivedArguments = args;
+      return listener;
+    },
+  };
+
+  assert.equal(listenOnLoopback(app, 4173), listener);
+  assert.deepEqual(receivedArguments, [4173, LOOPBACK_HOST]);
+});
+
+test("local API security accepts same-origin browser and CLI requests", async () => {
+  assert.equal(
+    await runMiddleware({
+      method: "POST",
+      headers: {
+        host: "127.0.0.1:4173",
+        origin: "http://127.0.0.1:4173",
+        "sec-fetch-site": "same-origin",
+      },
+    }),
+    null
+  );
+  assert.equal(
+    await runMiddleware({
+      method: "POST",
+      headers: { host: "localhost:4173" },
+    }),
+    null
+  );
+});
+
+test("local API security rejects foreign hosts and cross-origin mutations", async () => {
+  const foreignHostError = await runMiddleware({
+    headers: { host: "example.test:4173" },
+  });
+  const crossOriginError = await runMiddleware({
+    method: "POST",
+    headers: {
+      host: "127.0.0.1:4173",
+      origin: "https://example.test",
+      "sec-fetch-site": "cross-site",
+    },
+  });
+  const wrongSchemeError = await runMiddleware({
+    method: "PATCH",
+    headers: {
+      host: "localhost:4173",
+      origin: "https://localhost:4173",
+    },
+  });
+
+  for (const error of [foreignHostError, crossOriginError, wrongSchemeError]) {
+    assert.equal(error?.statusCode, 403);
+    assert.equal(error?.code, "LOCAL_REQUEST_REQUIRED");
+  }
+});

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

@@ -0,0 +1,105 @@
+const assert = require("node:assert/strict");
+const test = require("node:test");
+const {
+  NativeFileDialogService,
+  buildDialogAttempts,
+  buildOpenDialogAttempts,
+  normalizeOpenedDatabasePath,
+  normalizeSelectedDatabasePath,
+} = require("../server/services/nativeFileDialogService");
+
+test("native database dialog normalizes paths and adds a default extension", () => {
+  assert.equal(normalizeSelectedDatabasePath("/tmp/customer-data"), "/tmp/customer-data.sqlite");
+  assert.equal(normalizeSelectedDatabasePath("/tmp/customer-data.db\n"), "/tmp/customer-data.db");
+  assert.equal(normalizeSelectedDatabasePath(""), null);
+});
+
+test("native database dialog builds platform-specific save commands", () => {
+  const macAttempt = buildDialogAttempts({ platform: "darwin", homeDirectory: "/Users/test" })[0];
+  const windowsAttempt = buildDialogAttempts({ platform: "win32", homeDirectory: "C:\\Users\\test" })[0];
+  const linuxAttempts = buildDialogAttempts({ platform: "linux", homeDirectory: "/home/test" });
+
+  assert.equal(macAttempt.command, "osascript");
+  assert.match(macAttempt.args.join(" "), /choose file name/);
+  assert.equal(windowsAttempt.command, "powershell.exe");
+  assert.match(windowsAttempt.args.at(-1), /SaveFileDialog/);
+  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",
+    homeDirectory: "/Users/test",
+    executeFile: async () => {
+      const error = new Error("User canceled.");
+      error.code = 1;
+      throw error;
+    },
+  });
+
+  assert.equal(await service.chooseCreateDatabasePath(), null);
+});
+
+test("native database dialog does not hide macOS script failures as cancellations", async () => {
+  const service = new NativeFileDialogService({
+    platform: "darwin",
+    homeDirectory: "/Users/test",
+    executeFile: async () => {
+      const error = new Error("AppleScript syntax error");
+      error.code = 1;
+      throw error;
+    },
+  });
+
+  await assert.rejects(service.chooseCreateDatabasePath(), (error) => {
+    assert.equal(error.code, "NATIVE_FILE_DIALOG_FAILED");
+    return true;
+  });
+});
+
+test("native database dialog falls back from zenity to kdialog", async () => {
+  const commands = [];
+  const service = new NativeFileDialogService({
+    platform: "linux",
+    homeDirectory: "/home/test",
+    executeFile: async (command) => {
+      commands.push(command);
+
+      if (command === "zenity") {
+        const error = new Error("not found");
+        error.code = "ENOENT";
+        throw error;
+      }
+
+      return { stdout: "/home/test/catalog.sqlite3\n" };
+    },
+  });
+
+  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/query-results-truncation.test.js

@@ -0,0 +1,20 @@
+const assert = require("node:assert/strict");
+const path = require("node:path");
+const test = require("node:test");
+const { pathToFileURL } = require("node:url");
+
+test("query results render an explicit truncation notice", async () => {
+  const moduleUrl = pathToFileURL(
+    path.resolve(__dirname, "../frontend/js/components/queryResults.js")
+  ).href;
+  const { renderQueryResultsPane } = await import(moduleUrl);
+  const html = renderQueryResultsPane({
+    columns: ["id"],
+    rows: [{ id: 1 }, { id: 2 }],
+    truncated: true,
+    rowLimit: 2,
+  });
+
+  assert.match(html, /Showing the first 2 rows/);
+  assert.match(html, /export it to process the complete result set/);
+});

package/tests/row-editor-null-values.test.js

@@ -0,0 +1,131 @@
+const Database = require("better-sqlite3");
+const assert = require("node:assert/strict");
+const path = require("node:path");
+const test = require("node:test");
+const { pathToFileURL } = require("node:url");
+const { DataBrowserService } = require("../server/services/sqlite/dataBrowserService");
+
+async function loadFrontendModule(relativePath) {
+  return import(pathToFileURL(path.resolve(__dirname, relativePath)).href);
+}
+
+test("row editor values preserve NULL and empty string as distinct values", async () => {
+  const {
+    buildRowEditorSubmittedValues,
+    getRowEditorValueState,
+    getRowEditorValueStateLabel,
+  } = await loadFrontendModule("../frontend/js/utils/rowEditorValues.js");
+  const formData = new FormData();
+
+  formData.append("field:title", "");
+  formData.append("field:description", "");
+  formData.append("field:count", "42");
+
+  assert.deepEqual(buildRowEditorSubmittedValues(formData, {
+    title: { initialState: "empty", dirty: false },
+    description: { initialState: "null", dirty: false },
+  }), {
+    title: "",
+    description: null,
+    count: "42",
+  });
+  assert.equal(
+    buildRowEditorSubmittedValues(formData, {
+      description: { initialState: "null", dirty: true },
+    }).description,
+    ""
+  );
+  assert.equal(getRowEditorValueState(null), "null");
+  assert.equal(getRowEditorValueState(""), "empty");
+  assert.equal(getRowEditorValueState("text"), "value");
+  assert.equal(getRowEditorValueStateLabel("null"), "NULL");
+  assert.equal(getRowEditorValueStateLabel("empty"), "EMPTY STRING");
+});
+
+test("row editor renders visible NULL and empty-string states", async () => {
+  const { renderRowEditorPanel } = await loadFrontendModule(
+    "../frontend/js/components/rowEditorPanel.js"
+  );
+  const html = renderRowEditorPanel({
+    title: "Values",
+    closeAction: "close",
+    formName: "save-data-row",
+    editableFields: [
+      {
+        name: "nullable_text",
+        label: "nullable_text",
+        rawValue: null,
+        value: "",
+        notNull: false,
+      },
+      {
+        name: "empty_text",
+        label: "empty_text",
+        rawValue: "",
+        value: "",
+        notNull: false,
+      },
+      {
+        name: "required_text",
+        label: "required_text",
+        rawValue: "value",
+        value: "value",
+        notNull: true,
+      },
+    ],
+  });
+
+  assert.match(html, /data-value-state="null"[^>]*>NULL</s);
+  assert.match(html, /data-value-state="empty"[^>]*>EMPTY STRING</s);
+  assert.match(html, /data-value-state="value"[^>]*>VALUE</s);
+  assert.doesNotMatch(html, /field-null:|row-editor-null-toggle|Set NULL/);
+  assert.doesNotMatch(html, /name="field:nullable_text"[\s\S]*?disabled/);
+});
+
+test("data updates can change NULL to empty string and empty string to NULL", () => {
+  const db = new Database(":memory:");
+
+  try {
+    db.exec(`
+      CREATE TABLE values_test (
+        id INTEGER PRIMARY KEY,
+        nullable_text TEXT,
+        empty_text TEXT
+      );
+      INSERT INTO values_test (id, nullable_text, empty_text) VALUES (1, NULL, '');
+    `);
+    const service = new DataBrowserService({
+      connectionManager: {
+        assertWritable() {},
+        getActiveDatabase: () => db,
+      },
+    });
+    const identity = service.getTableData("values_test", { limit: 10 }).rows[0].__identity;
+    const preview = service.previewTableRowUpdate("values_test", {
+      identity,
+      values: {
+        nullable_text: "",
+        empty_text: null,
+      },
+    });
+
+    assert.deepEqual(preview.changes, [
+      { column: "nullable_text", oldValue: "NULL", newValue: "" },
+      { column: "empty_text", oldValue: "", newValue: "NULL" },
+    ]);
+
+    service.updateTableRow("values_test", {
+      identity,
+      values: {
+        nullable_text: "",
+        empty_text: null,
+      },
+    });
+    const row = db.prepare("SELECT nullable_text, empty_text FROM values_test WHERE id = 1").get();
+
+    assert.equal(row.nullable_text, "");
+    assert.equal(row.empty_text, null);
+  } finally {
+    db.close();
+  }
+});

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

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