sqlite-hub 0.11.1 → 0.16.0

package/tests/file-path-preview.test.js

@@ -0,0 +1,165 @@
+const assert = require("node:assert/strict");
+const { readFileSync } = require("node:fs");
+const path = require("node:path");
+const test = require("node:test");
+
+let filePathPreviewModulePromise = null;
+
+function loadFilePathPreviewModule() {
+  if (!filePathPreviewModulePromise) {
+    const timestampPreviewSource = readFileSync(
+      path.resolve(__dirname, "../frontend/js/utils/timestampPreview.js"),
+      "utf8"
+    );
+    const timestampPreviewUrl = `data:text/javascript;base64,${Buffer.from(timestampPreviewSource).toString("base64")}`;
+    const filePathPreviewSource = readFileSync(
+      path.resolve(__dirname, "../frontend/js/utils/filePathPreview.js"),
+      "utf8"
+    ).replace(
+      'import { isProtectedKeyColumn } from "./timestampPreview.js";',
+      `import { isProtectedKeyColumn } from "${timestampPreviewUrl}";`
+    );
+    const filePathPreviewUrl = `data:text/javascript;base64,${Buffer.from(filePathPreviewSource).toString("base64")}`;
+
+    filePathPreviewModulePromise = import(filePathPreviewUrl);
+  }
+
+  return filePathPreviewModulePromise;
+}
+
+function createTableMeta() {
+  return {
+    columns: [
+      { name: "id", primaryKeyPosition: 1 },
+      { name: "parent_id", primaryKeyPosition: 0 },
+      { name: "file_path", primaryKeyPosition: 0 },
+      { name: "filename", primaryKeyPosition: 0 },
+      { name: "note", primaryKeyPosition: 0 },
+    ],
+    foreignKeys: [
+      {
+        mappings: [{ from: "parent_id", to: "id" }],
+      },
+    ],
+  };
+}
+
+test("filepath preview detects supported path styles", async () => {
+  const { detectFilePathValue } = await loadFilePathPreviewModule();
+  const tableMeta = createTableMeta();
+  const cases = [
+    {
+      value: "/Users/oli/project/file.txt",
+      pathType: "unix",
+      fileName: "file.txt",
+      directory: "/Users/oli/project",
+      extension: "txt",
+    },
+    {
+      value: "/home/oli/data/app.sqlite",
+      pathType: "unix",
+      fileName: "app.sqlite",
+      directory: "/home/oli/data",
+      extension: "sqlite",
+    },
+    {
+      value: "C:\\Users\\Oliver\\Desktop\\file.pdf",
+      pathType: "windows",
+      fileName: "file.pdf",
+      directory: "C:\\Users\\Oliver\\Desktop",
+      extension: "pdf",
+    },
+    {
+      value: "./data/export.csv",
+      pathType: "relative",
+      fileName: "export.csv",
+      directory: "./data",
+      extension: "csv",
+    },
+    {
+      value: "../logs/app.log",
+      pathType: "relative",
+      fileName: "app.log",
+      directory: "../logs",
+      extension: "log",
+    },
+    {
+      value: "~/Documents/report.md",
+      pathType: "home",
+      fileName: "report.md",
+      directory: "~/Documents",
+      extension: "md",
+    },
+    {
+      value: "data/images/avatar.png",
+      pathType: "relative",
+      fileName: "avatar.png",
+      directory: "data/images",
+      extension: "png",
+    },
+  ];
+
+  for (const item of cases) {
+    const preview = detectFilePathValue(item.value, "file_path", tableMeta);
+
+    assert.equal(preview?.type, "filepath");
+    assert.equal(preview.pathType, item.pathType);
+    assert.equal(preview.fileName, item.fileName);
+    assert.equal(preview.directory, item.directory);
+    assert.equal(preview.extension, item.extension);
+    assert.ok(preview.confidence >= 0.7);
+  }
+});
+
+test("filepath preview does not detect URLs, primitive text, JSON, emails, or weak filenames", async () => {
+  const { detectFilePathValue } = await loadFilePathPreviewModule();
+  const tableMeta = createTableMeta();
+  const rejectedValues = [
+    "https://example.com/file.txt",
+    "http://localhost:3000/test",
+    "mailto:oliver@example.com",
+    "tel:+431234567",
+    "ftp://example.com/file.txt",
+    "oliver@example.com",
+    "1717682400",
+    "true",
+    "false",
+    '{"path":"/tmp/file.txt"}',
+    "hello world",
+    "file",
+    "invoice.pdf",
+  ];
+
+  for (const value of rejectedValues) {
+    assert.equal(detectFilePathValue(value, "note", tableMeta), null);
+  }
+});
+
+test("filepath preview protects primary keys and foreign keys", async () => {
+  const { detectFilePathValue } = await loadFilePathPreviewModule();
+  const tableMeta = createTableMeta();
+
+  assert.equal(detectFilePathValue("/Users/oli/project/file.txt", "id", tableMeta), null);
+  assert.equal(detectFilePathValue("/Users/oli/project/file.txt", "parent_id", tableMeta), null);
+});
+
+test("filepath preview allows bare filenames only for strong file columns", async () => {
+  const { detectFilePathValue } = await loadFilePathPreviewModule();
+  const tableMeta = createTableMeta();
+
+  assert.equal(detectFilePathValue("invoice.pdf", "note", tableMeta), null);
+
+  const preview = detectFilePathValue("invoice.pdf", "filename", tableMeta);
+
+  assert.equal(preview?.pathType, "relative");
+  assert.equal(preview.fileName, "invoice.pdf");
+  assert.equal(preview.directory, null);
+  assert.equal(preview.extension, "pdf");
+});
+
+test("filepath preview compacts long paths while preserving filename", async () => {
+  const { compactPathForDisplay } = await loadFilePathPreviewModule();
+  const display = compactPathForDisplay("/Users/oli/projects/sqlite-hub/data/app.sqlite", 24);
+
+  assert.equal(display, ".../data/app.sqlite");
+});

