sqlite-hub 0.17.0 → 0.17.2

package/server/services/nativeFileDialogService.js

@@ -0,0 +1,168 @@
+const path = require("node:path");
+const os = require("node:os");
+const { execFile } = require("node:child_process");
+const { promisify } = require("node:util");
+const { AppError } = require("../utils/errors");
+
+const execFileAsync = promisify(execFile);
+const DEFAULT_DATABASE_FILENAME = "new-database.sqlite";
+
+function escapePowerShellSingleQuotedString(value) {
+  return String(value).replaceAll("'", "''");
+}
+
+function buildDialogAttempts({ platform = process.platform, homeDirectory = os.homedir() } = {}) {
+  const defaultPath = path.join(homeDirectory, DEFAULT_DATABASE_FILENAME);
+
+  if (platform === "darwin") {
+    return [
+      {
+        command: "osascript",
+        args: [
+          "-e",
+          "on run argv",
+          "-e",
+          'set selectedFile to choose file name with prompt "Create SQLite Database" default location POSIX file (item 1 of argv) default name (item 2 of argv)',
+          "-e",
+          "return POSIX path of selectedFile",
+          "-e",
+          "end run",
+          homeDirectory,
+          DEFAULT_DATABASE_FILENAME,
+        ],
+        cancelledExitCodes: new Set([1]),
+        cancelledErrorPattern: /user canceled|-128/i,
+      },
+    ];
+  }
+
+  if (platform === "win32") {
+    const initialDirectory = escapePowerShellSingleQuotedString(homeDirectory);
+    const script = [
+      "Add-Type -AssemblyName System.Windows.Forms",
+      "$dialog = New-Object System.Windows.Forms.SaveFileDialog",
+      "$dialog.Title = 'Create SQLite Database'",
+      "$dialog.Filter = 'SQLite databases (*.db;*.sqlite;*.sqlite3)|*.db;*.sqlite;*.sqlite3|All files (*.*)|*.*'",
+      "$dialog.DefaultExt = 'sqlite'",
+      "$dialog.AddExtension = $true",
+      `$dialog.InitialDirectory = '${initialDirectory}'`,
+      `$dialog.FileName = '${DEFAULT_DATABASE_FILENAME}'`,
+      "if ($dialog.ShowDialog() -eq [System.Windows.Forms.DialogResult]::OK) {",
+      "  [Console]::Out.Write($dialog.FileName)",
+      "} else {",
+      "  exit 2",
+      "}",
+    ].join("; ");
+
+    return [
+      {
+        command: "powershell.exe",
+        args: ["-NoProfile", "-STA", "-Command", script],
+        cancelledExitCodes: new Set([2]),
+      },
+    ];
+  }
+
+  return [
+    {
+      command: "zenity",
+      args: [
+        "--file-selection",
+        "--save",
+        "--title=Create SQLite Database",
+        `--filename=${defaultPath}`,
+        "--file-filter=SQLite databases | *.db *.sqlite *.sqlite3",
+        "--file-filter=All files | *",
+      ],
+      cancelledExitCodes: new Set([1]),
+    },
+    {
+      command: "kdialog",
+      args: [
+        "--getsavefilename",
+        defaultPath,
+        "SQLite databases (*.db *.sqlite *.sqlite3)",
+        "--title",
+        "Create SQLite Database",
+      ],
+      cancelledExitCodes: new Set([1]),
+    },
+  ];
+}
+
+function normalizeSelectedDatabasePath(value) {
+  const selectedPath = String(value ?? "").trim();
+
+  if (!selectedPath) {
+    return null;
+  }
+
+  return path.extname(selectedPath) ? selectedPath : `${selectedPath}.sqlite`;
+}
+
+function isMissingDialogCommand(error) {
+  return error?.code === "ENOENT";
+}
+
+function isCancelledDialog(error, attempt) {
+  if (!attempt.cancelledExitCodes.has(Number(error?.code))) {
+    return false;
+  }
+
+  if (!attempt.cancelledErrorPattern) {
+    return true;
+  }
+
+  return attempt.cancelledErrorPattern.test(`${error?.message ?? ""}\n${error?.stderr ?? ""}`);
+}
+
+class NativeFileDialogService {
+  constructor(options = {}) {
+    this.platform = options.platform ?? process.platform;
+    this.homeDirectory = options.homeDirectory ?? os.homedir();
+    this.executeFile = options.executeFile ?? execFileAsync;
+  }
+
+  async chooseCreateDatabasePath() {
+    const attempts = buildDialogAttempts({
+      platform: this.platform,
+      homeDirectory: this.homeDirectory,
+    });
+
+    for (const attempt of attempts) {
+      try {
+        const result = await this.executeFile(attempt.command, attempt.args, {
+          maxBuffer: 64 * 1024,
+          windowsHide: true,
+        });
+
+        return normalizeSelectedDatabasePath(result?.stdout);
+      } catch (error) {
+        if (isCancelledDialog(error, attempt)) {
+          return null;
+        }
+
+        if (isMissingDialogCommand(error)) {
+          continue;
+        }
+
+        throw new AppError("The native file dialog could not be opened.", 500, {
+          code: "NATIVE_FILE_DIALOG_FAILED",
+          details: { platform: this.platform },
+        });
+      }
+    }
+
+    throw new AppError("No supported native file dialog is available on this system.", 501, {
+      code: "NATIVE_FILE_DIALOG_UNAVAILABLE",
+      details: { platform: this.platform },
+    });
+  }
+}
+
+module.exports = {
+  DEFAULT_DATABASE_FILENAME,
+  NativeFileDialogService,
+  buildDialogAttempts,
+  normalizeSelectedDatabasePath,
+};

