sqlite-hub 1.2.0 → 1.4.0

package/tests/sql-formatter.test.js

@@ -1,173 +0,0 @@
-const assert = require("node:assert/strict");
-const { readFileSync } = require("node:fs");
-const path = require("node:path");
-const test = require("node:test");
-
-let sqlFormatterModulePromise = null;
-
-function loadSqlFormatterModule() {
-  if (!sqlFormatterModulePromise) {
-    const source = readFileSync(
-      path.resolve(__dirname, "../frontend/js/utils/sqlFormatter.js"),
-      "utf8"
-    );
-    const url = `data:text/javascript;base64,${Buffer.from(source).toString("base64")}`;
-
-    sqlFormatterModulePromise = import(url);
-  }
-
-  return sqlFormatterModulePromise;
-}
-
-test("SQL formatter uppercases keywords and formats common clauses", async () => {
-  const { formatSqlQuery } = await loadSqlFormatterModule();
-
-  assert.equal(
-    formatSqlQuery("select id,name from users where status='active' and age>=18 order by name desc;"),
-    [
-      "SELECT id,",
-      "  name",
-      "",
-      "FROM users",
-      "",
-      "WHERE status = 'active'",
-      "  AND age >= 18",
-      "",
-      "ORDER BY name DESC;",
-    ].join("\n")
-  );
-});
-
-test("SQL formatter keeps string literals and comments untouched", async () => {
-  const { formatSqlQuery } = await loadSqlFormatterModule();
-
-  assert.equal(
-    formatSqlQuery("-- select from comment\nselect 'from where' as note, name from users"),
-    [
-      "-- select from comment",
-      "SELECT 'from where' AS note,",
-      "  name",
-      "",
-      "FROM users",
-    ].join("\n")
-  );
-});
-
-test("SQL formatter formats joins on separate readable lines", async () => {
-  const { formatSqlQuery } = await loadSqlFormatterModule();
-
-  assert.equal(
-    formatSqlQuery("select * from users left join posts on posts.user_id=users.id where users.id=1"),
-    [
-      "SELECT *",
-      "",
-      "FROM users",
-      "",
-      "LEFT JOIN posts",
-      "  ON posts.user_id = users.id",
-      "",
-      "WHERE users.id = 1",
-    ].join("\n")
-  );
-});
-
-test("SQL formatter does not break function arguments as select columns", async () => {
-  const { formatSqlQuery } = await loadSqlFormatterModule();
-
-  assert.equal(
-    formatSqlQuery("select coalesce(first_name,last_name) as display_name, id from users"),
-    [
-      "SELECT coalesce(first_name, last_name) AS display_name,",
-      "  id",
-      "",
-      "FROM users",
-    ].join("\n")
-  );
-});
-
-test("SQL formatter indents AS parenthesis blocks", async () => {
-  const { formatSqlQuery } = await loadSqlFormatterModule();
-
-  assert.equal(
-    formatSqlQuery("with recent as(select id,name from users where active=1) select * from recent"),
-    [
-      "WITH recent AS (",
-      "  SELECT id,",
-      "    name",
-      "",
-      "  FROM users",
-      "",
-      "  WHERE active = 1",
-      ")",
-      "",
-      "SELECT *",
-      "",
-      "FROM recent",
-    ].join("\n")
-  );
-});
-
-test("SQL formatter does not treat non-parenthesized AS keywords as blocks", async () => {
-  const { formatSqlQuery } = await loadSqlFormatterModule();
-
-  assert.equal(
-    formatSqlQuery("select cast(value as integer) as value_int from metrics"),
-    [
-      "SELECT CAST(value AS INTEGER) AS value_int",
-      "",
-      "FROM metrics",
-    ].join("\n")
-  );
-});
-
-test("SQL formatter expands CASE expressions into readable blocks", async () => {
-  const { formatSqlQuery } = await loadSqlFormatterModule();
-
-  assert.equal(
-    formatSqlQuery(
-      "select upload_date,case when upload_date is null then null else substr(cast(upload_date as text),1,4)||'-'||substr(cast(upload_date as text),5,2)||'-'||substr(cast(upload_date as text),7,2) end as upload_date_readable from white_house_live_streams"
-    ),
-    [
-      "SELECT upload_date,",
-      "  CASE",
-      "    WHEN upload_date IS NULL THEN NULL",
-      "    ELSE",
-      "      substr(CAST(upload_date AS TEXT), 1, 4) || '-' ||",
-      "      substr(CAST(upload_date AS TEXT), 5, 2) || '-' ||",
-      "      substr(CAST(upload_date AS TEXT), 7, 2)",
-      "  END AS upload_date_readable",
-      "",
-      "FROM white_house_live_streams",
-    ].join("\n")
-  );
-});
-
-test("SQL formatter separates window functions and join blocks", async () => {
-  const { formatSqlQuery } = await loadSqlFormatterModule();
-
-  assert.equal(
-    formatSqlQuery(
-      "with winners as(select w.window_label,row_number() over(partition by w.window_label order by w.delta_return desc) as winner_rank from windowed w join mention_impact mi on mi.id=w.mention_impact_id order by w.window_label,winner_rank) select * from winners"
-    ),
-    [
-      "WITH winners AS (",
-      "  SELECT w.window_label,",
-      "    ROW_NUMBER() OVER (",
-      "      PARTITION BY w.window_label",
-      "      ORDER BY w.delta_return DESC",
-      "    ) AS winner_rank",
-      "",
-      "  FROM windowed w",
-      "",
-      "  JOIN mention_impact mi",
-      "    ON mi.id = w.mention_impact_id",
-      "",
-      "  ORDER BY w.window_label, winner_rank",
-      ")",
-      "",
-      "SELECT *",
-      "",
-      "FROM winners",
-    ].join("\n")
-  );
-});

