sqlite-hub 0.17.2 → 1.1.0

package/server/services/nativeFileDialogService.js

@@ -90,6 +90,79 @@ function buildDialogAttempts({ platform = process.platform, homeDirectory = os.h
   ];
 }
 
+function buildOpenDialogAttempts({ platform = process.platform, homeDirectory = os.homedir() } = {}) {
+  if (platform === "darwin") {
+    return [
+      {
+        command: "osascript",
+        args: [
+          "-e",
+          "on run argv",
+          "-e",
+          'set selectedFile to choose file with prompt "Open SQLite Database" default location POSIX file (item 1 of argv)',
+          "-e",
+          "return POSIX path of selectedFile",
+          "-e",
+          "end run",
+          homeDirectory,
+        ],
+        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.OpenFileDialog",
+      "$dialog.Title = 'Open SQLite Database'",
+      "$dialog.Filter = 'SQLite databases (*.db;*.sqlite;*.sqlite3)|*.db;*.sqlite;*.sqlite3|All files (*.*)|*.*'",
+      "$dialog.CheckFileExists = $true",
+      `$dialog.InitialDirectory = '${initialDirectory}'`,
+      "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",
+        "--title=Open SQLite Database",
+        `--filename=${homeDirectory}${path.sep}`,
+        "--file-filter=SQLite databases | *.db *.sqlite *.sqlite3",
+        "--file-filter=All files | *",
+      ],
+      cancelledExitCodes: new Set([1]),
+    },
+    {
+      command: "kdialog",
+      args: [
+        "--getopenfilename",
+        homeDirectory,
+        "SQLite databases (*.db *.sqlite *.sqlite3);;All files (*)",
+        "--title",
+        "Open SQLite Database",
+      ],
+      cancelledExitCodes: new Set([1]),
+    },
+  ];
+}
+
 function normalizeSelectedDatabasePath(value) {
   const selectedPath = String(value ?? "").trim();
 
@@ -100,6 +173,10 @@ function normalizeSelectedDatabasePath(value) {
   return path.extname(selectedPath) ? selectedPath : `${selectedPath}.sqlite`;
 }
 
+function normalizeOpenedDatabasePath(value) {
+  return String(value ?? "").trim() || null;
+}
+
 function isMissingDialogCommand(error) {
   return error?.code === "ENOENT";
 }
@@ -129,6 +206,19 @@ class NativeFileDialogService {
       homeDirectory: this.homeDirectory,
     });
 
