sqlite-hub 1.2.0 → 1.4.0

package/tests/email-preview.test.js

@@ -1,89 +0,0 @@
-const assert = require("node:assert/strict");
-const path = require("node:path");
-const { pathToFileURL } = require("node:url");
-const test = require("node:test");
-
-async function loadEmailPreviewModule() {
-  return import(pathToFileURL(path.resolve(__dirname, "../frontend/js/utils/emailPreview.js")).href);
-}
-
-async function loadDataViewModule() {
-  return import(pathToFileURL(path.resolve(__dirname, "../frontend/js/views/data.js")).href);
-}
-
-async function loadRowEditorPanelModule() {
-  return import(pathToFileURL(path.resolve(__dirname, "../frontend/js/components/rowEditorPanel.js")).href);
-}
-
-test("email preview detects simple email values only", async () => {
-  const { detectEmailValue } = await loadEmailPreviewModule();
-
-  assert.deepEqual(detectEmailValue("oli@example.com"), {
-    type: "email",
-    value: "oli@example.com",
-    localPart: "oli",
-    domain: "example.com",
-  });
-  assert.equal(detectEmailValue("https://example.com"), null);
-  assert.equal(detectEmailValue("not an email"), null);
-  assert.equal(detectEmailValue(null), null);
-});
-
-test("data table renders an email icon for email cells", async () => {
-  const { renderDataView } = await loadDataViewModule();
-  const rendered = renderDataView({
-    connections: {
-      active: { readOnly: false },
-    },
-    dataBrowser: {
-      error: null,
-      loading: false,
-      page: 1,
-      pageSize: 50,
-      selectedRowIndex: null,
-      selectedTable: "contacts",
-      tableSearchQuery: "",
-      tables: [{ name: "contacts", columnCount: 2 }],
-      tablesVisible: true,
-      table: {
-        name: "contacts",
-        columns: ["id", "email"],
-        columnMeta: [
-          { name: "id", visible: true, primaryKeyPosition: 1, affinity: "INTEGER" },
-          { name: "email", visible: true, affinity: "TEXT" },
-        ],
-        foreignKeys: [],
-        rows: [{ id: 1, email: "oli@example.com" }],
-        rowCount: 1,
-        page: 1,
-        pageCount: 1,
-        offset: 0,
-        limit: 50,
-      },
-    },
-  }).main;
-
-  assert.match(rendered, /alternate_email/);
-  assert.match(rendered, /oli@example\.com/);
-});
-
-test("row editor renders an email badge for email fields", async () => {
-  const { renderRowEditorPanel } = await loadRowEditorPanelModule();
-  const rendered = renderRowEditorPanel({
-    title: "contacts",
-    closeAction: "close",
-    formName: "save-data-row",
-    editableFields: [
-      {
-        name: "email",
-        label: "email",
-        badges: [{ label: "TEXT", tone: "type" }],
-        value: "oli@example.com",
-        rawValue: "oli@example.com",
-      },
-    ],
-  });
-
-  assert.match(rendered, /EMAIL/);
-  assert.match(rendered, /data-row-editor-email-field/);
-});

package/tests/export-blob.test.js

