sqlite-hub 0.1.3 → 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

@@ -1,11 +1,13 @@
 const express = require("express");
 const path = require("node:path");
 const { errorMiddleware } = require("./utils/errors");
+const { resolveAppStatePaths } = require("./utils/appPaths");
 const { AppStateStore } = require("./services/storage/appStateStore");
 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");
@@ -17,19 +19,26 @@ const { createDataRouter } = require("./routes/data");
 const { createSettingsRouter } = require("./routes/settings");
 const { createExportRouter } = require("./routes/export");
 
-const APP_STATE_DB_PATH = path.resolve(__dirname, "..", "data", "sqlite-hub-state.db");
-const LEGACY_STATE_PATH = path.resolve(__dirname, "..", "data", "app-state.json");
+const PACKAGE_ROOT = path.resolve(__dirname, "..");
+const {
+  appStateDbPath: APP_STATE_DB_PATH,
+  legacyStatePath: LEGACY_STATE_PATH,
+  legacyDatabasePaths: LEGACY_DATABASE_PATHS,
+} = resolveAppStatePaths(PACKAGE_ROOT);
 const DEFAULT_PORT = 4173;
 
 const appStateStore = new AppStateStore(APP_STATE_DB_PATH, {
   legacyFilePath: LEGACY_STATE_PATH,
+  legacyDatabasePaths: LEGACY_DATABASE_PATHS,
 });
 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 });
@@ -59,6 +68,7 @@ app.use(
   createConnectionsRouter({
     connectionManager,
     importService,
+    backupService,
   })
 );
 app.use("/api/db", createOverviewRouter({ overviewService }));
@@ -80,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

@@ -20,6 +20,9 @@ class AppStateStore {
   constructor(filePath, options = {}) {
     this.filePath = filePath;
     this.legacyFilePath = options.legacyFilePath ?? null;
+    this.legacyDatabasePaths = Array.isArray(options.legacyDatabasePaths)
+      ? options.legacyDatabasePaths
+      : [];
     this.isFreshDatabase = !fs.existsSync(filePath);
 
     fs.mkdirSync(path.dirname(this.filePath), { recursive: true });
@@ -29,8 +32,10 @@ class AppStateStore {
     this.ensureSchema();
     this.seedDefaultSettings();
 
-    if (this.shouldImportLegacyState()) {
-      this.importLegacyState();
+    const importedLegacyDatabase = this.importFirstLegacyDatabase();
+
+    if (!importedLegacyDatabase && this.shouldImportLegacyState()) {
+      this.tryImportLegacyState();
     }
   }
 
@@ -121,8 +126,90 @@ class AppStateStore {
     };
   }
 
-  importLegacyState() {
-    const legacyState = this.readLegacyState();
+  getExistingLegacyDatabasePaths() {
+    return this.legacyDatabasePaths
+      .filter(Boolean)
+      .map((legacyPath) => path.resolve(legacyPath))
+      .filter(
+        (legacyPath, index, legacyPaths) =>
+          legacyPath !== path.resolve(this.filePath) &&
+          legacyPaths.indexOf(legacyPath) === index &&
+          fs.existsSync(legacyPath)
+      );
+  }
+
+  readLegacyDatabase(legacyDatabasePath) {
+    const legacyDb = new Database(legacyDatabasePath, {
+      readonly: true,
+      fileMustExist: true,
+    });
+
+    try {
+      legacyDb.pragma("query_only = ON");
+
+      const tables = new Set(
+        legacyDb
+          .prepare("SELECT name FROM sqlite_master WHERE type = 'table'")
+          .all()
+          .map((row) => row.name)
+      );
+
+      return {
+        settings: tables.has("settings")
+          ? Object.fromEntries(
+              legacyDb
+                .prepare("SELECT key, value FROM settings")
+                .all()
+                .map((row) => [row.key, row.value])
+            )
+          : {},
+        recentConnections: tables.has("recent_connections")
+          ? legacyDb
+              .prepare(`
+                SELECT
+                  id,
+                  label,
+                  path,
+                  lastOpenedAt,
+                  lastModifiedAt,
+                  sizeBytes,
+                  readOnly
+                FROM recent_connections
+                ORDER BY lastOpenedAt DESC, id ASC
+              `)
+              .all()
+          : [],
+        sqlHistory: tables.has("sql_history")
+          ? legacyDb
+              .prepare(`
+                SELECT
+                  id,
+                  connectionId,
+                  connectionLabel,
+                  sql,
+                  statementCount,
+                  resultKind,
+                  affectedRowCount,
+                  rowCount,
+                  timingMs,
+                  executedAt
+                FROM sql_history
+                ORDER BY executedAt DESC, id ASC
+              `)
+              .all()
+          : [],
+        activeConnectionId: tables.has("app_meta")
+          ? legacyDb
+              .prepare("SELECT value FROM app_meta WHERE key = ?")
+              .get("activeConnectionId")?.value ?? null
+          : null,
+      };
+    } finally {
+      legacyDb.close();
+    }
+  }
+
+  importStateSnapshot(legacyState, sourcePath) {
     const insertSetting = this.db.prepare(`
       INSERT INTO settings (key, value)
       VALUES (?, ?)
@@ -175,7 +262,10 @@ class AppStateStore {
 
     this.db.transaction(() => {
       for (const [key, value] of Object.entries(legacyState.settings ?? {})) {
-        insertSetting.run(key, JSON.stringify(value));
+        const normalizedValue =
+          typeof value === "string" ? this.parseStoredValue(value) : value;
+
+        insertSetting.run(key, JSON.stringify(normalizedValue));
       }
 
       for (const connection of legacyState.recentConnections ?? []) {
@@ -208,11 +298,43 @@ class AppStateStore {
       this.setMetaValue("activeConnectionId", legacyState.activeConnectionId ?? null);
       this.setMetaValue(
         "legacyImportSource",
-        path.relative(path.dirname(this.filePath), this.legacyFilePath)
+        path.relative(path.dirname(this.filePath), sourcePath)
       );
     })();
   }
 
+  importFirstLegacyDatabase() {
+    if (!this.isFreshDatabase) {
+      return false;
+    }
+
+    for (const legacyDatabasePath of this.getExistingLegacyDatabasePaths()) {
+      try {
+        this.importStateSnapshot(
+          this.readLegacyDatabase(legacyDatabasePath),
+          legacyDatabasePath
+        );
+        return true;
+      } catch (error) {
+        console.warn(
+          `Could not import legacy app state database from ${legacyDatabasePath}: ${error.message}`
+        );
+      }
+    }
+
+    return false;
+  }
+
+  tryImportLegacyState() {
+    try {
+      this.importStateSnapshot(this.readLegacyState(), this.legacyFilePath);
+    } catch (error) {
+      console.warn(
+        `Could not import legacy app state from ${this.legacyFilePath}: ${error.message}`
+      );
+    }
+  }
+
   parseStoredValue(value) {
     try {
       return JSON.parse(value);
@@ -322,7 +444,9 @@ class AppStateStore {
       }));
   }
 
-  upsertRecentConnection(connection) {
+  upsertRecentConnection(connection, options = {}) {
+    const makeActive = options.makeActive !== false;
+
     this.db.transaction(() => {
       this.db
         .prepare(`
@@ -354,7 +478,10 @@ class AppStateStore {
           connection.readOnly ? 1 : 0
         );
 
-      this.setMetaValue("activeConnectionId", connection.id);
+      if (makeActive) {
+        this.setMetaValue("activeConnectionId", connection.id);
+      }
+
       this.trimRecentConnections();
     })();