package/tests/row-editor-json.test.js

@@ -0,0 +1,82 @@
+const assert = require("node:assert/strict");
+const { readFileSync } = require("node:fs");
+const path = require("node:path");
+const test = require("node:test");
+
+let rowEditorJsonModulePromise = null;
+
+function loadRowEditorJsonModule() {
+  if (!rowEditorJsonModulePromise) {
+    const source = readFileSync(
+      path.resolve(__dirname, "../frontend/js/utils/rowEditorJson.js"),
+      "utf8"
+    );
+    const url = `data:text/javascript;base64,${Buffer.from(source).toString("base64")}`;
+
+    rowEditorJsonModulePromise = import(url);
+  }
+
+  return rowEditorJsonModulePromise;
+}
+
+test("row editor JSON for data rows preserves column order and omits identity metadata", async () => {
+  const { buildDataRowEditorJsonObject, stringifyRowEditorJson } = await loadRowEditorJsonModule();
+  const row = {
+    id: 1,
+    title: "Event",
+    created_at: 1717682400,
+    payload: { __type: "blob", sizeBytes: 4, hexPreview: "ffff" },
+    __identity: { kind: "primaryKey", values: { id: 1 } },
+  };
+  const rowObject = buildDataRowEditorJsonObject({
+    row,
+    columns: ["id", "title", "created_at", "payload"],
+  });
+
+  assert.deepEqual(Object.keys(rowObject), ["id", "title", "created_at", "payload"]);
+  assert.deepEqual(rowObject, {
+    id: 1,
+    title: "Event",
+    created_at: 1717682400,
+    payload: { __type: "blob", sizeBytes: 4, hexPreview: "ffff" },
+  });
+  assert.equal(
+    stringifyRowEditorJson(rowObject),
+    [
+      "{",
+      '  "id": 1,',
+      '  "title": "Event",',
+      '  "created_at": 1717682400,',
+      '  "payload": {',
+      '    "__type": "blob",',
+      '    "sizeBytes": 4,',
+      '    "hexPreview": "ffff"',
+      "  }",
+      "}",
+    ].join("\n")
+  );
+});
+
+test("row editor JSON for SQL result rows maps visible source columns once", async () => {
+  const { buildEditorRowEditorJsonObject } = await loadRowEditorJsonModule();
+  const rowObject = buildEditorRowEditorJsonObject({
+    row: {
+      id: 1,
+      title_alias: "Event",
+      duplicate_title: "Ignored",
+      hidden_note: "Hidden",
+      __identity: { kind: "primaryKey", values: { id: 1 } },
+    },
+    editingColumns: [
+      { resultName: "id", sourceColumn: "id", visible: true },
+      { resultName: "title_alias", sourceColumn: "title", visible: true },
+      { resultName: "duplicate_title", sourceColumn: "title", visible: true },
+      { resultName: "hidden_note", sourceColumn: "note", visible: false },
+    ],
+  });
+
+  assert.deepEqual(rowObject, {
+    id: 1,
+    title: "Event",
+  });
+});

package/tests/row-editor-timestamp-preview.test.js