@@ -1,99 +0,0 @@
-const Database = require("better-sqlite3");
-const assert = require("node:assert/strict");
-const parquet = require("parquetjs-lite");
-const test = require("node:test");
-const { ExportService } = require("../server/services/sqlite/exportService");
-const { SqlExecutor } = require("../server/services/sqlite/sqlExecutor");
-
-async function readParquetRows(buffer) {
-  const reader = await parquet.ParquetReader.openBuffer(buffer);
-  const cursor = reader.getCursor();
-  const rows = [];
-
-  try {
-    let row;
-
-    while ((row = await cursor.next())) {
-      rows.push(row);
-    }
-  } finally {
-    await reader.close();
-  }
-
-  return rows;
-}
-
-test("query and table exports include complete BLOB data", async () => {
-  const db = new Database(":memory:");
-  const blob = Buffer.from(Array.from({ length: 100 }, (_, index) => index));
-
-  try {
-    db.exec("CREATE TABLE files (id INTEGER PRIMARY KEY, payload BLOB)");
-    db.prepare("INSERT INTO files (payload) VALUES (?)").run(blob);
-
-    const connection = { id: "blob-export-test", label: "Blob export" };
-    const connectionManager = {
-      getActiveConnection: () => connection,
-      getActiveDatabase: () => db,
-    };
-    const appStateStore = {
-      findQueryHistoryItemBySql: () => null,
-      getSettings: () => ({ csvDelimiter: "," }),
-      recordQueryExecution: () => 1,
-    };
-    const sqlExecutor = new SqlExecutor({ connectionManager, appStateStore });
-    const exportService = new ExportService({
-      appStateStore,
-      connectionManager,
-      sqlExecutor,
-    });
-    const expectedBase64 = blob.toString("base64");
-    const queryExport = exportService.exportQuery(
-      "SELECT payload FROM files ORDER BY id",
-      { format: "csv" }
-    );
-    const queryJsonExport = exportService.exportQuery(
-      "SELECT payload FROM files ORDER BY id",
-      { format: "json" }
-    );
-    const tableExport = exportService.exportTable("files", { format: "tsv" });
-    const jsonExport = exportService.exportTable("files", { format: "json" });
-    const queryParquetExport = await exportService.exportQueryDownload(
-      "SELECT id, payload FROM files ORDER BY id",
-      { format: "parquet" }
-    );
-    const tableParquetExport = await exportService.exportTableDownload("files", { format: "parquet" });
-
-    for (const content of [queryExport.content, tableExport.content]) {
-      assert.equal(content.includes(expectedBase64), true);
-      assert.match(content, /""encoding"":""base64""/);
-      assert.doesNotMatch(content, /base64Preview|hexPreview/);
-    }
-
-    assert.equal(jsonExport.mimeType, "application/json; charset=utf-8");
-    assert.equal(jsonExport.filename, "files.json");
-
-    const [queryJsonRow] = JSON.parse(queryJsonExport.content);
-    const [jsonRow] = JSON.parse(jsonExport.content);
-    assert.equal(queryJsonExport.mimeType, "application/json; charset=utf-8");
-    assert.equal(queryJsonRow.payload.encoding, "base64");
-    assert.equal(queryJsonRow.payload.data, expectedBase64);
-    assert.equal(jsonRow.payload.encoding, "base64");
-    assert.equal(jsonRow.payload.data, expectedBase64);
-    assert.equal(jsonRow.payload.sizeBytes, blob.length);
-    assert.equal(jsonExport.content.includes("base64Preview"), false);
-    assert.equal(jsonExport.content.includes("hexPreview"), false);
-
-    assert.equal(queryParquetExport.mimeType, "application/vnd.apache.parquet");
-    assert.equal(queryParquetExport.filename.endsWith(".parquet"), true);
-    assert.equal(Buffer.isBuffer(queryParquetExport.content), true);
-    assert.equal(tableParquetExport.filename, "files.parquet");
-
-    const [queryParquetRow] = await readParquetRows(queryParquetExport.content);
-    const [tableParquetRow] = await readParquetRows(tableParquetExport.content);
-    assert.equal(queryParquetRow.payload.equals(blob), true);
-    assert.equal(tableParquetRow.payload.equals(blob), true);
-  } finally {
-    db.close();
-  }
-});

