sqlite-hub 0.3.1 → 0.4.0

package/{publish_npm.sh → scripts/publish_npm.sh}

@@ -2,7 +2,7 @@
 
 set -euo pipefail
 
-ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
 cd "$ROOT_DIR"
 
 DRY_RUN=0
@@ -15,7 +15,7 @@ GH_REMOTE="origin"
 usage() {
   cat <<'EOF'
 Usage:
-  ./publish_npm.sh [options]
+  ./scripts/publish_npm.sh [options]
 
 Options:
   --tag NAME          Publish to a custom npm dist-tag instead of `latest`.

package/server/routes/connections.js

@@ -113,6 +113,8 @@ function createConnectionsRouter({ connectionManager, importService, backupServi
         filePath: req.body.path,
         label: req.body.label,
         readOnly: Boolean(req.body.readOnly),
+        logoUpload: req.body.logoUpload ?? null,
+        clearLogo: Boolean(req.body.clearLogo),
       });
 
       res.json(

package/server/routes/data.js

@@ -51,6 +51,20 @@ function createDataRouter({ dataBrowserService }) {
     })
   );
 
+  router.delete(
+    "/:tableName/rows",
+    route((req, res) => {
+      const data = dataBrowserService.deleteTableRow(req.params.tableName, req.body ?? {});
+
+      res.json(
+        successResponse({
+          message: "Table row deleted.",
+          data,
+        })
+      );
+    })
+  );
+
   return router;
 }
 

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,
@@ -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,12 +105,31 @@ 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 resolvePort(value = process.env.PORT) {
+function parsePortArgument(argv = process.argv.slice(2)) {
+  for (let index = 0; index < argv.length; index += 1) {
+    const argument = argv[index];
+
+    if (argument.startsWith("--port:")) {
+      return argument.slice("--port:".length);
+    }
+
+    if (argument.startsWith("--port=")) {
+      return argument.slice("--port=".length);
+    }
+
+    if (argument === "--port") {
+      return argv[index + 1];
+    }
+  }
+
+  return undefined;
+}
+
+function resolvePort(value = process.env.PORT ?? parsePortArgument()) {
   if (value === undefined || value === null || value === "") {
     return DEFAULT_PORT;
   }
@@ -153,6 +175,7 @@ module.exports = {
   appStateStore,
   connectionManager,
   DEFAULT_PORT,
+  parsePortArgument,
   resolvePort,
   startServer,
 };

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

@@ -171,6 +171,36 @@ class DataBrowserService {
     };
   }
 
+  deleteTableRow(tableName, payload = {}) {
+    this.connectionManager.assertWritable();
+
+    const db = this.connectionManager.getActiveDatabase();
+    const tableDetail = getTableDetail(db, tableName, { includeRowCount: false });
+    const identity = payload.identity ?? null;
+
+    if (tableDetail.notSafelyUpdatable) {
+      throw new ValidationError(
+        `Table ${tableName} cannot be safely updated because it has no stable row identity.`
+      );
+    }
+
+    const where = this.buildWhereClause(tableDetail, identity);
+    const result = db
+      .prepare(`DELETE FROM ${quoteIdentifier(tableName)} WHERE ${where.clause}`)
+      .run(...where.params);
+
+    if (!result.changes) {
+      throw new NotFoundError(`Row not found in table: ${tableName}`);
+    }
+
+    return {
+      tableName,
+      deleted: true,
+      identity,
+      affectedRowCount: result.changes,
+    };
+  }
+
   buildWhereClause(tableDetail, identity) {
     if (tableDetail.identityStrategy?.type === "rowid") {
       const rowid = identity?.values?.rowid;

package/server/services/storage/appStateStore.js

@@ -1,6 +1,7 @@
 const fs = require("node:fs");
 const path = require("node:path");
 const Database = require("better-sqlite3");
+const { ValidationError } = require("../../utils/errors");
 
 const DEFAULT_STATE = {
   recentConnections: [],
@@ -16,9 +17,24 @@ const DEFAULT_STATE = {
   },
 };
 
+const CONNECTION_LOGO_DIRECTORY = "db_logos";
+const MAX_CONNECTION_LOGO_SIZE_BYTES = 5 * 1024 * 1024;
+const CONNECTION_LOGO_EXTENSION_BY_MIME_TYPE = {
+  "image/jpeg": "jpg",
+  "image/png": "png",
+  "image/webp": "webp",
+};
+const CONNECTION_LOGO_EXTENSION_BY_FILE_EXTENSION = {
+  ".jpeg": "jpg",
+  ".jpg": "jpg",
+  ".png": "png",
+  ".webp": "webp",
+};
+
 class AppStateStore {
   constructor(filePath, options = {}) {
     this.filePath = filePath;
+    this.logoDirectory = path.join(path.dirname(this.filePath), CONNECTION_LOGO_DIRECTORY);
     this.legacyFilePath = options.legacyFilePath ?? null;
     this.legacyDatabasePaths = Array.isArray(options.legacyDatabasePaths)
       ? options.legacyDatabasePaths
@@ -26,6 +42,7 @@ class AppStateStore {
     this.isFreshDatabase = !fs.existsSync(filePath);
 
     fs.mkdirSync(path.dirname(this.filePath), { recursive: true });
+    fs.mkdirSync(this.logoDirectory, { recursive: true });
 
     this.db = new Database(this.filePath);
     this.configureDatabase();
@@ -64,7 +81,8 @@ class AppStateStore {
         lastOpenedAt TEXT NOT NULL,
         lastModifiedAt TEXT,
         sizeBytes INTEGER,
-        readOnly INTEGER NOT NULL DEFAULT 0
+        readOnly INTEGER NOT NULL DEFAULT 0,
+        logoPath TEXT
       );
 
       CREATE TABLE IF NOT EXISTS sql_history (
@@ -86,6 +104,17 @@ class AppStateStore {
       CREATE INDEX IF NOT EXISTS idx_sql_history_executed_at
       ON sql_history(executedAt DESC, id ASC);
     `);
+
+    const recentConnectionColumns = new Set(
+      this.db
+        .prepare("PRAGMA table_info(recent_connections)")
+        .all()
+        .map((column) => column.name)
+    );
+
+    if (!recentConnectionColumns.has("logoPath")) {
+      this.db.exec("ALTER TABLE recent_connections ADD COLUMN logoPath TEXT");
+    }
   }
 
   seedDefaultSettings() {
@@ -153,6 +182,14 @@ class AppStateStore {
           .all()
           .map((row) => row.name)
       );
+      const recentConnectionColumns = tables.has("recent_connections")
+        ? new Set(
+            legacyDb
+              .prepare("PRAGMA table_info(recent_connections)")
+              .all()
+              .map((column) => column.name)
+          )
+        : new Set();
 
       return {
         settings: tables.has("settings")
@@ -173,7 +210,8 @@ class AppStateStore {
                   lastOpenedAt,
                   lastModifiedAt,
                   sizeBytes,
-                  readOnly
+                  readOnly,
+                  ${recentConnectionColumns.has("logoPath") ? "logoPath" : "NULL AS logoPath"}
                 FROM recent_connections
                 ORDER BY lastOpenedAt DESC, id ASC
               `)
@@ -223,16 +261,18 @@ class AppStateStore {
         lastOpenedAt,
         lastModifiedAt,
         sizeBytes,
-        readOnly
+        readOnly,
+        logoPath
       )
-      VALUES (?, ?, ?, ?, ?, ?, ?)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
       ON CONFLICT(id) DO UPDATE SET
         label = excluded.label,
         path = excluded.path,
         lastOpenedAt = excluded.lastOpenedAt,
         lastModifiedAt = excluded.lastModifiedAt,
         sizeBytes = excluded.sizeBytes,
-        readOnly = excluded.readOnly
+        readOnly = excluded.readOnly,
+        logoPath = excluded.logoPath
     `);
     const insertHistory = this.db.prepare(`
       INSERT INTO sql_history (
@@ -276,7 +316,8 @@ class AppStateStore {
           connection.lastOpenedAt ?? new Date().toISOString(),
           connection.lastModifiedAt ?? null,
           connection.sizeBytes ?? null,
-          connection.readOnly ? 1 : 0
+          connection.readOnly ? 1 : 0,
+          this.normalizeLogoPath(connection.logoPath)
         );
       }
 
@@ -373,7 +414,7 @@ class AppStateStore {
 
     const staleRows = this.db
       .prepare(`
-        SELECT id
+        SELECT id, logoPath
         FROM recent_connections
         ORDER BY lastOpenedAt DESC, id ASC
         LIMIT -1 OFFSET ?
@@ -393,6 +434,10 @@ class AppStateStore {
     if (activeConnectionId && staleRows.some((row) => row.id === activeConnectionId)) {
       this.setMetaValue("activeConnectionId", null);
     }
+
+    staleRows.forEach((row) => {
+      this.deleteConnectionLogo(row.logoPath);
+    });
   }
 
   trimSqlHistory() {
@@ -433,19 +478,19 @@ class AppStateStore {
           lastOpenedAt,
           lastModifiedAt,
           sizeBytes,
-          readOnly
+          readOnly,
+          logoPath
         FROM recent_connections
         ORDER BY lastOpenedAt DESC, id ASC
       `)
       .all()
-      .map((connection) => ({
-        ...connection,
-        readOnly: Boolean(connection.readOnly),
-      }));
+      .map((connection) => this.decorateConnection(connection));
   }
 
   upsertRecentConnection(connection, options = {}) {
     const makeActive = options.makeActive !== false;
+    const existing = this.getRecentConnections().find((entry) => entry.id === connection.id);
+    const nextLogoPath = this.normalizeLogoPath(connection.logoPath);
 
     this.db.transaction(() => {
       this.db
@@ -457,16 +502,18 @@ class AppStateStore {
             lastOpenedAt,
             lastModifiedAt,
             sizeBytes,
-            readOnly
+            readOnly,
+            logoPath
           )
-          VALUES (?, ?, ?, ?, ?, ?, ?)
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?)
           ON CONFLICT(id) DO UPDATE SET
             label = excluded.label,
             path = excluded.path,
             lastOpenedAt = excluded.lastOpenedAt,
             lastModifiedAt = excluded.lastModifiedAt,
             sizeBytes = excluded.sizeBytes,
-            readOnly = excluded.readOnly
+            readOnly = excluded.readOnly,
+            logoPath = excluded.logoPath
         `)
         .run(
           connection.id,
@@ -475,7 +522,8 @@ class AppStateStore {
           connection.lastOpenedAt,
           connection.lastModifiedAt ?? null,
           connection.sizeBytes ?? null,
-          connection.readOnly ? 1 : 0
+          connection.readOnly ? 1 : 0,
+          nextLogoPath
         );
 
       if (makeActive) {
@@ -485,10 +533,16 @@ class AppStateStore {
       this.trimRecentConnections();
     })();
 
+    if (this.normalizeLogoPath(existing?.logoPath) !== nextLogoPath) {
+      this.deleteConnectionLogo(existing?.logoPath);
+    }
+
     return this.getRecentConnections();
   }
 
   removeRecentConnection(id) {
+    const existing = this.getRecentConnections().find((connection) => connection.id === id);
+
     this.db.transaction(() => {
       this.db.prepare("DELETE FROM recent_connections WHERE id = ?").run(id);
 
@@ -497,6 +551,8 @@ class AppStateStore {
       }
     })();
 
+    this.deleteConnectionLogo(existing?.logoPath);
+
     return this.getState();
   }
 
@@ -518,16 +574,18 @@ class AppStateStore {
           lastOpenedAt,
           lastModifiedAt,
           sizeBytes,
-          readOnly
+          readOnly,
+          logoPath
         )
-        VALUES (?, ?, ?, ?, ?, ?, ?)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?)
         ON CONFLICT(id) DO UPDATE SET
           label = excluded.label,
           path = excluded.path,
           lastOpenedAt = excluded.lastOpenedAt,
           lastModifiedAt = excluded.lastModifiedAt,
           sizeBytes = excluded.sizeBytes,
-          readOnly = excluded.readOnly
+          readOnly = excluded.readOnly,
+          logoPath = excluded.logoPath
       `)
       .run(
         nextConnection.id,
@@ -536,12 +594,93 @@ class AppStateStore {
         nextConnection.lastOpenedAt ?? existing.lastOpenedAt,
         nextConnection.lastModifiedAt ?? null,
         nextConnection.sizeBytes ?? null,
-        nextConnection.readOnly ? 1 : 0
+        nextConnection.readOnly ? 1 : 0,
+        this.normalizeLogoPath(nextConnection.logoPath)
       );
 
+    if (this.normalizeLogoPath(nextConnection.logoPath) !== this.normalizeLogoPath(existing.logoPath)) {
+      this.deleteConnectionLogo(existing.logoPath);
+    }
+
     return this.getRecentConnections();
   }
 
+  getConnectionLogoUrl(logoPath) {
+    const normalizedLogoPath = this.normalizeLogoPath(logoPath);
+
+    if (!normalizedLogoPath) {
+      return null;
+    }
+
+    return `/${CONNECTION_LOGO_DIRECTORY}/${encodeURIComponent(normalizedLogoPath)}`;
+  }
+
+  saveConnectionLogo(connectionId, logoUpload = {}) {
+    const fileName = String(logoUpload.fileName ?? "").trim();
+    const mimeType = String(logoUpload.mimeType ?? "").trim().toLowerCase();
+    const base64 = String(logoUpload.base64 ?? "").trim();
+    const extension =
+      CONNECTION_LOGO_EXTENSION_BY_MIME_TYPE[mimeType] ??
+      CONNECTION_LOGO_EXTENSION_BY_FILE_EXTENSION[path.extname(fileName).toLowerCase()] ??
+      null;
+
+    if (!extension) {
+      throw new ValidationError("Connection logos must be one of: .png, .jpg, .jpeg, .webp");
+    }
+
+    if (!base64) {
+      throw new ValidationError("Connection logo upload is empty.");
+    }
+
+    const buffer = Buffer.from(base64, "base64");
+
+    if (!buffer.length) {
+      throw new ValidationError("Connection logo upload is empty.");
+    }
+
+    if (buffer.length > MAX_CONNECTION_LOGO_SIZE_BYTES) {
+      throw new ValidationError("Connection logo must be 5 MB or smaller.");
+    }
+
+    const safeConnectionId = String(connectionId ?? "connection").replace(/[^a-zA-Z0-9_-]/g, "_");
+    const storedFileName = `${safeConnectionId}-${Date.now()}.${extension}`;
+
+    fs.writeFileSync(path.join(this.logoDirectory, storedFileName), buffer);
+
+    return storedFileName;
+  }
+
+  deleteConnectionLogo(logoPath) {
+    const normalizedLogoPath = this.normalizeLogoPath(logoPath);
+
+    if (!normalizedLogoPath) {
+      return;
+    }
+
+    fs.rmSync(path.join(this.logoDirectory, normalizedLogoPath), { force: true });
+  }
+
+  decorateConnection(connection = {}) {
+    const logoPath = this.normalizeLogoPath(connection.logoPath);
+
+    return {
+      ...connection,
+      readOnly: Boolean(connection.readOnly),
+      logoPath,
+      logoUrl: this.getConnectionLogoUrl(logoPath),
+    };
+  }
+
+  normalizeLogoPath(logoPath) {
+    const trimmedLogoPath = String(logoPath ?? "").trim();
+
+    if (!trimmedLogoPath) {
+      return null;
+    }
+
+    return path.basename(trimmedLogoPath);
+  }
+
   setActiveConnectionId(id) {
     this.setMetaValue("activeConnectionId", id ?? null);
     return this.getActiveConnectionId();