sqlite-hub 0.1.3 → 0.2.0

package/README.md

@@ -44,3 +44,5 @@ After linking or installing globally, the binary can also be called directly:
 ```bash
 sqlite-hub --port:1203
 ```
+
+App state such as recent connections, SQL history, and local settings is stored in the user profile instead of the install directory. On macOS this lives under `~/Library/Application Support/sqlite-hub/`, so Homebrew upgrades keep the internal state across versions.

package/bin/sqlite-hub.js

@@ -1,116 +1,123 @@
 #!/usr/bin/env node
 
-const { spawn } = require("node:child_process");
+const { spawn } = require('node:child_process');
 
 const DEFAULT_PORT = 4173;
 
 function printHelp() {
-  console.log(`SQLite Hub CLI
+    console.log(`SQLite Hub CLI
 
 Usage:
   sqlite-hub [--port:4173]
 
 Options:
-  --port:PORT   Start the server on a custom port.
   --help        Show this help text.
+  --port:PORT   Start the server on a custom port.
+  --version     Show the version number.
 `);
 }
 
 function parsePort(rawValue) {
-  const port = Number(rawValue);
+    const port = Number(rawValue);
 
-  if (!Number.isInteger(port) || port < 1 || port > 65535) {
-    throw new Error(`Invalid port: ${rawValue}`);
-  }
+    if (!Number.isInteger(port) || port < 1 || port > 65535) {
+        throw new Error(`Invalid port: ${rawValue}`);
+    }
 
-  return port;
+    return port;
 }
 
 function parseCliArguments(argv) {
-  let port;
-
-  for (let index = 0; index < argv.length; index += 1) {
-    const argument = argv[index];
-
-    if (argument === "--help" || argument === "-h") {
-      return { help: true };
-    }
-
-    if (argument.startsWith("--port:")) {
-      port = parsePort(argument.slice("--port:".length));
-      continue;
+    let port;
+
+    for (let index = 0; index < argv.length; index += 1) {
+        const argument = argv[index];
+
+        if (argument === '--help' || argument === '-h') {
+            return { help: true };
+        }
+
+        if (argument.startsWith('--port:')) {
+            port = parsePort(argument.slice('--port:'.length));
+            continue;
+        }
+
+        if (argument.startsWith('--port=')) {
+            port = parsePort(argument.slice('--port='.length));
+            continue;
+        }
+
+        if (argument === '--port') {
+            port = parsePort(argv[index + 1]);
+            index += 1;
+            continue;
+        }
+
+        if (argument === '--version' || argument === '-v') {
+            const { version } = require('../package.json');
+            console.log(`SQLite Hub CLI version ${version}`);
+            process.exit(0);
+        }
+
+        throw new Error(`Unknown argument: ${argument}`);
     }
 
-    if (argument.startsWith("--port=")) {
-      port = parsePort(argument.slice("--port=".length));
-      continue;
-    }
-
-    if (argument === "--port") {
-      port = parsePort(argv[index + 1]);
-      index += 1;
-      continue;
-    }
-
-    throw new Error(`Unknown argument: ${argument}`);
-  }
-
-  return { help: false, port };
+    return { help: false, port };
 }
 
 function openInDefaultBrowser(url) {
-  const openers = {
-    darwin: {
-      command: "open",
-      args: [url],
-    },
-    win32: {
-      command: "cmd",
-      args: ["/c", "start", "", url],
-      options: { windowsHide: true },
-    },
-    default: {
-      command: "xdg-open",
-      args: [url],
-    },
-  };
-
-  const opener = openers[process.platform] || openers.default;
-  const child = spawn(opener.command, opener.args, {
-    detached: true,
-    stdio: "ignore",
-    ...opener.options,
-  });
-
-  child.on("error", (error) => {
-    console.warn(`Could not open the browser automatically: ${error.message}`);
-  });
-
-  child.unref();
+    const openers = {
+        darwin: {
+            command: 'open',
+            args: [url],
+        },
+        win32: {
+            command: 'cmd',
+            args: ['/c', 'start', '', url],
+            options: { windowsHide: true },
+        },
+        default: {
+            command: 'xdg-open',
+            args: [url],
+        },
+    };
+
+    const opener = openers[process.platform] || openers.default;
+    const child = spawn(opener.command, opener.args, {
+        detached: true,
+        stdio: 'ignore',
+        ...opener.options,
+    });
+
+    child.on('error', error => {
+        console.warn(`Could not open the browser automatically: ${error.message}`);
+    });
+
+    child.unref();
 }
 
 async function main() {
-  const { help, port = DEFAULT_PORT } = parseCliArguments(process.argv.slice(2));
+    const { help, port = DEFAULT_PORT } = parseCliArguments(process.argv.slice(2));
 
-  if (help) {
-    printHelp();
-    return;
-  }
+    if (help) {
+        printHelp();
+        return;
+    }
 
-  const { startServer } = require("../server/server");
-  const { url } = await startServer({ port });
-  openInDefaultBrowser(url);
+    const { startServer } = require('../server/server');
+    const { url } = await startServer({ port });
+    openInDefaultBrowser(url);
 }
 
 if (require.main === module) {
-  main().catch((error) => {
-    console.error(error.message);
-    process.exit(1);
-  });
+    main().catch(error => {
+        console.error(error.message);
+        process.exit(1);
+    });
 }
 
 module.exports = {
-  main,
-  openInDefaultBrowser,
-  parseCliArguments,
+    main,
+    openInDefaultBrowser,
+    parseCliArguments,
 };

package/changelog.md

@@ -1,3 +1,7 @@
+# v0.2.0
+
+- db fix
+
 # v0.1.3
 
 - edit in sql editro

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "sqlite-hub",
-    "version": "0.1.3",
+    "version": "0.2.0",
     "description": "SQLite-only local management app backend and SPA shell",
     "main": "server/server.js",
     "bin": {

package/server/server.js

@@ -1,6 +1,7 @@
 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");
@@ -17,12 +18,17 @@ 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 });

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);

package/server/utils/appPaths.js

@@ -0,0 +1,131 @@
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+
+const APP_NAME = "sqlite-hub";
+const APP_STATE_DB_FILENAME = "sqlite-hub-state.db";
+const LEGACY_STATE_FILENAME = "app-state.json";
+
+function resolveAppStateDirectory() {
+  const homeDirectory = os.homedir();
+
+  if (process.platform === "darwin") {
+    return path.join(homeDirectory, "Library", "Application Support", APP_NAME);
+  }
+
+  if (process.platform === "win32") {
+    const appDataDirectory =
+      process.env.APPDATA || path.join(homeDirectory, "AppData", "Roaming");
+
+    return path.join(appDataDirectory, APP_NAME);
+  }
+
+  if (process.env.XDG_STATE_HOME) {
+    return path.join(process.env.XDG_STATE_HOME, APP_NAME);
+  }
+
+  return path.join(homeDirectory, ".local", "state", APP_NAME);
+}
+
+function resolvePackagedDataDirectory(packageRoot) {
+  return path.resolve(packageRoot, "data");
+}
+
+function resolvePackagedAppStateDbPath(packageRoot) {
+  return path.join(resolvePackagedDataDirectory(packageRoot), APP_STATE_DB_FILENAME);
+}
+
+function resolvePackagedLegacyStatePath(packageRoot) {
+  return path.join(resolvePackagedDataDirectory(packageRoot), LEGACY_STATE_FILENAME);
+}
+
+function resolveHomebrewCellarInfo(packageRoot) {
+  const resolvedPackageRoot = path.resolve(packageRoot);
+  const { root } = path.parse(resolvedPackageRoot);
+  const relativeSegments = resolvedPackageRoot
+    .slice(root.length)
+    .split(path.sep)
+    .filter(Boolean);
+  const cellarIndex = relativeSegments.indexOf("Cellar");
+
+  if (cellarIndex === -1) {
+    return null;
+  }
+
+  const formulaName = relativeSegments[cellarIndex + 1];
+  const currentVersion = relativeSegments[cellarIndex + 2];
+
+  if (formulaName !== APP_NAME || !currentVersion) {
+    return null;
+  }
+
+  return {
+    cellarRoot: path.join(root, ...relativeSegments.slice(0, cellarIndex + 2)),
+    currentVersion,
+  };
+}
+
+function safeStatMtimeMs(filePath) {
+  try {
+    return fs.statSync(filePath).mtimeMs;
+  } catch {
+    return -1;
+  }
+}
+
+function collectHomebrewLegacyStateDbPaths(packageRoot) {
+  const cellarInfo = resolveHomebrewCellarInfo(packageRoot);
+
+  if (!cellarInfo || !fs.existsSync(cellarInfo.cellarRoot)) {
+    return [];
+  }
+
+  return fs
+    .readdirSync(cellarInfo.cellarRoot, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory() && entry.name !== cellarInfo.currentVersion)
+    .map((entry) => {
+      const candidatePath = path.join(
+        cellarInfo.cellarRoot,
+        entry.name,
+        "libexec",
+        "lib",
+        "node_modules",
+        APP_NAME,
+        "data",
+        APP_STATE_DB_FILENAME
+      );
+
+      return {
+        path: candidatePath,
+        mtimeMs: safeStatMtimeMs(candidatePath),
+      };
+    })
+    .filter((candidate) => candidate.mtimeMs >= 0)
+    .sort((left, right) => right.mtimeMs - left.mtimeMs)
+    .map((candidate) => candidate.path);
+}
+
+function collectLegacyDatabasePaths(packageRoot) {
+  return [
+    resolvePackagedAppStateDbPath(packageRoot),
+    ...collectHomebrewLegacyStateDbPaths(packageRoot),
+  ].filter((candidatePath, index, candidates) => candidates.indexOf(candidatePath) === index);
+}
+
+function resolveAppStatePaths(packageRoot) {
+  const appStateDirectory = resolveAppStateDirectory();
+
+  return {
+    appStateDirectory,
+    appStateDbPath: path.join(appStateDirectory, APP_STATE_DB_FILENAME),
+    legacyStatePath: resolvePackagedLegacyStatePath(packageRoot),
+    legacyDatabasePaths: collectLegacyDatabasePaths(packageRoot),
+  };
+}
+
+module.exports = {
+  APP_NAME,
+  APP_STATE_DB_FILENAME,
+  resolveAppStateDirectory,
+  resolveAppStatePaths,
+};