package/tests/sql-highlight.test.js

@@ -1,38 +0,0 @@
-const assert = require("node:assert/strict");
-const { readFileSync } = require("node:fs");
-const path = require("node:path");
-const test = require("node:test");
-
-let formatModulePromise = null;
-
-function loadFormatModule() {
-  if (!formatModulePromise) {
-    const source = readFileSync(
-      path.resolve(__dirname, "../frontend/js/utils/format.js"),
-      "utf8"
-    );
-    const url = `data:text/javascript;base64,${Buffer.from(source).toString("base64")}`;
-
-    formatModulePromise = import(url);
-  }
-
-  return formatModulePromise;
-}
-
-test("SQL highlighting marks CASE and null-check keywords", async () => {
-  const { highlightSql } = await loadFormatModule();
-  const highlighted = highlightSql("CASE WHEN upload_date IS NULL THEN NULL ELSE 1 END");
-
-  for (const keyword of ["CASE", "WHEN", "IS", "NULL", "THEN", "ELSE", "END"]) {
-    assert.match(highlighted, new RegExp(`<span class="sql-keyword">${keyword}</span>`));
-  }
-});
-
-test("SQL highlighting marks window function keywords", async () => {
-  const { highlightSql } = await loadFormatModule();
-  const highlighted = highlightSql("ROW_NUMBER() OVER (PARTITION BY window_label ORDER BY delta_return DESC)");
-
-  for (const keyword of ["ROW_NUMBER", "OVER", "PARTITION", "ORDER", "BY", "DESC"]) {
-    assert.match(highlighted, new RegExp(`<span class="sql-keyword">${keyword}</span>`));
-  }
-});

package/tests/sql-identifier-safety.test.js

