sqlite-hub 0.2.0 → 0.3.2

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,12 +90,44 @@ 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")));
 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;
   }
@@ -137,6 +173,7 @@ module.exports = {
   appStateStore,
   connectionManager,
   DEFAULT_PORT,
+  parsePortArgument,
   resolvePort,
   startServer,
 };

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/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/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();
     })();