package/tests/export-filenames.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 exportFilenamesModulePromise = null;
-
-function loadExportFilenamesModule() {
-  if (!exportFilenamesModulePromise) {
-    const source = readFileSync(
-      path.resolve(__dirname, "../frontend/js/utils/exportFilenames.js"),
-      "utf8"
-    );
-    const url = `data:text/javascript;base64,${Buffer.from(source).toString("base64")}`;
-
-    exportFilenamesModulePromise = import(url);
-  }
-
-  return exportFilenamesModulePromise;
-}
-
-test("text export filenames use the selected format extension", async () => {
-  const { buildTextExportFilename } = await loadExportFilenamesModule();
-
-  assert.equal(buildTextExportFilename("query-results.csv", { format: "tsv" }), "query-results.tsv");
-  assert.equal(buildTextExportFilename("white_house_live_streams", { format: "md" }), "white_house_live_streams.md");
-  assert.equal(buildTextExportFilename("companies.tsv", { format: "json" }), "companies.json");
-  assert.equal(buildTextExportFilename("companies.json", { format: "parquet" }), "companies.parquet");
-});
-
-test("text export filenames sanitize unsafe names and fallback when empty", async () => {
-  const { buildTextExportFilename } = await loadExportFilenamesModule();
-
-  assert.equal(buildTextExportFilename("", { format: "csv", fallback: "table" }), "table.csv");
-  assert.equal(buildTextExportFilename("../bad:name?.csv", { format: "csv", fallback: "table" }), "bad name.csv");
-  assert.equal(buildTextExportFilename("bad:name?.json", { format: "json", fallback: "table" }), "bad name.json");
-  assert.equal(buildTextExportFilename("bad:name?.parquet", { format: "parquet", fallback: "table" }), "bad name.parquet");
-});

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

@@ -1,165 +0,0 @@
-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/form-controls.test.js

@@ -1,34 +0,0 @@
-const assert = require('node:assert/strict');
-const path = require('node:path');
-const { pathToFileURL } = require('node:url');
-const test = require('node:test');
-
-let formControlsModulePromise = null;
-
-function loadFormControlsModule() {
-    if (!formControlsModulePromise) {
-        formControlsModulePromise = import(
-            pathToFileURL(path.resolve(__dirname, '../frontend/js/components/formControls.js')).href
-        );
-    }
-
-    return formControlsModulePromise;
-}
-
-test('standard text input uses the shared application styling', async () => {
-    const { renderTextInput } = await loadFormControlsModule();
-    const markup = renderTextInput({
-        className: 'flex-1',
-        dataAttributes: { tokenName: true },
-        maxlength: 80,
-        placeholder: 'Token name',
-    });
-
-    assert.match(markup, /control-input/);
-    assert.match(markup, /border-outline-variant\/20/);
-    assert.match(markup, /bg-surface-container-lowest/);
-    assert.match(markup, /placeholder:text-on-surface-variant\/35/);
-    assert.match(markup, /focus:border-primary-container/);
-    assert.match(markup, /data-token-name/);
-    assert.match(markup, /maxlength="80"/);
-});

package/tests/json-preview.test.js

@@ -1,49 +0,0 @@
-const assert = require("node:assert/strict");
-const { readFileSync } = require("node:fs");
-const path = require("node:path");
-const test = require("node:test");
-
-let jsonPreviewModulePromise = null;
-
-function loadJsonPreviewModule() {
-  if (!jsonPreviewModulePromise) {
-    const source = readFileSync(
-      path.resolve(__dirname, "../frontend/js/utils/jsonPreview.js"),
-      "utf8"
-    );
-    const url = `data:text/javascript;base64,${Buffer.from(source).toString("base64")}`;
-
-    jsonPreviewModulePromise = import(url);
-  }
-
-  return jsonPreviewModulePromise;
-}
-
-test("JSON preview formats objects and arrays with line breaks and indentation", async () => {
-  const { formatJsonPreview } = await loadJsonPreviewModule();
-
-  assert.equal(
-    formatJsonPreview('{"event":"created","metadata":{"source":"api"}}'),
-    [
-      "{",
-      '  "event": "created",',
-      '  "metadata": {',
-      '    "source": "api"',
-      "  }",
-      "}",
-    ].join("\n")
-  );
-  assert.equal(
-    formatJsonPreview([1, { active: true }]),
-    ["[", "  1,", "  {", '    "active": true', "  }", "]"].join("\n")
-  );
-});
-
-test("JSON preview ignores invalid JSON and scalar values", async () => {
-  const { formatJsonPreview } = await loadJsonPreviewModule();
-
-  assert.equal(formatJsonPreview("plain text"), null);
-  assert.equal(formatJsonPreview("{invalid"), null);
-  assert.equal(formatJsonPreview("42"), null);
-  assert.equal(formatJsonPreview(null), null);
-});