@@ -1,171 +0,0 @@
-const Database = require("better-sqlite3");
-const assert = require("node:assert/strict");
-const test = require("node:test");
-const { DataBrowserService } = require("../server/services/sqlite/dataBrowserService");
-const { quoteIdentifier } = require("../server/utils/identifier");
-
-test("data browser mutations preserve quoted dynamic identifiers", () => {
-  const db = new Database(":memory:");
-  const tableName = 'items" archived';
-  const valueColumn = 'display"name';
-  const noteColumn = 'review"note';
-
-  try {
-    db.exec(
-      [
-        "CREATE TABLE",
-        quoteIdentifier(tableName),
-        "(",
-        quoteIdentifier(valueColumn),
-        "TEXT, status INTEGER,",
-        quoteIdentifier(noteColumn),
-        "TEXT",
-        ")",
-      ].join(" ")
-    );
-    db.prepare(
-      [
-        "INSERT INTO",
-        quoteIdentifier(tableName),
-        "(" + quoteIdentifier(valueColumn) + ", status, " + quoteIdentifier(noteColumn) + ")",
-        "VALUES (?, ?, ?)",
-      ].join(" ")
-    ).run("before", 0, null);
-
-    const service = new DataBrowserService({
-      connectionManager: {
-        assertWritable() {},
-        getActiveDatabase: () => db,
-      },
-    });
-    const tableData = service.getTableData(tableName, { limit: 10, offset: 0 });
-    const filteredTableData = service.getTableData(tableName, {
-      limit: 10,
-      offset: 0,
-      filterColumn: valueColumn,
-      filterOperator: "=",
-      filterValue: "EFO",
-    });
-    const negativeFilteredTableData = service.getTableData(tableName, {
-      limit: 10,
-      offset: 0,
-      filterColumn: valueColumn,
-      filterOperator: "!=",
-      filterValue: "EFO",
-    });
-    const exactFilteredTableData = service.getTableData(tableName, {
-      limit: 10,
-      offset: 0,
-      filterColumn: valueColumn,
-      filterOperator: "equals",
-      filterValue: "BEFORE",
-    });
-    const exactSubstringMissTableData = service.getTableData(tableName, {
-      limit: 10,
-      offset: 0,
-      filterColumn: valueColumn,
-      filterOperator: "equals",
-      filterValue: "EFO",
-    });
-
-    assert.equal(filteredTableData.rowCount, 1);
-    assert.equal(filteredTableData.rows[0][valueColumn], "before");
-    assert.deepEqual(filteredTableData.filter, {
-      column: valueColumn,
-      operator: "=",
-      value: "EFO",
-      matchMode: "contains",
-    });
-    assert.equal(negativeFilteredTableData.rowCount, 0);
-    assert.equal(exactFilteredTableData.rowCount, 1);
-    assert.equal(exactFilteredTableData.rows[0][valueColumn], "before");
-    assert.deepEqual(exactFilteredTableData.filter, {
-      column: valueColumn,
-      operator: "equals",
-      value: "BEFORE",
-      matchMode: "equals",
-    });
-    assert.equal(exactSubstringMissTableData.rowCount, 0);
-    assert.throws(
-      () =>
-        service.getTableData(tableName, {
-          limit: 10,
-          offset: 0,
-          filterColumn: valueColumn,
-          filterOperator: "<>",
-          filterValue: "before",
-        }),
-      /filterOperator/
-    );
-
-    const identity = tableData.rows[0].__identity;
-    const preview = service.previewTableRowUpdate(tableName, {
-      identity,
-      values: {
-        [valueColumn]: "after",
-        status: 0,
-        [noteColumn]: "",
-      },
-    });
-
-    assert.equal(
-      preview.sql,
-      [
-        "UPDATE",
-        quoteIdentifier(tableName),
-        "SET",
-        quoteIdentifier(valueColumn) + " = ?,",
-        quoteIdentifier(noteColumn) + " = ?",
-        "WHERE",
-        "rowid IS ?",
-      ].join(" ")
-    );
-    assert.deepEqual(preview.changes, [
-      {
-        column: valueColumn,
-        oldValue: "before",
-        newValue: "after",
-      },
-      {
-        column: noteColumn,
-        oldValue: "NULL",
-        newValue: "",
-      },
-    ]);
-
-    const updated = service.updateTableRow(tableName, {
-      identity,
-      values: {
-        [valueColumn]: "after",
-        [noteColumn]: "",
-      },
-    });
-
-    assert.equal(updated.row[valueColumn], "after");
-    assert.equal(updated.row[noteColumn], "");
-    const persistedRow = db.prepare(
-      [
-        "SELECT",
-        quoteIdentifier(valueColumn) + ",",
-        quoteIdentifier(noteColumn),
-        "FROM",
-        quoteIdentifier(tableName),
-      ].join(" ")
-    ).get();
-
-    assert.equal(persistedRow[valueColumn], "after");
-    assert.equal(persistedRow[noteColumn], "");
-
-    const deleted = service.deleteTableRow(tableName, {
-      identity: updated.row.__identity,
-    });
-
-    assert.equal(deleted.affectedRowCount, 1);
-    assert.equal(
-      db.prepare(["SELECT COUNT(*) AS count FROM", quoteIdentifier(tableName)].join(" ")).get().count,
-      0
-    );
-  } finally {
-    db.close();
-  }
-});

