sqlite-hub 1.2.0 → 1.4.0

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

@@ -1,144 +0,0 @@
-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/check-constraint-options.test.js

@@ -1,90 +0,0 @@
-const Database = require("better-sqlite3");
-const assert = require("node:assert/strict");
-const test = require("node:test");
-const { getTableDetail } = require("../server/services/sqlite/introspection");
-const { SqlExecutor } = require("../server/services/sqlite/sqlExecutor");
-const { buildTableDesignerDraft } = require("../server/services/sqlite/tableDesigner/schemaMapping");
-
-test("table detail exposes string options from simple CHECK IN constraints", () => {
-  const db = new Database(":memory:");
-
-  try {
-    db.exec(`
-      CREATE TABLE stream_company_mentions (
-        id INTEGER PRIMARY KEY,
-        mention_type TEXT,
-        CHECK (
-          mention_type IS NULL
-          OR mention_type IN (
-            'company',
-            'stock_company',
-            'brand',
-            'product',
-            'person',
-            'organization',
-            'terrorists',
-            'events',
-            'collective_terms',
-            'countries',
-            'none',
-            'unknown'
-          )
-        )
-      );
-      INSERT INTO stream_company_mentions (mention_type) VALUES ('company');
-    `);
-
-    const tableDetail = getTableDetail(db, "stream_company_mentions");
-    const designerDraft = buildTableDesignerDraft(tableDetail);
-    const mentionTypeColumn = tableDetail.columns.find(
-      (column) => column.name === "mention_type"
-    );
-
-    assert.deepEqual(mentionTypeColumn.allowedValues, [
-      "company",
-      "stock_company",
-      "brand",
-      "product",
-      "person",
-      "organization",
-      "terrorists",
-      "events",
-      "collective_terms",
-      "countries",
-      "none",
-      "unknown",
-    ]);
-
-    const executor = new SqlExecutor({
-      connectionManager: {
-        getActiveDatabase: () => db,
-        getActiveConnection: () => ({ id: "test" }),
-      },
-      appStateStore: {
-        recordQueryExecution: () => 1,
-      },
-    });
-    const result = executor.execute(
-      "SELECT id, mention_type FROM stream_company_mentions"
-    );
-    const editableColumn = result.editing.columns.find(
-      (column) => column.sourceColumn === "mention_type"
-    );
-
-    assert.deepEqual(editableColumn.allowedValues, mentionTypeColumn.allowedValues);
-
-    assert.equal(designerDraft.designerVersion, 2);
-    assert.equal(designerDraft.checkConstraints.length, 1);
-    assert.match(designerDraft.checkConstraints[0].expression, /CHECK/i);
-    assert.equal(designerDraft.checkConstraints[0].originalExpression, designerDraft.checkConstraints[0].expression);
-    assert.equal(designerDraft.checkConstraints[0].editable, true);
-    assert.deepEqual(designerDraft.checkConstraints[0].columns, [
-      {
-        name: "mention_type",
-        allowedValues: mentionTypeColumn.allowedValues,
-      },
-    ]);
-  } finally {
-    db.close();
-  }
-});

package/tests/cli-args.test.js