package/tests/local-request-security.test.js

@@ -1,85 +0,0 @@
-const assert = require("node:assert/strict");
-const test = require("node:test");
-const {
-  LOOPBACK_HOST,
-  listenOnLoopback,
-  localRequestSecurity,
-} = require("../server/middleware/localRequestSecurity");
-
-function runMiddleware({ method = "GET", protocol = "http", headers = {} } = {}) {
-  const normalizedHeaders = Object.fromEntries(
-    Object.entries(headers).map(([name, value]) => [name.toLowerCase(), value])
-  );
-  const req = {
-    method,
-    protocol,
-    get(name) {
-      return normalizedHeaders[String(name).toLowerCase()];
-    },
-  };
-
-  return new Promise((resolve) => {
-    localRequestSecurity(req, {}, (error) => resolve(error ?? null));
-  });
-}
-
-test("server listener binds explicitly to the IPv4 loopback address", () => {
-  let receivedArguments = null;
-  const listener = {};
-  const app = {
-    listen(...args) {
-      receivedArguments = args;
-      return listener;
-    },
-  };
-
-  assert.equal(listenOnLoopback(app, 4173), listener);
-  assert.deepEqual(receivedArguments, [4173, LOOPBACK_HOST]);
-});
-
-test("local API security accepts same-origin browser and CLI requests", async () => {
-  assert.equal(
-    await runMiddleware({
-      method: "POST",
-      headers: {
-        host: "127.0.0.1:4173",
-        origin: "http://127.0.0.1:4173",
-        "sec-fetch-site": "same-origin",
-      },
-    }),
-    null
-  );
-  assert.equal(
-    await runMiddleware({
-      method: "POST",
-      headers: { host: "localhost:4173" },
-    }),
-    null
-  );
-});
-
-test("local API security rejects foreign hosts and cross-origin mutations", async () => {
-  const foreignHostError = await runMiddleware({
-    headers: { host: "example.test:4173" },
-  });
-  const crossOriginError = await runMiddleware({
-    method: "POST",
-    headers: {
-      host: "127.0.0.1:4173",
-      origin: "https://example.test",
-      "sec-fetch-site": "cross-site",
-    },
-  });
-  const wrongSchemeError = await runMiddleware({
-    method: "PATCH",
-    headers: {
-      host: "localhost:4173",
-      origin: "https://localhost:4173",
-    },
-  });
-
-  for (const error of [foreignHostError, crossOriginError, wrongSchemeError]) {
-    assert.equal(error?.statusCode, 403);
-    assert.equal(error?.code, "LOCAL_REQUEST_REQUIRED");
-  }
-});

package/tests/markdown-documents.test.js

@@ -1,103 +0,0 @@
-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 keeps JSON code block quotes readable", async () => {
-  const { renderMarkdownPreview } = await loadMarkdownModule();
-  const previousMarked = globalThis.marked;
-  let parsedSource = "";
-
-  globalThis.marked = {
-    parse: source => {
-      parsedSource = source;
-      return `<pre><code>${source}</code></pre>`;
-    },
-  };
-
-  try {
-    const html = renderMarkdownPreview(['<img src=x onerror="alert(1)">', '', '```json', '{"id":"abc"}', '```'].join("\n"));
-
-    assert.match(parsedSource, /&lt;img/);
-    assert.match(parsedSource, /"id":"abc"/);
-    assert.doesNotMatch(parsedSource, /&quot;id&quot;/);
-    assert.match(html, /"id":"abc"/);
-  } finally {
-    globalThis.marked = previousMarked;
-  }
-});
-
-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;
-  }
-});