+    return this.runDialogAttempts(attempts, normalizeSelectedDatabasePath);
+  }
+
+  async chooseOpenDatabasePath() {
+    const attempts = buildOpenDialogAttempts({
+      platform: this.platform,
+      homeDirectory: this.homeDirectory,
+    });
+
+    return this.runDialogAttempts(attempts, normalizeOpenedDatabasePath);
+  }
+
+  async runDialogAttempts(attempts, normalizePath) {
     for (const attempt of attempts) {
       try {
         const result = await this.executeFile(attempt.command, attempt.args, {
@@ -136,7 +226,7 @@ class NativeFileDialogService {
           windowsHide: true,
         });
 
-        return normalizeSelectedDatabasePath(result?.stdout);
+        return normalizePath(result?.stdout);
       } catch (error) {
         if (isCancelledDialog(error, attempt)) {
           return null;
@@ -164,5 +254,7 @@ module.exports = {
   DEFAULT_DATABASE_FILENAME,
   NativeFileDialogService,
   buildDialogAttempts,
+  buildOpenDialogAttempts,
+  normalizeOpenedDatabasePath,
   normalizeSelectedDatabasePath,
 };

package/server/services/sqlite/exportService.js

@@ -1,5 +1,8 @@
+const { PassThrough } = require("node:stream");
+const parquet = require("parquetjs-lite");
 const { quoteIdentifier } = require("../../utils/identifier");
 const { serializeRows } = require("../../utils/sqliteTypes");
+const { ValidationError } = require("../../utils/errors");
 const {
   rowsToCsv,
   rowsToDelimitedText,
@@ -41,6 +44,14 @@ const EXPORT_FORMATS = {
     extension: "md",
     mimeType: "text/markdown; charset=utf-8",
   },
+  json: {
+    extension: "json",
+    mimeType: "application/json; charset=utf-8",
+  },
+  parquet: {
+    extension: "parquet",
+    mimeType: "application/vnd.apache.parquet",
+  },
 };
 
 function normalizeExportFormat(format) {
@@ -54,6 +65,20 @@ function normalizeExportFormat(format) {
 }
 
 function renderExportContent({ columns, rows, format, csvDelimiter }) {
+  if (format === "parquet") {
+    throw new ValidationError("Parquet exports are binary and must use a download endpoint.");
+  }
+
+  if (format === "json") {
+    return JSON.stringify(
+      rows.map((row) =>
+        Object.fromEntries(columns.map((column) => [column, row[column]]))
+      ),
+      null,
+      2
+    );
+  }
+
   if (format === "tsv") {
     return rowsToDelimitedText({ columns, rows, delimiter: "\t" });
   }
@@ -65,6 +90,206 @@ function renderExportContent({ columns, rows, format, csvDelimiter }) {
   return rowsToCsv({ columns, rows, delimiter: csvDelimiter });
 }
 
+function isSerializedBlob(value) {
+  return (
+    value &&
+    typeof value === "object" &&
+    value.__type === "blob" &&
+    typeof value.data === "string"
+  );
+}
+
+function getParquetValueKind(value) {
+  if (value === null || value === undefined) {
+    return null;
+  }
+
+  if (Buffer.isBuffer(value) || value instanceof Uint8Array || isSerializedBlob(value)) {
+    return "blob";
+  }
+
+  if (typeof value === "boolean") {
+    return "boolean";
+  }
+
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return Number.isInteger(value) ? "integer" : "number";
+  }
+
+  return "string";
+}
+
+function inferParquetColumnType(rows, column) {
+  const kinds = new Set();
+
+  for (const row of rows) {
+    const kind = getParquetValueKind(row?.[column]);
+
+    if (kind) {
+      kinds.add(kind);
+    }
+  }
+
+  if (kinds.size === 0) {
+    return "UTF8";
+  }
+
+  if (kinds.size === 1 && kinds.has("blob")) {
+    return "BYTE_ARRAY";
+  }
+
+  if (kinds.size === 1 && kinds.has("boolean")) {
+    return "BOOLEAN";
+  }
+
+  if (kinds.size === 1 && kinds.has("integer")) {
+    return "INT64";
+  }
+
+  if (
+    (kinds.size === 1 && kinds.has("number")) ||
+    (kinds.size === 2 && kinds.has("integer") && kinds.has("number"))
+  ) {
+    return "DOUBLE";
+  }
+
+  return "UTF8";
+}
+
+function stringifyParquetValue(value) {
+  if (value === null || value === undefined) {
+    return undefined;
+  }
+
+  if (typeof value === "string") {
+    return value;
+  }
+
+  if (Buffer.isBuffer(value)) {
+    return value.toString("base64");
+  }
+
+  if (value instanceof Uint8Array) {
+    return Buffer.from(value).toString("base64");
+  }
+
+  if (typeof value === "object") {
+    return JSON.stringify(value);
+  }
+
+  return String(value);
+}
+
+function normalizeParquetBlob(value) {
+  if (value === null || value === undefined) {
+    return undefined;
+  }
+
+  if (Buffer.isBuffer(value)) {
+    return value;
+  }
+
+  if (value instanceof Uint8Array) {
+    return Buffer.from(value);
+  }
+
+  if (isSerializedBlob(value)) {
+    return Buffer.from(value.data, value.encoding === "hex" ? "hex" : "base64");
+  }
+
+  return Buffer.from(stringifyParquetValue(value) ?? "", "utf8");
+}
+
+function normalizeParquetValue(value, type) {
+  if (value === null || value === undefined) {
+    return undefined;
+  }
+
+  if (type === "BYTE_ARRAY") {
+    return normalizeParquetBlob(value);
+  }
+
+  if (type === "BOOLEAN") {
+    return Boolean(value);
+  }
+
+  if (type === "INT64" || type === "DOUBLE") {
+    return Number(value);
+  }
+
+  return stringifyParquetValue(value);
+}
+
+function createParquetSchema(columns, rows) {
+  return new parquet.ParquetSchema(
+    Object.fromEntries(
+      columns.map((column) => [
+        column,
+        {
+          type: inferParquetColumnType(rows, column),
+          optional: true,
+        },
+      ])
+    )
+  );
+}
+
+async function rowsToParquetBuffer({ columns, rows }) {
+  const schema = createParquetSchema(columns, rows);
+  const output = new PassThrough();
+  const chunks = [];
+  const finished = new Promise((resolve, reject) => {
+    output.on("data", (chunk) => chunks.push(Buffer.from(chunk)));
+    output.on("end", resolve);
+    output.on("error", reject);
+  });
+  const writer = await parquet.ParquetWriter.openStream(schema, output, {
+    useDataPageV2: false,
+  });
+  const columnTypes = Object.fromEntries(
+    columns.map((column) => [column, schema.schema[column].type])
+  );
+
+  for (const row of rows) {
+    const parquetRow = {};
+
+    for (const column of columns) {
+      const value = normalizeParquetValue(row?.[column], columnTypes[column]);
+
+      if (value !== undefined) {
+        parquetRow[column] = value;
+      }
+    }
+
+    await writer.appendRow(parquetRow);
+  }
+
+  await writer.close();
+  await finished;
+
+  return Buffer.concat(chunks);
+}
+
+async function renderDownloadContent({ columns, rows, format, csvDelimiter }) {
+  if (format === "parquet") {
+    return rowsToParquetBuffer({ columns, rows });
+  }
+
+  return renderExportContent({ columns, rows, format, csvDelimiter });
+}
+
+function buildExportResult({ filenameBase, formatConfig, content, format, columns, rowCount }) {
+  return {
+    filename: `${filenameBase}.${formatConfig.extension}`,
+    content,
+    csv: format === "csv" ? content : undefined,
+    format,
+    mimeType: formatConfig.mimeType,
+    columns,
+    rowCount,
+  };
+}
+
 class ExportService {
   constructor({ appStateStore, connectionManager, sqlExecutor }) {
     this.appStateStore = appStateStore;
@@ -76,7 +301,7 @@ class ExportService {
     return this.appStateStore.getSettings().csvDelimiter || ",";
   }
 
-  exportQuery(sql, options = {}) {
+  buildQueryExportData(sql, options = {}) {
     const format = normalizeExportFormat(options.format);
     const formatConfig = EXPORT_FORMATS[format];
     const activeConnection = this.connectionManager.getActiveConnection();
@@ -96,25 +321,55 @@ class ExportService {
       persistHistory: false,
       requireReader: true,
     });
-    const content = renderExportContent({
+
+    return {
+      filenameBase,
+      format,
+      formatConfig,
       columns: result.columns,
       rows: result.rows,
-      format,
+    };
+  }
+
+  exportQuery(sql, options = {}) {
+    const exportData = this.buildQueryExportData(sql, options);
+    const content = renderExportContent({
+      columns: exportData.columns,
+      rows: exportData.rows,
+      format: exportData.format,
       csvDelimiter: this.getDelimiter(),
     });
 
-    return {
-      filename: `${filenameBase}.${formatConfig.extension}`,
+    return buildExportResult({
+      filenameBase: exportData.filenameBase,
+      formatConfig: exportData.formatConfig,
       content,
-      csv: format === "csv" ? content : undefined,
-      format,
-      mimeType: formatConfig.mimeType,
-      columns: result.columns,
-      rowCount: result.rows.length,
-    };
+      format: exportData.format,
+      columns: exportData.columns,
+      rowCount: exportData.rows.length,
+    });
   }
 
-  exportTable(tableName, options = {}) {
+  async exportQueryDownload(sql, options = {}) {
+    const exportData = this.buildQueryExportData(sql, options);
+    const content = await renderDownloadContent({
+      columns: exportData.columns,
+      rows: exportData.rows,
+      format: exportData.format,
+      csvDelimiter: this.getDelimiter(),
+    });
+
+    return buildExportResult({
+      filenameBase: exportData.filenameBase,
+      formatConfig: exportData.formatConfig,
+      content,
+      format: exportData.format,
+      columns: exportData.columns,
+      rowCount: exportData.rows.length,
+    });
+  }
+
+  buildTableExportData(tableName, options = {}) {
     const format = normalizeExportFormat(options.format);
     const formatConfig = EXPORT_FORMATS[format];
     const db = this.connectionManager.getActiveDatabase();
@@ -138,22 +393,52 @@ class ExportService {
       blobMode: "full",
     });
     const columns = statement.columns().map((column) => column.name);
-    const content = renderExportContent({
+
+    return {
+      filenameBase: tableName,
+      format,
+      formatConfig,
       columns,
       rows,
-      format,
+    };
+  }
+
+  exportTable(tableName, options = {}) {
+    const exportData = this.buildTableExportData(tableName, options);
+    const content = renderExportContent({
+      columns: exportData.columns,
+      rows: exportData.rows,
+      format: exportData.format,
       csvDelimiter: this.getDelimiter(),
     });
 
-    return {
-      filename: `${tableName}.${formatConfig.extension}`,
+    return buildExportResult({
+      filenameBase: exportData.filenameBase,
+      formatConfig: exportData.formatConfig,
       content,
-      csv: format === "csv" ? content : undefined,
-      format,
-      mimeType: formatConfig.mimeType,
-      columns,
-      rowCount: rows.length,
-    };
+      format: exportData.format,
+      columns: exportData.columns,
+      rowCount: exportData.rows.length,
+    });
+  }
+
+  async exportTableDownload(tableName, options = {}) {
+    const exportData = this.buildTableExportData(tableName, options);
+    const content = await renderDownloadContent({
+      columns: exportData.columns,
+      rows: exportData.rows,
+      format: exportData.format,
+      csvDelimiter: this.getDelimiter(),
+    });
+
+    return buildExportResult({
+      filenameBase: exportData.filenameBase,
+      formatConfig: exportData.formatConfig,
+      content,
+      format: exportData.format,
+      columns: exportData.columns,
+      rowCount: exportData.rows.length,
+    });
   }
 }
 

package/server/services/storage/appStateStore.js

@@ -457,6 +457,19 @@ class AppStateStore {
 
       CREATE INDEX IF NOT EXISTS idx_database_documents_database_updated
       ON database_documents(database_key, updated_at DESC, id ASC);
+
+      CREATE TABLE IF NOT EXISTS api_tokens (
+        id TEXT PRIMARY KEY,
+        database_key TEXT NOT NULL,
+        name TEXT NOT NULL,
+        token_hash TEXT NOT NULL UNIQUE,
+        token_prefix TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        last_used_at TEXT
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_api_tokens_database_created
+      ON api_tokens(database_key, created_at DESC, id ASC);
     `);
 
     const recentConnectionColumns = new Set(
@@ -2335,6 +2348,106 @@ class AppStateStore {
     return this.getSettings();
   }
 
+  decorateApiTokenRow(row = {}) {
+    return {
+      id: String(row.id ?? ""),
+      databaseKey: String(row.database_key ?? row.databaseKey ?? ""),
+      name: String(row.name ?? ""),
+      tokenPrefix: String(row.token_prefix ?? row.tokenPrefix ?? ""),
+      createdAt: row.created_at ?? row.createdAt ?? null,
+      lastUsedAt: row.last_used_at ?? row.lastUsedAt ?? null,
+    };
+  }
+
+  listApiTokens(databaseKey) {
+    const normalizedDatabaseKey = normalizeDocumentDatabaseKey(databaseKey);
+
+    return this.db
+      .prepare(
+        `
+          SELECT id, database_key, name, token_prefix, created_at, last_used_at
+          FROM api_tokens
+          WHERE database_key = ?
+          ORDER BY created_at DESC, id ASC
+        `
+      )
+      .all(normalizedDatabaseKey)
+      .map((row) => this.decorateApiTokenRow(row));
+  }
+
+  createApiToken({ databaseKey, name, tokenHash, tokenPrefix }) {
+    const normalizedDatabaseKey = normalizeDocumentDatabaseKey(databaseKey);
+    const id = crypto.randomUUID();
+    const createdAt = new Date().toISOString();
+
+    this.db
+      .prepare(
+        `
+          INSERT INTO api_tokens (
+            id,
+            database_key,
+            name,
+            token_hash,
+            token_prefix,
+            created_at
+          )
+          VALUES (?, ?, ?, ?, ?, ?)
+        `
+      )
+      .run(id, normalizedDatabaseKey, name, tokenHash, tokenPrefix, createdAt);
+
+    return this.listApiTokens(normalizedDatabaseKey).find((token) => token.id === id);
+  }
+
+  findApiTokenByHash(tokenHash) {
+    const normalizedTokenHash = String(tokenHash ?? "").trim();
+
+    if (!normalizedTokenHash) {
+      return null;
+    }
+
+    const row = this.db
+      .prepare(
+        `
+          SELECT id, database_key, name, token_prefix, created_at, last_used_at
+          FROM api_tokens
+          WHERE token_hash = ?
+          LIMIT 1
+        `
+      )
+      .get(normalizedTokenHash);
+
+    return row ? this.decorateApiTokenRow(row) : null;
+  }
+
+  touchApiToken(tokenId) {
+    this.db
+      .prepare("UPDATE api_tokens SET last_used_at = ? WHERE id = ?")
+      .run(new Date().toISOString(), String(tokenId ?? "").trim());
+  }
+
+  deleteApiToken(databaseKey, tokenId) {
+    const normalizedDatabaseKey = normalizeDocumentDatabaseKey(databaseKey);
+    const normalizedTokenId = String(tokenId ?? "").trim();
+
+    if (!normalizedTokenId) {
+      throw new ValidationError("Token id is required.");
+    }
+
+    const result = this.db
+      .prepare("DELETE FROM api_tokens WHERE database_key = ? AND id = ?")
+      .run(normalizedDatabaseKey, normalizedTokenId);
+
+    if (result.changes < 1) {
+      throw new NotFoundError("API token was not found.");
+    }
+
+    return {
+      id: normalizedTokenId,
+      deleted: true,
+    };
+  }
+
   decorateDatabaseDocumentRow(row = {}) {
     return {
       id: String(row.id ?? ""),

package/server/utils/errors.js

@@ -29,6 +29,12 @@ class ConflictError extends AppError {
   }
 }
 
+class AuthenticationError extends AppError {
+  constructor(message = "Authentication required.", options = {}) {
+    super(message, 401, { code: "AUTHENTICATION_REQUIRED", ...options });
+  }
+}
+
 class BusyError extends AppError {
   constructor(message, options = {}) {
     super(message, 423, { code: "SQLITE_BUSY", ...options });
@@ -161,6 +167,7 @@ function errorMiddleware(error, req, res, next) {
 
 module.exports = {
   AppError,
+  AuthenticationError,
   BusyError,
   ConflictError,
   DatabaseRequiredError,