package/server/services/sqlite/dataBrowserService.js

@@ -74,10 +74,6 @@ function formatPreviewValue(value) {
 }
 
 function isUnchangedSubmittedValue(currentValue, submittedValue) {
-  if (currentValue === null && submittedValue === "") {
-    return true;
-  }
-
   return formatPreviewValue(currentValue) === formatPreviewValue(submittedValue);
 }
 

package/server/services/sqlite/exportService.js

@@ -91,6 +91,8 @@ class ExportService {
         })
     );
     const result = this.sqlExecutor.execute(sql, {
+      blobMode: "full",
+      maxRows: null,
       persistHistory: false,
       requireReader: true,
     });
@@ -132,7 +134,9 @@ class ExportService {
         .filter(Boolean)
         .join(" ")
     );
-    const rows = serializeRows(statement.all(...(filter?.params ?? [])));
+    const rows = serializeRows(statement.all(...(filter?.params ?? [])), {
+      blobMode: "full",
+    });
     const columns = statement.columns().map((column) => column.name);
     const content = renderExportContent({
       columns,

package/server/services/sqlite/sqlExecutor.js

@@ -2,6 +2,45 @@ const { ValidationError, mapSqliteError } = require("../../utils/errors");
 const { serializeRows } = require("../../utils/sqliteTypes");
 const { getTableDetail } = require("./introspection");
 
+const DEFAULT_RESULT_ROW_LIMIT = 5000;
+
+function normalizeResultRowLimit(value) {
+  if (value === null || value === false) {
+    return null;
+  }
+
+  const normalized = value === undefined ? DEFAULT_RESULT_ROW_LIMIT : Number(value);
+
+  if (!Number.isInteger(normalized) || normalized < 1) {
+    throw new ValidationError("SQL result row limit must be a positive integer or null.");
+  }
+
+  return normalized;
+}
+
+function readResultRows(prepared, rowLimit) {
+  if (rowLimit === null) {
+    return {
+      rows: prepared.all(),
+      truncated: false,
+    };
+  }
+
+  const rows = [];
+  let truncated = false;
+
+  for (const row of prepared.iterate()) {
+    if (rows.length >= rowLimit) {
+      truncated = true;
+      break;
+    }
+
+    rows.push(row);
+  }
+
+  return { rows, truncated };
+}
+
 function getSerializedMemoryBytes(value) {
   try {
     return Buffer.byteLength(JSON.stringify(value ?? null), "utf8");
@@ -365,6 +404,7 @@ class SqlExecutor {
     const db = this.connectionManager.getActiveDatabase();
     const connection = this.connectionManager.getActiveConnection();
     const statements = splitSqlStatements(sql);
+    const rowLimit = normalizeResultRowLimit(options.maxRows);
 
     if (statements.length === 0) {
       throw new ValidationError("No executable SQL statements were found.");
@@ -386,9 +426,11 @@ class SqlExecutor {
         }
 
         if (prepared.reader) {
-          const rows = prepared.all();
+          const { rows, truncated } = readResultRows(prepared, rowLimit);
           const columnDefinitions = prepared.columns();
-          const serializedRows = serializeRows(rows);
+          const serializedRows = serializeRows(rows, {
+            blobMode: options.blobMode,
+          });
           const editableResult = resolveEditableResult(db, columnDefinitions, serializedRows);
           const columns = columnDefinitions.map((column) => column.name);
           const result = {
@@ -397,6 +439,8 @@ class SqlExecutor {
             keyword,
             kind: "resultSet",
             rowCount: serializedRows.length,
+            truncated,
+            rowLimit,
             columns,
             rows: editableResult?.rows ?? serializedRows,
             editing: editableResult
@@ -463,6 +507,8 @@ class SqlExecutor {
       rows: lastResultSet?.rows ?? [],
       columns: lastResultSet?.columns ?? [],
       editing: lastResultSet?.editing ?? null,
+      truncated: Boolean(lastResultSet?.truncated),
+      rowLimit: lastResultSet ? lastResultSet.rowLimit : null,
       affectedRowCount: totalChanges,
       resultKind: lastResultSet ? "resultSet" : results.at(-1)?.kind ?? "unknown",
     };
@@ -490,6 +536,9 @@ class SqlExecutor {
 }
 
 module.exports = {
+  DEFAULT_RESULT_ROW_LIMIT,
   SqlExecutor,
+  normalizeResultRowLimit,
+  readResultRows,
   splitSqlStatements,
 };

package/server/utils/sqliteTypes.js

@@ -37,7 +37,16 @@ function normalizeDeclaredType(type) {
   return { declaredType, affinity: "NUMERIC" };
 }
 
-function serializeBlob(buffer) {
+function serializeBlob(buffer, options = {}) {
+  if (options.blobMode === "full") {
+    return {
+      __type: "blob",
+      sizeBytes: buffer.length,
+      encoding: "base64",
+      data: buffer.toString("base64"),
+    };
+  }
+
   return {
     __type: "blob",
     sizeBytes: buffer.length,
@@ -46,26 +55,26 @@ function serializeBlob(buffer) {
   };
 }
 
-function serializeSqliteValue(value) {
+function serializeSqliteValue(value, options = {}) {
   if (Buffer.isBuffer(value)) {
-    return serializeBlob(value);
+    return serializeBlob(value, options);
   }
 
   if (value instanceof Uint8Array) {
-    return serializeBlob(Buffer.from(value));
+    return serializeBlob(Buffer.from(value), options);
   }
 
   return value;
 }
 
-function serializeRow(row) {
+function serializeRow(row, options = {}) {
   return Object.fromEntries(
-    Object.entries(row).map(([key, value]) => [key, serializeSqliteValue(value)])
+    Object.entries(row).map(([key, value]) => [key, serializeSqliteValue(value, options)])
   );
 }
 
-function serializeRows(rows) {
-  return rows.map((row) => serializeRow(row));
+function serializeRows(rows, options = {}) {
+  return rows.map((row) => serializeRow(row, options));
 }
 
 function decodeBlobPayload(payload) {

package/tests/connections-file-dialog-route.test.js

@@ -0,0 +1,46 @@
+const assert = require("node:assert/strict");
+const express = require("express");
+const test = require("node:test");
+const { createConnectionsRouter } = require("../server/routes/connections");
+const { errorMiddleware } = require("../server/utils/errors");
+
+test("connections route returns the path selected by the native dialog", async () => {
+  const app = express();
+  app.use(express.json());
+  app.use(
+    "/api/connections",
+    createConnectionsRouter({
+      connectionManager: {},
+      importService: {},
+      backupService: {},
+      nativeFileDialogService: {
+        chooseCreateDatabasePath: async () => "/tmp/new-database.sqlite",
+      },
+    })
+  );
+  app.use(errorMiddleware);
+
+  const server = await new Promise((resolve) => {
+    const listener = app.listen(0, "127.0.0.1", () => resolve(listener));
+  });
+
+  try {
+    const address = server.address();
+    const response = await fetch(
+      `http://127.0.0.1:${address.port}/api/connections/choose-create-path`,
+      { method: "POST" }
+    );
+    const payload = await response.json();
+
+    assert.equal(response.status, 200);
+    assert.equal(payload.success, true);
+    assert.deepEqual(payload.data, {
+      cancelled: false,
+      path: "/tmp/new-database.sqlite",
+    });
+  } finally {
+    await new Promise((resolve, reject) => {
+      server.close((error) => (error ? reject(error) : resolve()));
+    });
+  }
+});

package/tests/copy-column-modal.test.js

@@ -81,3 +81,17 @@ test("modal footer close buttons are not right-aligned", () => {
     /'<div class="[^']*justify-end[^']*pt-2[^']*>'[\s\S]{0,500}?data-action="close-modal"/
   );
 });
+
+test("create database modal offers a native path picker and manual fallback", async () => {
+  const { renderCreateDatabaseForm } = await loadModalModule();
+  const html = renderCreateDatabaseForm({
+    kind: "create-connection",
+    error: null,
+    submitting: false,
+  });
+
+  assert.match(html, /data-action="choose-create-database-path"/);
+  assert.match(html, /data-create-database-path/);
+  assert.match(html, /name="path"/);
+  assert.match(html, /enter an absolute path manually/);
+});

package/tests/export-blob.test.js

@@ -0,0 +1,46 @@
+const Database = require("better-sqlite3");
+const assert = require("node:assert/strict");
+const test = require("node:test");
+const { ExportService } = require("../server/services/sqlite/exportService");
+const { SqlExecutor } = require("../server/services/sqlite/sqlExecutor");
+
+test("query and table exports include complete BLOB data", () => {
+  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 tableExport = exportService.exportTable("files", { format: "tsv" });
+
+    for (const content of [queryExport.content, tableExport.content]) {
+      assert.equal(content.includes(expectedBase64), true);
+      assert.match(content, /""encoding"":""base64""/);
+      assert.doesNotMatch(content, /base64Preview|hexPreview/);
+    }
+  } finally {
+    db.close();
+  }
+});

package/tests/json-preview.test.js

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

@@ -0,0 +1,85 @@
+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/native-file-dialog.test.js

@@ -0,0 +1,78 @@
+const assert = require("node:assert/strict");
+const test = require("node:test");
+const {
+  NativeFileDialogService,
+  buildDialogAttempts,
+  normalizeSelectedDatabasePath,
+} = require("../server/services/nativeFileDialogService");
+
+test("native database dialog normalizes paths and adds a default extension", () => {
+  assert.equal(normalizeSelectedDatabasePath("/tmp/customer-data"), "/tmp/customer-data.sqlite");
+  assert.equal(normalizeSelectedDatabasePath("/tmp/customer-data.db\n"), "/tmp/customer-data.db");
+  assert.equal(normalizeSelectedDatabasePath(""), null);
+});
+
+test("native database dialog builds platform-specific save commands", () => {
+  const macAttempt = buildDialogAttempts({ platform: "darwin", homeDirectory: "/Users/test" })[0];
+  const windowsAttempt = buildDialogAttempts({ platform: "win32", homeDirectory: "C:\\Users\\test" })[0];
+  const linuxAttempts = buildDialogAttempts({ platform: "linux", homeDirectory: "/home/test" });
+
+  assert.equal(macAttempt.command, "osascript");
+  assert.match(macAttempt.args.join(" "), /choose file name/);
+  assert.equal(windowsAttempt.command, "powershell.exe");
+  assert.match(windowsAttempt.args.at(-1), /SaveFileDialog/);
+  assert.deepEqual(linuxAttempts.map((attempt) => attempt.command), ["zenity", "kdialog"]);
+});
+
+test("native database dialog returns null when the user cancels", async () => {
+  const service = new NativeFileDialogService({
+    platform: "darwin",
+    homeDirectory: "/Users/test",
+    executeFile: async () => {
+      const error = new Error("User canceled.");
+      error.code = 1;
+      throw error;
+    },
+  });
+
+  assert.equal(await service.chooseCreateDatabasePath(), null);
+});
+
+test("native database dialog does not hide macOS script failures as cancellations", async () => {
+  const service = new NativeFileDialogService({
+    platform: "darwin",
+    homeDirectory: "/Users/test",
+    executeFile: async () => {
+      const error = new Error("AppleScript syntax error");
+      error.code = 1;
+      throw error;
+    },
+  });
+
+  await assert.rejects(service.chooseCreateDatabasePath(), (error) => {
+    assert.equal(error.code, "NATIVE_FILE_DIALOG_FAILED");
+    return true;
+  });
+});
+
+test("native database dialog falls back from zenity to kdialog", async () => {
+  const commands = [];
+  const service = new NativeFileDialogService({
+    platform: "linux",
+    homeDirectory: "/home/test",
+    executeFile: async (command) => {
+      commands.push(command);
+
+      if (command === "zenity") {
+        const error = new Error("not found");
+        error.code = "ENOENT";
+        throw error;
+      }
+
+      return { stdout: "/home/test/catalog.sqlite3\n" };
+    },
+  });
+
+  assert.equal(await service.chooseCreateDatabasePath(), "/home/test/catalog.sqlite3");
+  assert.deepEqual(commands, ["zenity", "kdialog"]);
+});

package/tests/query-results-truncation.test.js

@@ -0,0 +1,20 @@
+const assert = require("node:assert/strict");
+const path = require("node:path");
+const test = require("node:test");
+const { pathToFileURL } = require("node:url");
+
+test("query results render an explicit truncation notice", async () => {
+  const moduleUrl = pathToFileURL(
+    path.resolve(__dirname, "../frontend/js/components/queryResults.js")
+  ).href;
+  const { renderQueryResultsPane } = await import(moduleUrl);
+  const html = renderQueryResultsPane({
+    columns: ["id"],
+    rows: [{ id: 1 }, { id: 2 }],
+    truncated: true,
+    rowLimit: 2,
+  });
+
+  assert.match(html, /Showing the first 2 rows/);
+  assert.match(html, /export it to process the complete result set/);
+});