package/tests/sql-result-limit.test.js

@@ -1,66 +0,0 @@
-const Database = require("better-sqlite3");
-const assert = require("node:assert/strict");
-const test = require("node:test");
-const {
-  DEFAULT_RESULT_ROW_LIMIT,
-  SqlExecutor,
-} = require("../server/services/sqlite/sqlExecutor");
-
-function createExecutor(db) {
-  return new SqlExecutor({
-    connectionManager: {
-      getActiveDatabase: () => db,
-      getActiveConnection: () => ({ id: "result-limit-test" }),
-    },
-    appStateStore: {
-      recordQueryExecution: () => 1,
-    },
-  });
-}
-
-test("interactive SQL results stop at the configured row limit", () => {
-  const db = new Database(":memory:");
-
-  try {
-    db.exec(`
-      CREATE TABLE items (id INTEGER PRIMARY KEY, label TEXT);
-      INSERT INTO items (label) VALUES ('one'), ('two'), ('three'), ('four'), ('five');
-    `);
-
-    const result = createExecutor(db).execute("SELECT id, label FROM items ORDER BY id", {
-      maxRows: 3,
-    });
-
-    assert.equal(DEFAULT_RESULT_ROW_LIMIT, 5000);
-    assert.equal(result.rows.length, 3);
-    assert.deepEqual(result.rows.map((row) => row.id), [1, 2, 3]);
-    assert.equal(result.truncated, true);
-    assert.equal(result.rowLimit, 3);
-    assert.equal(result.statements[0].truncated, true);
-    assert.equal(result.statements[0].rowCount, 3);
-  } finally {
-    db.close();
-  }
-});
-
-test("unlimited SQL execution remains available for export services", () => {
-  const db = new Database(":memory:");
-
-  try {
-    db.exec(`
-      CREATE TABLE items (id INTEGER PRIMARY KEY);
-      INSERT INTO items VALUES (1), (2), (3), (4), (5);
-    `);
-
-    const result = createExecutor(db).execute("SELECT id FROM items ORDER BY id", {
-      maxRows: null,
-      persistHistory: false,
-    });
-
-    assert.equal(result.rows.length, 5);
-    assert.equal(result.truncated, false);
-    assert.equal(result.rowLimit, null);
-  } finally {
-    db.close();
-  }
-});

package/tests/structure-view.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");
-
-let structureViewModulePromise = null;
-
-function loadStructureViewModule() {
-  if (!structureViewModulePromise) {
-    structureViewModulePromise = import(
-      pathToFileURL(path.resolve(__dirname, "../frontend/js/views/structure.js")).href
-    );
-  }
-
-  return structureViewModulePromise;
-}
-
-function buildStructureState() {
-  return {
-    structure: {
-      data: {
-        grouped: {
-          tables: [{ name: "companies", type: "table" }],
-          views: [],
-          indexes: [],
-          triggers: [],
-        },
-        graph: {
-          relationshipCount: 0,
-          tables: [{ name: "companies", type: "table", columns: [], foreignKeys: [] }],
-        },
-      },
-      detail: null,
-      detailLoading: false,
-      error: null,
-      loading: false,
-      selectedName: "companies",
-      tableSearchQuery: "",
-      tablesVisible: true,
-    },
-  };
-}
-
-test("structure toolbar groups graph format actions in a dropdown", async () => {
-  const { renderStructureView } = await loadStructureViewModule();
-  const { main } = renderStructureView(buildStructureState());
-
-  assert.match(main, /data-dropdown-button/);
-  assert.match(main, /Open companies/);
-  assert.match(main, /data-to="\/data\/companies"/);
-  assert.match(main, /data-to="\/table-designer\/companies"/);
-  assert.match(main, /data-action="open-table-in-sql-editor"/);
-  assert.match(main, /Format graph/);
-  assert.match(main, /Fit Graph/);
-  assert.match(main, /data-structure-graph-action="fit"/);
-  assert.match(main, /Recalculate Layout/);
-  assert.match(main, /data-structure-graph-action="relayout"/);
-  assert.match(main, /Clear Selection/);
-  assert.match(main, /data-structure-graph-action="clear"/);
-});

