sqlite-hub 0.3.2 → 0.5.0

package/server/routes/sql.js

@@ -1,7 +1,43 @@
 const express = require("express");
 const { route, successResponse } = require("../utils/errors");
 
-function createSqlRouter({ appStateStore, sqlExecutor }) {
+function parseBooleanFlag(value) {
+  if (typeof value === "boolean") {
+    return value;
+  }
+
+  const normalized = String(value ?? "")
+    .trim()
+    .toLowerCase();
+
+  return ["1", "true", "yes", "on"].includes(normalized);
+}
+
+function parseListLimit(value, fallback = 30, max = 100) {
+  const numericValue = Number(value);
+
+  if (!Number.isFinite(numericValue) || numericValue < 1) {
+    return fallback;
+  }
+
+  return Math.min(max, Math.round(numericValue));
+}
+
+function parseOffset(value) {
+  const numericValue = Number(value);
+
+  if (!Number.isFinite(numericValue) || numericValue < 0) {
+    return 0;
+  }
+
+  return Math.round(numericValue);
+}
+
+function getActiveDatabaseKey(connectionManager) {
+  return connectionManager.getActiveConnection()?.id ?? null;
+}
+
+function createSqlRouter({ appStateStore, connectionManager, sqlExecutor }) {
   const router = express.Router();
 
   router.post(
@@ -21,9 +57,32 @@ function createSqlRouter({ appStateStore, sqlExecutor }) {
   router.get(
     "/history",
     route((req, res) => {
+      const databaseKey = getActiveDatabaseKey(connectionManager);
+      const tab = String(req.query.tab ?? "recent").trim().toLowerCase();
+      const options = {
+        databaseKey,
+        limit: parseListLimit(req.query.limit, 30, 100),
+        offset: parseOffset(req.query.offset),
+        search: String(req.query.search ?? ""),
+        queryType: String(req.query.queryType ?? "").trim() || null,
+        onlySaved: parseBooleanFlag(req.query.onlySaved),
+        onlyFavorites: parseBooleanFlag(req.query.onlyFavorites),
+      };
+      const result =
+        tab === "failed"
+          ? appStateStore.getFailedQueries(options)
+          : appStateStore.getRecentQueries({
+              ...options,
+              onlySaved: tab === "saved" ? true : options.onlySaved,
+            });
+
       res.json(
         successResponse({
-          data: appStateStore.getSqlHistory(),
+          data: result,
+          metadata: {
+            databaseKey,
+            tab,
+          },
         })
       );
     })
@@ -32,11 +91,110 @@ function createSqlRouter({ appStateStore, sqlExecutor }) {
   router.delete(
     "/history",
     route((req, res) => {
-      appStateStore.clearSqlHistory();
+      const databaseKey = getActiveDatabaseKey(connectionManager);
+      const deletedCount = appStateStore.clearQueryHistoryForDatabase(databaseKey);
+
+      res.json(
+        successResponse({
+          message: deletedCount
+            ? "Query history cleared for the active database."
+            : "No query history was found for the active database.",
+          data: {
+            deletedCount,
+          },
+          metadata: {
+            databaseKey,
+          },
+        })
+      );
+    })
+  );
+
+  router.get(
+    "/history/:historyId/runs",
+    route((req, res) => {
+      res.json(
+        successResponse({
+          data: appStateStore.getQueryRunsByHistoryId(
+            req.params.historyId,
+            parseListLimit(req.query.limit, 8, 50)
+          ),
+        })
+      );
+    })
+  );
+
+  router.patch(
+    "/history/:historyId/favorite",
+    route((req, res) => {
+      const nextValue = parseBooleanFlag(req.body?.value);
+      res.json(
+        successResponse({
+          message: nextValue ? "Query favorited." : "Query removed from favorites.",
+          data: appStateStore.toggleFavorite(req.params.historyId, nextValue),
+        })
+      );
+    })
+  );
+
+  router.patch(
+    "/history/:historyId/saved",
+    route((req, res) => {
+      const nextValue = parseBooleanFlag(req.body?.value);
+      res.json(
+        successResponse({
+          message: nextValue ? "Query saved." : "Query removed from saved queries.",
+          data: appStateStore.toggleSaved(req.params.historyId, nextValue),
+        })
+      );
+    })
+  );
+
+  router.patch(
+    "/history/:historyId/title",
+    route((req, res) => {
+      res.json(
+        successResponse({
+          message: "Query title updated.",
+          data: appStateStore.renameQuery(req.params.historyId, req.body?.title),
+        })
+      );
+    })
+  );
+
+  router.patch(
+    "/history/:historyId/notes",
+    route((req, res) => {
+      res.json(
+        successResponse({
+          message: "Query notes updated.",
+          data: appStateStore.updateQueryNotes(req.params.historyId, req.body?.notes),
+        })
+      );
+    })
+  );
+
+  router.delete(
+    "/history/:historyId",
+    route((req, res) => {
+      appStateStore.deleteQueryHistoryItem(req.params.historyId);
+      res.json(
+        successResponse({
+          message: "Query history item deleted.",
+          data: {
+            id: Number(req.params.historyId),
+          },
+        })
+      );
+    })
+  );
+
+  router.get(
+    "/history/:historyId",
+    route((req, res) => {
       res.json(
         successResponse({
-          message: "SQL history cleared.",
-          data: [],
+          data: appStateStore.getQueryHistoryItemById(req.params.historyId),
         })
       );
     })

package/server/server.js

@@ -20,7 +20,10 @@ const { createSettingsRouter } = require("./routes/settings");
 const { createExportRouter } = require("./routes/export");
 
 const PACKAGE_ROOT = path.resolve(__dirname, "..");
+const FRONTEND_ROOT = path.join(PACKAGE_ROOT, "frontend");
+const FRONTEND_ENTRYPOINT = path.join(FRONTEND_ROOT, "index.html");
 const {
+  appStateDirectory: APP_STATE_DIRECTORY,
   appStateDbPath: APP_STATE_DB_PATH,
   legacyStatePath: LEGACY_STATE_PATH,
   legacyDatabasePaths: LEGACY_DATABASE_PATHS,
@@ -72,7 +75,7 @@ app.use(
   })
 );
 app.use("/api/db", createOverviewRouter({ overviewService }));
-app.use("/api/sql", createSqlRouter({ appStateStore, sqlExecutor }));
+app.use("/api/sql", createSqlRouter({ appStateStore, connectionManager, sqlExecutor }));
 app.use("/api/structure", createStructureRouter({ structureService }));
 app.use("/api/data", createDataRouter({ dataBrowserService }));
 app.use("/api/settings", createSettingsRouter({ appStateStore }));
@@ -83,11 +86,11 @@ app.get("/favicon.ico", (req, res) => {
 });
 
 app.get("/", (req, res) => {
-  res.sendFile(path.resolve(__dirname, "..", "index.html"));
+  res.sendFile(FRONTEND_ENTRYPOINT);
 });
 
 app.get("/index.html", (req, res) => {
-  res.sendFile(path.resolve(__dirname, "..", "index.html"));
+  res.sendFile(FRONTEND_ENTRYPOINT);
 });
 
 app.use(
@@ -102,9 +105,8 @@ app.use(
   "/vendor/elkjs",
   express.static(path.resolve(__dirname, "..", "node_modules", "elkjs"))
 );
-app.use("/js", express.static(path.resolve(__dirname, "..", "js")));
-app.use("/styles", express.static(path.resolve(__dirname, "..", "styles")));
-app.use("/assets", express.static(path.resolve(__dirname, "..", "assets")));
+app.use(express.static(FRONTEND_ROOT));
+app.use("/db_logos", express.static(path.join(APP_STATE_DIRECTORY, "db_logos")));
 app.use(errorMiddleware);
 
 function parsePortArgument(argv = process.argv.slice(2)) {

package/server/services/sqlite/connectionManager.js

@@ -44,6 +44,7 @@ class ConnectionManager {
         filePath: recent.path,
         label: recent.label,
         id: recent.id,
+        logoPath: recent.logoPath ?? null,
         makeActive: true,
       });
     } catch (error) {
@@ -54,17 +55,26 @@ class ConnectionManager {
 
   buildConnectionRecord(filePath, options = {}) {
     const metadata = getFileMetadata(filePath);
+    const id =
+      options.id ??
+      `conn_${crypto.createHash("sha1").update(filePath).digest("hex").slice(0, 16)}`;
+    const existingConnection = this.appStateStore
+      .getRecentConnections()
+      .find((connection) => connection.id === id);
+    const logoPath = Object.prototype.hasOwnProperty.call(options, "logoPath")
+      ? options.logoPath
+      : (existingConnection?.logoPath ?? null);
 
     return {
-      id:
-        options.id ??
-        `conn_${crypto.createHash("sha1").update(filePath).digest("hex").slice(0, 16)}`,
+      id,
       label: options.label?.trim() || path.basename(filePath),
       path: filePath,
       lastOpenedAt: new Date().toISOString(),
       lastModifiedAt: metadata.lastModifiedAt,
       sizeBytes: metadata.sizeBytes,
       readOnly: options.readOnly ?? !isWritable(filePath),
+      logoPath,
+      logoUrl: this.appStateStore.getConnectionLogoUrl(logoPath),
     };
   }
 
@@ -94,7 +104,7 @@ class ConnectionManager {
     this.current = null;
   }
 
-  openConnection({ filePath, label, id, makeActive = true, readOnly = false }) {
+  openConnection({ filePath, label, id, makeActive = true, readOnly = false, logoPath }) {
     const resolvedPath = validateSqlitePath(filePath, { mustExist: true });
     const db = this.openRawDatabase(resolvedPath, {
       fileMustExist: true,
@@ -103,11 +113,17 @@ class ConnectionManager {
 
     this.closeCurrent();
 
-    const connection = this.buildConnectionRecord(resolvedPath, {
+    const connectionOptions = {
       id,
       label,
       readOnly,
-    });
+    };
+
+    if (logoPath !== undefined) {
+      connectionOptions.logoPath = logoPath;
+    }
+
+    const connection = this.buildConnectionRecord(resolvedPath, connectionOptions);
 
     this.current = {
       ...connection,
@@ -186,6 +202,7 @@ class ConnectionManager {
       id: recent.id,
       makeActive: true,
       readOnly: recent.readOnly,
+      logoPath: recent.logoPath ?? null,
     });
   }
 
@@ -199,7 +216,7 @@ class ConnectionManager {
     return state.recentConnections;
   }
 
-  updateRecentConnection(id, { filePath, label, readOnly = false }) {
+  updateRecentConnection(id, { filePath, label, readOnly = false, logoUpload = null, clearLogo = false }) {
     const recentConnections = this.appStateStore.getRecentConnections();
     const existing = recentConnections.find((connection) => connection.id === id);
 
@@ -218,40 +235,58 @@ class ConnectionManager {
 
     const normalizedLabel = label?.trim() || path.basename(resolvedPath);
     const normalizedReadOnly = Boolean(readOnly);
+    let nextLogoPath = clearLogo ? null : existing.logoPath ?? null;
+    let createdLogoPath = null;
 
-    if (this.current?.id === id) {
-      return this.openConnection({
-        filePath: resolvedPath,
-        label: normalizedLabel,
-        id,
-        makeActive: true,
+    if (logoUpload) {
+      createdLogoPath = this.appStateStore.saveConnectionLogo(id, logoUpload);
+      nextLogoPath = createdLogoPath;
+    }
+
+    try {
+      if (this.current?.id === id) {
+        return this.openConnection({
+          filePath: resolvedPath,
+          label: normalizedLabel,
+          id,
+          makeActive: true,
+          readOnly: normalizedReadOnly,
+          logoPath: nextLogoPath,
+        });
+      }
+
+      const db = this.openRawDatabase(resolvedPath, {
+        fileMustExist: true,
         readOnly: normalizedReadOnly,
       });
-    }
 
-    const db = this.openRawDatabase(resolvedPath, {
-      fileMustExist: true,
-      readOnly: normalizedReadOnly,
-    });
+      db.close();
 
-    db.close();
+      const metadata = getFileMetadata(resolvedPath);
+      const nextConnection = {
+        ...existing,
+        label: normalizedLabel,
+        path: resolvedPath,
+        lastModifiedAt: metadata.lastModifiedAt,
+        sizeBytes: metadata.sizeBytes,
+        readOnly: normalizedReadOnly,
+        logoPath: nextLogoPath,
+      };
 
-    const metadata = getFileMetadata(resolvedPath);
-    const nextConnection = {
-      ...existing,
-      label: normalizedLabel,
-      path: resolvedPath,
-      lastModifiedAt: metadata.lastModifiedAt,
-      sizeBytes: metadata.sizeBytes,
-      readOnly: normalizedReadOnly,
-    };
+      this.appStateStore.updateRecentConnection(id, () => nextConnection);
 
-    this.appStateStore.updateRecentConnection(id, () => nextConnection);
+      return {
+        ...nextConnection,
+        logoUrl: this.appStateStore.getConnectionLogoUrl(nextLogoPath),
+        isActive: false,
+      };
+    } catch (error) {
+      if (createdLogoPath) {
+        this.appStateStore.deleteConnectionLogo(createdLogoPath);
+      }
 
-    return {
-      ...nextConnection,
-      isActive: false,
-    };
+      throw error;
+    }
   }
 
   getActiveConnection() {

package/server/services/sqlite/dataBrowserService.js

@@ -6,6 +6,7 @@ const {
   serializeRows,
 } = require("../../utils/sqliteTypes");
 const { getRawStructureEntries, getTableDetail } = require("./introspection");
+const { buildTableOrderClause, normalizeTableSort } = require("./tableSort");
 
 const DEFAULT_LIMIT = 50;
 const MAX_LIMIT = 100;
@@ -70,9 +71,10 @@ class DataBrowserService {
     const db = this.connectionManager.getActiveDatabase();
     const tableDetail = getTableDetail(db, tableName);
     const { limit, offset } = normalizePaginationOptions(options);
+    const sort = normalizeTableSort(tableDetail, options);
     const selectExpression =
       tableDetail.identityStrategy?.type === "rowid" ? "rowid AS __rowid__, *" : "*";
-    const orderClause = this.buildOrderClause(tableDetail);
+    const orderClause = buildTableOrderClause(tableDetail, sort);
     const statement = db.prepare(
       [
         `SELECT ${selectExpression} FROM ${quoteIdentifier(tableName)}`,
@@ -114,6 +116,7 @@ class DataBrowserService {
       rows,
       identityStrategy: tableDetail.identityStrategy,
       notSafelyUpdatable: tableDetail.notSafelyUpdatable,
+      sort,
     };
   }
 
@@ -238,21 +241,6 @@ class DataBrowserService {
       `Table ${tableDetail.name} cannot be updated because it has no stable row identity.`
     );
   }
-
-  buildOrderClause(tableDetail) {
-    if (tableDetail.identityStrategy?.type === "rowid") {
-      return "rowid ASC";
-    }
-
-    if (tableDetail.identityStrategy?.type === "primaryKey") {
-      return tableDetail.identityStrategy.columns
-        .map((columnName) => `${quoteIdentifier(columnName)} ASC`)
-        .join(", ");
-    }
-
-    return "";
-  }
-
   getRowByIdentity(db, tableDetail, where) {
     const selectExpression =
       tableDetail.identityStrategy?.type === "rowid" ? "rowid AS __rowid__, *" : "*";

package/server/services/sqlite/exportService.js

@@ -2,6 +2,7 @@ const { quoteIdentifier } = require("../../utils/identifier");
 const { serializeRows } = require("../../utils/sqliteTypes");
 const { rowsToCsv } = require("../../utils/csv");
 const { getTableDetail } = require("./introspection");
+const { buildTableOrderClause, normalizeTableSort } = require("./tableSort");
 
 class ExportService {
   constructor({ appStateStore, connectionManager, sqlExecutor }) {
@@ -32,10 +33,11 @@ class ExportService {
     };
   }
 
-  exportTable(tableName) {
+  exportTable(tableName, options = {}) {
     const db = this.connectionManager.getActiveDatabase();
     const tableDetail = getTableDetail(db, tableName, { includeRowCount: false });
-    const orderClause = this.buildOrderClause(tableDetail);
+    const sort = normalizeTableSort(tableDetail, options);
+    const orderClause = buildTableOrderClause(tableDetail, sort);
     const statement = db.prepare(
       [
         `SELECT * FROM ${quoteIdentifier(tableName)}`,
@@ -58,20 +60,6 @@ class ExportService {
       rowCount: rows.length,
     };
   }
-
-  buildOrderClause(tableDetail) {
-    if (tableDetail.identityStrategy?.type === "rowid") {
-      return "rowid ASC";
-    }
-
-    if (tableDetail.identityStrategy?.type === "primaryKey") {
-      return tableDetail.identityStrategy.columns
-        .map((columnName) => `${quoteIdentifier(columnName)} ASC`)
-        .join(", ");
-    }
-
-    return "";
-  }
 }
 
 module.exports = {

package/server/services/sqlite/overviewService.js

@@ -1,5 +1,12 @@
+const fs = require("fs");
+const path = require("path");
+const { execFile } = require("child_process");
+const { promisify } = require("util");
+const { AppError, DatabaseRequiredError } = require("../../utils/errors");
 const { listSchema } = require("./introspection");
 
+const execFileAsync = promisify(execFile);
+
 class OverviewService {
   constructor({ connectionManager }) {
     this.connectionManager = connectionManager;
@@ -102,6 +109,33 @@ class OverviewService {
       readOnly: active?.readOnly ?? false,
     };
   }
+
+  async revealActiveDatabaseInFinder() {
+    const active = this.connectionManager.getActiveConnection();
+    const targetPath = active?.path;
+
+    if (!targetPath) {
+      throw new DatabaseRequiredError();
+    }
+
+    if (!fs.existsSync(targetPath)) {
+      throw new AppError("The active database file could not be found on disk.", 404, {
+        code: "DATABASE_FILE_NOT_FOUND",
+      });
+    }
+
+    if (process.platform === "darwin") {
+      await execFileAsync("open", ["-R", targetPath]);
+      return;
+    }
+
+    if (process.platform === "win32") {
+      await execFileAsync("explorer.exe", ["/select,", targetPath]);
+      return;
+    }
+
+    await execFileAsync("xdg-open", [path.dirname(targetPath)]);
+  }
 }
 
 module.exports = {