@@ -1,113 +0,0 @@
-const assert = require("node:assert/strict");
-const test = require("node:test");
-
-const {
-  normalizeExportFormat,
-  parseCliArguments,
-} = require("../bin/sqlite-hub");
-
-test("parses database execute command", () => {
-  const options = parseCliArguments([
-    "--database:trump live interviews",
-    "--execute:Stock Winners",
-  ]);
-
-  assert.equal(options.databaseName, "trump live interviews");
-  assert.equal(options.executeQuery, "Stock Winners");
-  assert.equal(options.queries, false);
-});
-
-test("parses database table list command", () => {
-  const options = parseCliArguments(["--database:trump live interviews", "--tables"]);
-
-  assert.equal(options.databaseName, "trump live interviews");
-  assert.equal(options.tables, true);
-});
-
-test("parses database info commands with the new schema", () => {
-  assert.equal(parseCliArguments(["--database:db", "--path"]).pathInfo, true);
-  assert.equal(parseCliArguments(["--database:db", "---path"]).pathInfo, true);
-  assert.equal(parseCliArguments(["--database:db", "--size"]).sizeInfo, true);
-  assert.equal(parseCliArguments(["--database:db", "--lastopened"]).lastOpenedInfo, true);
-});
-
-test("parses app info command and keeps config as a legacy alias", () => {
-  assert.equal(parseCliArguments(["--info"]).info, true);
-  assert.equal(parseCliArguments(["--config"]).info, true);
-});
-
-test("keeps old sqleditor aliases working", () => {
-  const listOptions = parseCliArguments(["--database:Unit-00", "--sqleditor"]);
-  const executeOptions = parseCliArguments(["--database:Unit-00", "--sqleditor:Saved Query"]);
-
-  assert.equal(listOptions.queries, true);
-  assert.equal(executeOptions.executeQuery, "Saved Query");
-});
-
-test("keeps old database detail aliases working", () => {
-  const pathOptions = parseCliArguments(["--database-path:Billly", "--queries"]);
-  const tableOptions = parseCliArguments(["--database-tables:Billly"]);
-
-  assert.equal(pathOptions.databaseName, "Billly");
-  assert.equal(pathOptions.pathInfo, true);
-  assert.equal(pathOptions.queries, true);
-  assert.equal(tableOptions.databaseName, "Billly");
-  assert.equal(tableOptions.tables, true);
-});
-
-test("parses raw query, store name, saved query display, and export commands", () => {
-  const rawOptions = parseCliArguments([
-    "--database:db",
-    "--query:SELECT 1",
-    "--store:Stored Select",
-  ]);
-  const showOptions = parseCliArguments(["--database:db", "--saved-query:Stock Winners"]);
-  const notesOptions = parseCliArguments(["--database:db", "--notes:Stock Winners"]);
-  const exportOptions = parseCliArguments([
-    "--database:db",
-    "--export:Stock Winners",
-    "--format:md",
-  ]);
-
-  assert.equal(rawOptions.rawQuery, "SELECT 1");
-  assert.equal(rawOptions.storeName, "Stored Select");
-  assert.equal(showOptions.showQuery, "Stock Winners");
-  assert.equal(notesOptions.showNotes, "Stock Winners");
-  assert.equal(exportOptions.exportTarget, "Stock Winners");
-  assert.equal(exportOptions.exportFormat, "md");
-});
-
-test("parses row json export command", () => {
-  const options = parseCliArguments([
-    "--database:db",
-    "--table:companies",
-    "--export:0a754aba373d34972998792a0be4333c",
-  ]);
-
-  assert.equal(options.tableName, "companies");
-  assert.equal(options.exportTarget, "0a754aba373d34972998792a0be4333c");
-});
-
-test("parses document commands", () => {
-  const listOptions = parseCliArguments(["--database:db", "--documents"]);
-  const showOptions = parseCliArguments(["--database:db", "--documents:Research Note"]);
-  const exportOptions = parseCliArguments(["--database:db", "--documents:Research Note", "--export"]);
-  const compactExportOptions = parseCliArguments(["--database:db", "--documents:Research Note--export"]);
-
-  assert.equal(listOptions.documents, true);
-  assert.equal(listOptions.documentName, null);
-  assert.equal(showOptions.documents, true);
-  assert.equal(showOptions.documentName, "Research Note");
-  assert.equal(showOptions.documentExport, false);
-  assert.equal(exportOptions.documentName, "Research Note");
-  assert.equal(exportOptions.documentExport, true);
-  assert.equal(compactExportOptions.documentName, "Research Note");
-  assert.equal(compactExportOptions.documentExport, true);
-});
-
-test("validates export formats", () => {
-  assert.equal(normalizeExportFormat("csv"), "csv");
-  assert.equal(normalizeExportFormat("TSV"), "tsv");
-  assert.equal(normalizeExportFormat("json"), "json");
-  assert.throws(() => normalizeExportFormat("xlsx"), /Unsupported export format/);
-});

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

