sqlite-hub 0.17.0 → 0.17.2

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/sql-identifier-safety.test.js

@@ -114,7 +114,8 @@ test("data browser mutations preserve quoted dynamic identifiers", () => {
         "UPDATE",
         quoteIdentifier(tableName),
         "SET",
-        quoteIdentifier(valueColumn) + " = ?",
+        quoteIdentifier(valueColumn) + " = ?,",
+        quoteIdentifier(noteColumn) + " = ?",
         "WHERE",
         "rowid IS ?",
       ].join(" ")
@@ -125,6 +126,11 @@ test("data browser mutations preserve quoted dynamic identifiers", () => {
         oldValue: "before",
         newValue: "after",
       },
+      {
+        column: noteColumn,
+        oldValue: "NULL",
+        newValue: "",
+      },
     ]);
 
     const updated = service.updateTableRow(tableName, {
@@ -136,7 +142,7 @@ test("data browser mutations preserve quoted dynamic identifiers", () => {
     });
 
     assert.equal(updated.row[valueColumn], "after");
-    assert.equal(updated.row[noteColumn], null);
+    assert.equal(updated.row[noteColumn], "");
     const persistedRow = db.prepare(
       [
         "SELECT",
@@ -148,7 +154,7 @@ test("data browser mutations preserve quoted dynamic identifiers", () => {
     ).get();
 
     assert.equal(persistedRow[valueColumn], "after");
-    assert.equal(persistedRow[noteColumn], null);
+    assert.equal(persistedRow[noteColumn], "");
 
     const deleted = service.deleteTableRow(tableName, {
       identity: updated.row.__identity,

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

@@ -0,0 +1,66 @@
+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/table-scroll-state.test.js

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