sqlite-hub 0.2.0 → 0.3.1

package/publish_brew.sh

@@ -304,6 +304,27 @@ commit_and_push_tap() {
   run git -C "$TAP_DIR" push origin HEAD
 }
 
+refresh_local_brew_tap_checkout() {
+  local brew_repo
+  local installed_tap_path
+
+  if ! command -v brew >/dev/null 2>&1; then
+    info "brew not found, skipping local tap refresh"
+    return
+  fi
+
+  brew_repo="$(brew --repository)"
+  installed_tap_path="${brew_repo}/Library/Taps/${TAP_OWNER}/${TAP_REPO_NAME}"
+
+  if [[ ! -d "$installed_tap_path/.git" ]]; then
+    info "No installed Homebrew tap checkout at ${installed_tap_path}, skipping local refresh"
+    return
+  fi
+
+  info "Refreshing installed Homebrew tap checkout at ${installed_tap_path}"
+  run git -C "$installed_tap_path" pull --ff-only
+}
+
 run_brew_audit() {
   if [[ "$SKIP_AUDIT" == "1" ]]; then
     info "Skipping brew audit"
@@ -439,6 +460,7 @@ ensure_tap_repo
 write_formula
 run_brew_audit
 commit_and_push_tap
+refresh_local_brew_tap_checkout
 
 info "Published ${FORMULA_NAME} ${VERSION}"
 info "Install with: brew install ${BREW_TAP_NAME}/${FORMULA_NAME}"

package/server/routes/connections.js

@@ -1,7 +1,7 @@
 const express = require("express");
 const { route, successResponse } = require("../utils/errors");
 
-function createConnectionsRouter({ connectionManager, importService }) {
+function createConnectionsRouter({ connectionManager, importService, backupService }) {
   const router = express.Router();
 
   router.post(
@@ -68,6 +68,20 @@ function createConnectionsRouter({ connectionManager, importService }) {
     })
   );
 
+  router.post(
+    "/backup-active",
+    route((req, res) => {
+      const backup = backupService.createActiveBackup();
+
+      res.json(
+        successResponse({
+          message: `Backup created: ${backup.fileName}`,
+          data: backup,
+        })
+      );
+    })
+  );
+
   router.get(
     "/recent",
     route((req, res) => {

package/server/routes/export.js

@@ -4,16 +4,36 @@ const { route } = require("../utils/errors");
 function createExportRouter({ exportService }) {
   const router = express.Router();
 
+  function sendCsv(res, result) {
+    res.setHeader("Content-Type", "text/csv; charset=utf-8");
+    res.setHeader(
+      "Content-Disposition",
+      `attachment; filename="${result.filename}"`
+    );
+    res.send(result.csv);
+  }
+
   router.post(
     "/query.csv",
     route((req, res) => {
       const result = exportService.exportQuery(req.body.sql);
-      res.setHeader("Content-Type", "text/csv; charset=utf-8");
-      res.setHeader(
-        "Content-Disposition",
-        `attachment; filename="${result.filename}"`
-      );
-      res.send(result.csv);
+      sendCsv(res, result);
+    })
+  );
+
+  router.post(
+    "/table.csv",
+    route((req, res) => {
+      const result = exportService.exportTable(req.body?.tableName);
+      sendCsv(res, result);
+    })
+  );
+
+  router.get(
+    "/table/:tableName.csv",
+    route((req, res) => {
+      const result = exportService.exportTable(req.params.tableName);
+      sendCsv(res, result);
     })
   );
 

package/server/server.js

@@ -7,6 +7,7 @@ const { ConnectionManager } = require("./services/sqlite/connectionManager");
 const { OverviewService } = require("./services/sqlite/overviewService");
 const { SqlExecutor } = require("./services/sqlite/sqlExecutor");
 const { ImportService } = require("./services/sqlite/importService");
+const { BackupService } = require("./services/sqlite/backupService");
 const { ExportService } = require("./services/sqlite/exportService");
 const { StructureService } = require("./services/sqlite/structureService");
 const { DataBrowserService } = require("./services/sqlite/dataBrowserService");
@@ -34,8 +35,10 @@ const connectionManager = new ConnectionManager({ appStateStore });
 const overviewService = new OverviewService({ connectionManager });
 const sqlExecutor = new SqlExecutor({ connectionManager, appStateStore });
 const importService = new ImportService({ connectionManager });
+const backupService = new BackupService({ connectionManager });
 const exportService = new ExportService({
   appStateStore,
+  connectionManager,
   sqlExecutor,
 });
 const structureService = new StructureService({ connectionManager, appStateStore });
@@ -65,6 +68,7 @@ app.use(
   createConnectionsRouter({
     connectionManager,
     importService,
+    backupService,
   })
 );
 app.use("/api/db", createOverviewRouter({ overviewService }));
@@ -86,6 +90,18 @@ app.get("/index.html", (req, res) => {
   res.sendFile(path.resolve(__dirname, "..", "index.html"));
 });
 
+app.use(
+  "/vendor/cytoscape",
+  express.static(path.resolve(__dirname, "..", "node_modules", "cytoscape"))
+);
+app.use(
+  "/vendor/cytoscape-elk",
+  express.static(path.resolve(__dirname, "..", "node_modules", "cytoscape-elk"))
+);
+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")));

package/server/services/sqlite/backupService.js

@@ -0,0 +1,112 @@
+const fs = require("node:fs");
+const path = require("node:path");
+const { DatabaseRequiredError } = require("../../utils/errors");
+const {
+  SQLITE_EXTENSIONS,
+  ensureParentDirectory,
+  getFileMetadata,
+  validateSqlitePath,
+} = require("../../utils/fileValidation");
+
+function padTimestampPart(value) {
+  return String(value).padStart(2, "0");
+}
+
+function formatBackupTimestamp(date) {
+  return [
+    date.getFullYear(),
+    padTimestampPart(date.getMonth() + 1),
+    padTimestampPart(date.getDate()),
+  ].join("-")
+    + "_"
+    + [
+      padTimestampPart(date.getHours()),
+      padTimestampPart(date.getMinutes()),
+      padTimestampPart(date.getSeconds()),
+    ].join("-");
+}
+
+function sanitizeBackupBaseName(value) {
+  const normalized = String(value ?? "").trim().replace(/[<>:"/\\|?*\u0000-\u001F]+/g, "_");
+  return normalized || "database";
+}
+
+function normalizeBackupLabelBase(value, fallback) {
+  const normalized = String(value ?? "").trim() || String(fallback ?? "").trim() || "database";
+  const extension = path.extname(normalized).toLowerCase();
+
+  if (SQLITE_EXTENSIONS.has(extension)) {
+    return normalized.slice(0, -extension.length) || "database";
+  }
+
+  return normalized;
+}
+
+class BackupService {
+  constructor({ connectionManager }) {
+    this.connectionManager = connectionManager;
+  }
+
+  createActiveBackup() {
+    const activeConnection = this.connectionManager.getActiveConnection();
+
+    if (!activeConnection) {
+      throw new DatabaseRequiredError("No active SQLite database selected for backup.");
+    }
+
+    const sourcePath = validateSqlitePath(activeConnection.path, { mustExist: true });
+    const { backupPath, connectionLabel } = this.buildBackupPath(sourcePath, activeConnection.label);
+
+    ensureParentDirectory(backupPath);
+    fs.copyFileSync(sourcePath, backupPath, fs.constants.COPYFILE_EXCL);
+
+    const backupConnection = this.connectionManager.rememberConnection({
+      filePath: backupPath,
+      label: connectionLabel,
+      makeActive: false,
+    });
+    const metadata = getFileMetadata(backupPath);
+
+    return {
+      sourcePath,
+      backupPath,
+      directory: path.dirname(backupPath),
+      fileName: path.basename(backupPath),
+      createdAt: new Date().toISOString(),
+      sizeBytes: metadata.sizeBytes,
+      connection: backupConnection,
+    };
+  }
+
+  buildBackupPath(sourcePath, sourceLabel) {
+    const parsedSource = path.parse(sourcePath);
+    const backupDirectory = path.join(parsedSource.dir, "backups");
+    const extension = parsedSource.ext || ".sqlite";
+    const displayBaseName = normalizeBackupLabelBase(sourceLabel, parsedSource.name);
+    const fileBaseName = sanitizeBackupBaseName(displayBaseName);
+    const timestamp = formatBackupTimestamp(new Date());
+    let attempt = 1;
+
+    while (true) {
+      const suffix = attempt === 1 ? "" : `_${String(attempt).padStart(2, "0")}`;
+      const fileStem = `${fileBaseName}_${timestamp}${suffix}`;
+      const candidate = path.join(
+        backupDirectory,
+        `${fileStem}${extension}`
+      );
+
+      if (!fs.existsSync(candidate)) {
+        return {
+          backupPath: candidate,
+          connectionLabel: `${displayBaseName}_${timestamp}${suffix}`,
+        };
+      }
+
+      attempt += 1;
+    }
+  }
+}
+
+module.exports = {
+  BackupService,
+};

package/server/services/sqlite/connectionManager.js

@@ -121,6 +121,21 @@ class ConnectionManager {
     return this.getActiveConnection();
   }
 
+  rememberConnection({ filePath, label, readOnly = false, makeActive = false }) {
+    const resolvedPath = validateSqlitePath(filePath, { mustExist: true });
+    const connection = this.buildConnectionRecord(resolvedPath, {
+      label,
+      readOnly,
+    });
+
+    this.appStateStore.upsertRecentConnection(connection, { makeActive });
+
+    return {
+      ...connection,
+      isActive: this.current?.id === connection.id,
+    };
+  }
+
   createConnection({ filePath, label }) {
     const resolvedPath = resolveUserPath(filePath);
     ensureFileDoesNotExist(resolvedPath, "SQLite database");

package/server/services/sqlite/exportService.js

@@ -1,8 +1,12 @@
+const { quoteIdentifier } = require("../../utils/identifier");
+const { serializeRows } = require("../../utils/sqliteTypes");
 const { rowsToCsv } = require("../../utils/csv");
+const { getTableDetail } = require("./introspection");
 
 class ExportService {
-  constructor({ appStateStore, sqlExecutor }) {
+  constructor({ appStateStore, connectionManager, sqlExecutor }) {
     this.appStateStore = appStateStore;
+    this.connectionManager = connectionManager;
     this.sqlExecutor = sqlExecutor;
   }
 
@@ -27,6 +31,47 @@ class ExportService {
       rowCount: result.rows.length,
     };
   }
+
+  exportTable(tableName) {
+    const db = this.connectionManager.getActiveDatabase();
+    const tableDetail = getTableDetail(db, tableName, { includeRowCount: false });
+    const orderClause = this.buildOrderClause(tableDetail);
+    const statement = db.prepare(
+      [
+        `SELECT * FROM ${quoteIdentifier(tableName)}`,
+        orderClause ? `ORDER BY ${orderClause}` : "",
+      ]
+        .filter(Boolean)
+        .join(" ")
+    );
+    const rows = serializeRows(statement.all());
+    const columns = statement.columns().map((column) => column.name);
+
+    return {
+      filename: `${tableName}.csv`,
+      csv: rowsToCsv({
+        columns,
+        rows,
+        delimiter: this.getDelimiter(),
+      }),
+      columns,
+      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/structureService.js

@@ -11,6 +11,18 @@ class StructureService {
   getStructureOverview() {
     const db = this.connectionManager.getActiveDatabase();
     const entries = getRawStructureEntries(db);
+    const tables = entries
+      .filter((entry) => entry.type === "table")
+      .map((entry) => getTableDetail(db, entry.name, { includeRowCount: false }));
+    const relationshipCount = tables.reduce(
+      (count, table) =>
+        count +
+        table.foreignKeys.reduce(
+          (tableCount, foreignKey) => tableCount + foreignKey.mappings.length,
+          0
+        ),
+      0
+    );
 
     return {
       entries,
@@ -20,6 +32,20 @@ class StructureService {
         indexes: entries.filter((entry) => entry.type === "index"),
         triggers: entries.filter((entry) => entry.type === "trigger"),
       },
+      graph: {
+        tables: tables.map((table) => ({
+          type: table.type,
+          name: table.name,
+          ddl: table.ddl,
+          withoutRowId: table.withoutRowId,
+          strict: table.strict,
+          columns: table.columns,
+          foreignKeys: table.foreignKeys,
+          identityStrategy: table.identityStrategy,
+          notSafelyUpdatable: table.notSafelyUpdatable,
+        })),
+        relationshipCount,
+      },
     };
   }
 

package/server/services/storage/appStateStore.js

@@ -444,7 +444,9 @@ class AppStateStore {
       }));
   }
 
-  upsertRecentConnection(connection) {
+  upsertRecentConnection(connection, options = {}) {
+    const makeActive = options.makeActive !== false;
+
     this.db.transaction(() => {
       this.db
         .prepare(`
@@ -476,7 +478,10 @@ class AppStateStore {
           connection.readOnly ? 1 : 0
         );
 
-      this.setMetaValue("activeConnectionId", connection.id);
+      if (makeActive) {
+        this.setMetaValue("activeConnectionId", connection.id);
+      }
+
       this.trimRecentConnections();
     })();