@@ -0,0 +1,192 @@
+const Database = require("better-sqlite3");
+const assert = require("node:assert/strict");
+const { readFileSync } = require("node:fs");
+const path = require("node:path");
+const test = require("node:test");
+const { DataBrowserService } = require("../server/services/sqlite/dataBrowserService");
+
+let timestampPreviewModulePromise = null;
+
+function loadTimestampPreviewModule() {
+  if (!timestampPreviewModulePromise) {
+    const source = readFileSync(
+      path.resolve(__dirname, "../frontend/js/utils/timestampPreview.js"),
+      "utf8"
+    );
+    const url = `data:text/javascript;base64,${Buffer.from(source).toString("base64")}`;
+
+    timestampPreviewModulePromise = import(url);
+  }
+
+  return timestampPreviewModulePromise;
+}
+
+function createTableMeta() {
+  return {
+    columns: [
+      { name: "id", primaryKeyPosition: 1 },
+      { name: "parent_id", primaryKeyPosition: 0 },
+      { name: "created_at", primaryKeyPosition: 0 },
+      { name: "updated_at", primaryKeyPosition: 0 },
+      { name: "published_at", primaryKeyPosition: 0 },
+      { name: "price", primaryKeyPosition: 0 },
+    ],
+    foreignKeys: [
+      {
+        mappings: [{ from: "parent_id", to: "id" }],
+      },
+    ],
+  };
+}
+
+test("row editor timestamp preview protects primary and foreign keys", async () => {
+  const {
+    getTimestampPreviewForField,
+    isProtectedKeyColumn,
+  } = await loadTimestampPreviewModule();
+  const tableMeta = createTableMeta();
+
+  assert.equal(isProtectedKeyColumn("id", tableMeta), true);
+  assert.equal(isProtectedKeyColumn("parent_id", tableMeta), true);
+
+  assert.equal(
+    getTimestampPreviewForField({
+      columnName: "id",
+      value: "1717682400",
+      tableMeta,
+    }).kind,
+    "protected-key"
+  );
+  assert.equal(
+    getTimestampPreviewForField({
+      columnName: "parent_id",
+      value: "1717682400",
+      tableMeta,
+    }).kind,
+    "protected-key"
+  );
+});
+
+test("row editor timestamp preview formats plausible non-key timestamp values", async () => {
+  const { getTimestampPreviewForField } = await loadTimestampPreviewModule();
+  const tableMeta = createTableMeta();
+
+  const createdAtPreview = getTimestampPreviewForField({
+    columnName: "created_at",
+    value: "1717682400",
+    tableMeta,
+  });
+  const updatedAtPreview = getTimestampPreviewForField({
+    columnName: "updated_at",
+    value: "1717682400000",
+    tableMeta,
+  });
+  const pricePreview = getTimestampPreviewForField({
+    columnName: "price",
+    value: "1717682400",
+    tableMeta,
+  });
+  const publishedAtPreview = getTimestampPreviewForField({
+    columnName: "published_at",
+    value: "1717682400000000",
+    tableMeta,
+  });
+
+  assert.equal(createdAtPreview.kind, "timestamp");
+  assert.equal(createdAtPreview.sourceFormat, "unix-seconds");
+  assert.equal(updatedAtPreview.kind, "timestamp");
+  assert.equal(updatedAtPreview.sourceFormat, "unix-milliseconds");
+  assert.equal(publishedAtPreview.kind, "timestamp");
+  assert.equal(publishedAtPreview.sourceFormat, "unix-microseconds");
+  assert.equal(pricePreview.kind, "timestamp");
+  assert.match(createdAtPreview.formatted, /^\d{2}\.\d{2}\.\d{4}, \d{2}:\d{2}:\d{2}$/);
+});
+
+test("row editor timestamp preview ignores ids and invalid timestamps", async () => {
+  const { getTimestampPreviewForField } = await loadTimestampPreviewModule();
+  const tableMeta = createTableMeta();
+
+  assert.equal(
+    getTimestampPreviewForField({
+      columnName: "external_id",
+      value: "1717682400",
+      tableMeta,
+    }).kind,
+    "none"
+  );
+  assert.equal(
+    getTimestampPreviewForField({
+      columnName: "created_at",
+      value: "42",
+      tableMeta,
+    }).kind,
+    "none"
+  );
+  assert.equal(
+    getTimestampPreviewForField({
+      columnName: "created_at",
+      value: "not a timestamp",
+      tableMeta,
+    }).kind,
+    "none"
+  );
+});
+
+test("row editor timestamp preview accepts ISO and SQLite datetime strings", async () => {
+  const { getTimestampPreviewForField } = await loadTimestampPreviewModule();
+  const tableMeta = createTableMeta();
+
+  assert.equal(
+    getTimestampPreviewForField({
+      columnName: "created_at",
+      value: "2026-06-06T18:49:00Z",
+      tableMeta,
+    }).kind,
+    "timestamp"
+  );
+  assert.equal(
+    getTimestampPreviewForField({
+      columnName: "updated_at",
+      value: "2026-06-06 18:49:00",
+      tableMeta,
+    }).kind,
+    "timestamp"
+  );
+});
+
+test("row update stores the submitted raw value without date conversion", () => {
+  const db = new Database(":memory:");
+
+  try {
+    db.exec(`
+      CREATE TABLE events (
+        id INTEGER PRIMARY KEY,
+        created_at TEXT
+      );
+      INSERT INTO events (id, created_at) VALUES (1, 'before');
+    `);
+
+    const service = new DataBrowserService({
+      connectionManager: {
+        assertWritable() {},
+        getActiveDatabase: () => db,
+      },
+    });
+    const tableData = service.getTableData("events", { limit: 10, offset: 0 });
+    const identity = tableData.rows[0].__identity;
+
+    service.updateTableRow("events", {
+      identity,
+      values: {
+        created_at: "1717682400",
+      },
+    });
+
+    assert.equal(
+      db.prepare("SELECT created_at FROM events WHERE id = 1").get().created_at,
+      "1717682400"
+    );
+  } finally {
+    db.close();
+  }
+});

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>`));
+  }
+});