package/tests/table-designer-v2-unique-constraints.test.js

@@ -1,78 +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 { analyzeTableDesignerChanges } = require("../server/services/sqlite/tableDesigner/changeAnalysis");
-const { buildTableDesignerDraft } = require("../server/services/sqlite/tableDesigner/schemaMapping");
-
-test("table designer draft exposes v2 complex unique constraints", () => {
-  const db = new Database(":memory:");
-
-  try {
-    db.exec(`
-      CREATE TABLE companies (
-        company_id INTEGER NOT NULL,
-        ticker TEXT NOT NULL,
-        deleted_at TEXT,
-        name TEXT,
-        UNIQUE (company_id, ticker)
-      );
-      CREATE UNIQUE INDEX uniq_active_company_ticker
-        ON companies (ticker)
-        WHERE deleted_at IS NULL;
-    `);
-
-    const tableDetail = getTableDetail(db, "companies", { includeRowCount: false });
-    const draft = buildTableDesignerDraft(tableDetail);
-
-    assert.equal(draft.designerVersion, 2);
-    assert.equal(draft.uniqueConstraints.length, 2);
-
-    const multiColumnConstraint = draft.uniqueConstraints.find(
-      (constraint) => constraint.columns.length === 2
-    );
-    assert.ok(multiColumnConstraint);
-    assert.equal(multiColumnConstraint.partial, false);
-    assert.deepEqual(
-      multiColumnConstraint.columns.map((column) => column.name),
-      ["company_id", "ticker"]
-    );
-    assert.equal(multiColumnConstraint.expression, 'UNIQUE ("company_id", "ticker")');
-    assert.equal(multiColumnConstraint.originalExpression, multiColumnConstraint.expression);
-    assert.equal(multiColumnConstraint.editable, true);
-    assert.equal(multiColumnConstraint.preserved, true);
-
-    const partialConstraint = draft.uniqueConstraints.find((constraint) => constraint.partial);
-    assert.ok(partialConstraint);
-    assert.equal(partialConstraint.name, "uniq_active_company_ticker");
-    assert.match(partialConstraint.sql, /CREATE UNIQUE INDEX uniq_active_company_ticker/i);
-    assert.match(partialConstraint.sql, /WHERE deleted_at IS NULL/i);
-    assert.equal(partialConstraint.expression, partialConstraint.sql);
-
-    const changedDraft = {
-      ...draft,
-      uniqueConstraints: draft.uniqueConstraints.map((constraint) =>
-        constraint.id === multiColumnConstraint.id
-          ? {
-              ...constraint,
-              expression: 'UNIQUE ("company_id", "ticker", "name")',
-            }
-          : constraint
-      ),
-    };
-    const analysis = analyzeTableDesignerChanges({ draft: changedDraft, originalDraft: draft });
-    assert.equal(analysis.dirty, true);
-    assert.equal(analysis.executable, false);
-    assert.match(analysis.warnings[0].title, /Constraint Change Requires Rebuild/);
-
-    const uniqueWarning = draft.schemaWarnings.find(
-      (warning) => warning.code === "COMPLEX_UNIQUE_CONSTRAINTS_PRESENT"
-    );
-    assert.ok(uniqueWarning);
-    assert.equal(uniqueWarning.title, "Table Designer v2 Unique Constraints");
-    assert.equal(uniqueWarning.tone, "muted");
-    assert.doesNotMatch(uniqueWarning.message, /outside Table Designer v1/i);
-  } finally {
-    db.close();
-  }
-});

