sqlite-hub 0.12.0 → 0.17.0

package/tests/sql-formatter.test.js

@@ -0,0 +1,173 @@
+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

@@ -0,0 +1,38 @@
+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/table-designer-v2-unique-constraints.test.js

@@ -0,0 +1,78 @@
+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/text-cell-stats.test.js

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