sqlite-hub 0.12.0 → 0.17.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/markdown-documents.test.js

@@ -0,0 +1,79 @@
+const assert = require("node:assert/strict");
+const path = require("node:path");
+const { pathToFileURL } = require("node:url");
+const test = require("node:test");
+
+let markdownModulePromise = null;
+
+function loadMarkdownModule() {
+  if (!markdownModulePromise) {
+    markdownModulePromise = import(
+      pathToFileURL(path.resolve(__dirname, "../frontend/js/utils/markdownDocuments.js")).href
+    );
+  }
+
+  return markdownModulePromise;
+}
+
+test("markdown preview renders clickable todo checkboxes with source line indexes", async () => {
+  const { renderMarkdownPreview } = await loadMarkdownModule();
+  const html = renderMarkdownPreview(["# Tasks", "- [ ] item1", "- [x] item2", "```", "- [ ] code", "```"].join("\n"));
+
+  assert.match(html, /document-markdown-task-list/);
+  assert.match(html, /data-action="toggle-document-todo"/);
+  assert.match(html, /data-line-index="1"/);
+  assert.match(html, /data-line-index="2"/);
+  assert.doesNotMatch(html, /data-line-index="4"/);
+});
+
+test("markdown todo toggle updates only real task lines", async () => {
+  const { toggleMarkdownTodoLine } = await loadMarkdownModule();
+  const markdown = ["- [ ] item1", "```", "- [ ] code", "```", "- [x] item2"].join("\n");
+
+  assert.equal(toggleMarkdownTodoLine(markdown, 0).split("\n")[0], "- [x] item1");
+  assert.equal(toggleMarkdownTodoLine(markdown, 2), markdown);
+  assert.equal(toggleMarkdownTodoLine(markdown, 4).split("\n")[4], "- [ ] item2");
+});
+
+test("markdown preview fallback renders unordered and ordered lists", async () => {
+  const { renderMarkdownPreview } = await loadMarkdownModule();
+  const previousMarked = globalThis.marked;
+
+  globalThis.marked = undefined;
+
+  try {
+    const html = renderMarkdownPreview(["- alpha", "- beta", "", "1. first", "2. second"].join("\n"));
+
+    assert.match(html, /<ul><li>alpha<\/li><li>beta<\/li><\/ul>/);
+    assert.match(html, /<ol><li>first<\/li><li>second<\/li><\/ol>/);
+  } finally {
+    globalThis.marked = previousMarked;
+  }
+});
+
+test("markdown preview escapes raw html content", async () => {
+  const { renderMarkdownPreview } = await loadMarkdownModule();
+  const html = renderMarkdownPreview('<img src=x onerror="alert(1)">\n- [ ] <script>alert(1)</script>');
+
+  assert.doesNotMatch(html, /<script>/i);
+  assert.doesNotMatch(html, /<img/i);
+  assert.match(html, /&lt;script&gt;/);
+});
+
+test("markdown preview strips executable link targets from rendered markdown", async () => {
+  const { renderMarkdownPreview } = await loadMarkdownModule();
+  const previousMarked = globalThis.marked;
+
+  globalThis.marked = {
+    parse: () => '<p><a href="javascript:alert(1)">unsafe</a></p>',
+  };
+
+  try {
+    const html = renderMarkdownPreview("[unsafe](javascript:alert(1))");
+
+    assert.doesNotMatch(html, /href="javascript:/i);
+    assert.match(html, /href="#"/);
+  } finally {
+    globalThis.marked = previousMarked;
+  }
+});

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/settings-metadata.test.js

@@ -0,0 +1,16 @@
+const assert = require("node:assert/strict");
+const test = require("node:test");
+
+const { version } = require("../package.json");
+const { readSettingsMetadata, readSqliteVersion } = require("../server/routes/settings");
+
+test("settings metadata exposes app and SQLite versions", () => {
+  const metadata = readSettingsMetadata();
+
+  assert.equal(metadata.appVersion, version);
+  assert.match(metadata.sqliteVersion, /^\d+\.\d+\.\d+$/);
+});
+
+test("SQLite runtime version is readable", () => {
+  assert.match(readSqliteVersion(), /^\d+\.\d+\.\d+$/);
+});

package/tests/settings-view.test.js

@@ -0,0 +1,32 @@
+const assert = require("node:assert/strict");
+const path = require("node:path");
+const { pathToFileURL } = require("node:url");
+const test = require("node:test");
+
+let settingsViewModulePromise = null;
+
+function loadSettingsViewModule() {
+  if (!settingsViewModulePromise) {
+    settingsViewModulePromise = import(
+      pathToFileURL(path.resolve(__dirname, "../frontend/js/views/settings.js")).href
+    );
+  }
+
+  return settingsViewModulePromise;
+}
+
+test("settings view shows SQLite runtime version and custom port command", async () => {
+  const { renderSettingsView } = await loadSettingsViewModule();
+  const rendered = renderSettingsView({
+    settings: {
+      loading: false,
+      error: null,
+      appVersion: "1.2.3",
+      sqliteVersion: "3.53.1",
+    },
+  });
+
+  assert.match(rendered.main, /SQLite_Runtime/);
+  assert.match(rendered.main, /3\.53\.1/);
+  assert.match(rendered.main, /sqlite-hub --port:PORT/);
+});