package/tests/table-scroll-state.test.js

@@ -1,70 +0,0 @@
-const assert = require("node:assert/strict");
-const { readFileSync } = require("node:fs");
-const path = require("node:path");
-const test = require("node:test");
-
-let tableScrollStateModulePromise = null;
-
-function loadTableScrollStateModule() {
-  if (!tableScrollStateModulePromise) {
-    const source = readFileSync(
-      path.resolve(__dirname, "../frontend/js/utils/tableScrollState.js"),
-      "utf8"
-    );
-    const url = `data:text/javascript;base64,${Buffer.from(source).toString("base64")}`;
-
-    tableScrollStateModulePromise = import(url);
-  }
-
-  return tableScrollStateModulePromise;
-}
-
-test("table scroll state restores horizontal position for the matching grid", async () => {
-  const { captureTableHorizontalScrollState, restoreTableHorizontalScrollState } =
-    await loadTableScrollStateModule();
-  const key = 'data:events "archive"';
-  const previousGrid = { dataset: { tableScrollKey: key }, scrollLeft: 640 };
-  const nextGrid = { dataset: { tableScrollKey: key }, scrollLeft: 0 };
-  const snapshot = captureTableHorizontalScrollState({
-    routeName: "data",
-    scrollNodes: [previousGrid],
-  });
-
-  assert.equal(
-    restoreTableHorizontalScrollState({
-      snapshot,
-      routeName: "data",
-      scrollNodes: [nextGrid],
-    }),
-    true
-  );
-  assert.equal(nextGrid.scrollLeft, 640);
-});
-
-test("table scroll state is not restored across routes or different grids", async () => {
-  const { captureTableHorizontalScrollState, restoreTableHorizontalScrollState } =
-    await loadTableScrollStateModule();
-  const snapshot = captureTableHorizontalScrollState({
-    routeName: "editorResults",
-    scrollNodes: [{ dataset: { tableScrollKey: "editor:12" }, scrollLeft: 320 }],
-  });
-  const nextGrid = { dataset: { tableScrollKey: "editor:13" }, scrollLeft: 0 };
-
-  assert.equal(
-    restoreTableHorizontalScrollState({
-      snapshot,
-      routeName: "data",
-      scrollNodes: [nextGrid],
-    }),
-    false
-  );
-  assert.equal(
-    restoreTableHorizontalScrollState({
-      snapshot,
-      routeName: "editorResults",
-      scrollNodes: [nextGrid],
-    }),
-    false
-  );
-  assert.equal(nextGrid.scrollLeft, 0);
-});

package/tests/text-cell-stats.test.js

@@ -1,38 +0,0 @@
-const assert = require("node:assert/strict");
-const { readFileSync } = require("node:fs");
-const path = require("node:path");
-const test = require("node:test");
-
-let textCellStatsModulePromise = null;
-
-function loadTextCellStatsModule() {
-  if (!textCellStatsModulePromise) {
-    const source = readFileSync(
-      path.resolve(__dirname, "../frontend/js/utils/textCellStats.js"),
-      "utf8"
-    );
-    const url = `data:text/javascript;base64,${Buffer.from(source).toString("base64")}`;
-
-    textCellStatsModulePromise = import(url);
-  }
-
-  return textCellStatsModulePromise;
-}
-
-test("text cell character count only returns counts for non-empty strings", async () => {
-  const { getTextCellCharacterCount } = await loadTextCellStatsModule();
-
-  assert.equal(getTextCellCharacterCount(""), null);
-  assert.equal(getTextCellCharacterCount(null), null);
-  assert.equal(getTextCellCharacterCount(123), null);
-  assert.equal(getTextCellCharacterCount("hello"), 5);
-  assert.equal(getTextCellCharacterCount("a\nb"), 3);
-});
-
-test("text cell character count label is readable", async () => {
-  const { formatTextCellCharacterCount } = await loadTextCellStatsModule();
-
-  assert.equal(formatTextCellCharacterCount(1), "1 char");
-  assert.equal(formatTextCellCharacterCount(25), "25 chars");
-  assert.equal(formatTextCellCharacterCount(1200), "1,200 chars");
-});