@@ -1,140 +0,0 @@
-const assert = require("node:assert/strict");
-const test = require("node:test");
-
-const { main } = require("../bin/sqlite-hub");
-
-test("CLI delegates database operations to the shared command service", 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];
-    },
-    listTables(reference) {
-      calls.push(["listTables", reference]);
-      return [{ name: "companies" }];
-    },
-  };
-  const output = [];
-  const originalLog = console.log;
-
-  console.log = (...values) => output.push(values.join(" "));
-
-  try {
-    await main(["--database:Database One", "--tables"], { databaseService });
-  } finally {
-    console.log = originalLog;
-  }
-
-  assert.deepEqual(calls, [
-    ["listDatabases"],
-    ["getDatabase", "Database One"],
-    ["listTables", "db-one"],
-  ]);
-  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

@@ -1,52 +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 { 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/connections-file-dialog-route.test.js

@@ -1,89 +0,0 @@
-const assert = require("node:assert/strict");
-const express = require("express");
-const test = require("node:test");
-const { createConnectionsRouter } = require("../server/routes/connections");
-const { errorMiddleware } = require("../server/utils/errors");
-
-test("connections route returns the path selected by the native dialog", async () => {
-  const app = express();
-  app.use(express.json());
-  app.use(
-    "/api/connections",
-    createConnectionsRouter({
-      connectionManager: {},
-      importService: {},
-      backupService: {},
-      nativeFileDialogService: {
-        chooseCreateDatabasePath: async () => "/tmp/new-database.sqlite",
-        chooseOpenDatabasePath: async () => "/tmp/existing-database.db",
-      },
-    })
-  );
-  app.use(errorMiddleware);
-
-  const server = await new Promise((resolve) => {
-    const listener = app.listen(0, "127.0.0.1", () => resolve(listener));
-  });
-
-  try {
-    const address = server.address();
-    const response = await fetch(
-      `http://127.0.0.1:${address.port}/api/connections/choose-create-path`,
-      { method: "POST" }
-    );
-    const payload = await response.json();
-
-    assert.equal(response.status, 200);
-    assert.equal(payload.success, true);
-    assert.deepEqual(payload.data, {
-      cancelled: false,
-      path: "/tmp/new-database.sqlite",
-    });
-  } finally {
-    await new Promise((resolve, reject) => {
-      server.close((error) => (error ? reject(error) : resolve()));
-    });
-  }
-});
-
-test("connections route returns the existing database selected by the native dialog", async () => {
-  const app = express();
-  app.use(express.json());
-  app.use(
-    "/api/connections",
-    createConnectionsRouter({
-      connectionManager: {},
-      importService: {},
-      backupService: {},
-      nativeFileDialogService: {
-        chooseCreateDatabasePath: async () => null,
-        chooseOpenDatabasePath: async () => "/tmp/existing-database.db",
-      },
-    })
-  );
-  app.use(errorMiddleware);
-
-  const server = await new Promise((resolve) => {
-    const listener = app.listen(0, "127.0.0.1", () => resolve(listener));
-  });
-
-  try {
-    const address = server.address();
-    const response = await fetch(
-      `http://127.0.0.1:${address.port}/api/connections/choose-open-path`,
-      { method: "POST" }
-    );
-    const payload = await response.json();
-
-    assert.equal(response.status, 200);
-    assert.equal(payload.success, true);
-    assert.deepEqual(payload.data, {
-      cancelled: false,
-      path: "/tmp/existing-database.db",
-    });
-  } finally {
-    await new Promise((resolve, reject) => {
-      server.close((error) => (error ? reject(error) : resolve()));
-    });
-  }
-});