sqlite-hub 0.1.3

package/server/services/sqlite/connectionManager.js

@@ -0,0 +1,306 @@
+const path = require("node:path");
+const crypto = require("node:crypto");
+const Database = require("better-sqlite3");
+const {
+  ConflictError,
+  DatabaseRequiredError,
+  NotFoundError,
+  ReadOnlyError,
+  ValidationError,
+  mapSqliteError,
+} = require("../../utils/errors");
+const {
+  ensureFileDoesNotExist,
+  ensureParentDirectory,
+  getFileMetadata,
+  isWritable,
+  resolveUserPath,
+  validateSqlitePath,
+} = require("../../utils/fileValidation");
+
+class ConnectionManager {
+  constructor({ appStateStore }) {
+    this.appStateStore = appStateStore;
+    this.current = null;
+  }
+
+  initialize() {
+    const activeId = this.appStateStore.getActiveConnectionId();
+
+    if (!activeId) {
+      return null;
+    }
+
+    const recent = this.appStateStore
+      .getRecentConnections()
+      .find((connection) => connection.id === activeId);
+
+    if (!recent) {
+      return null;
+    }
+
+    try {
+      return this.openConnection({
+        filePath: recent.path,
+        label: recent.label,
+        id: recent.id,
+        makeActive: true,
+      });
+    } catch (error) {
+      this.appStateStore.setActiveConnectionId(null);
+      return null;
+    }
+  }
+
+  buildConnectionRecord(filePath, options = {}) {
+    const metadata = getFileMetadata(filePath);
+
+    return {
+      id:
+        options.id ??
+        `conn_${crypto.createHash("sha1").update(filePath).digest("hex").slice(0, 16)}`,
+      label: options.label?.trim() || path.basename(filePath),
+      path: filePath,
+      lastOpenedAt: new Date().toISOString(),
+      lastModifiedAt: metadata.lastModifiedAt,
+      sizeBytes: metadata.sizeBytes,
+      readOnly: options.readOnly ?? !isWritable(filePath),
+    };
+  }
+
+  openRawDatabase(filePath, options = {}) {
+    const db = new Database(filePath, {
+      readonly: Boolean(options.readOnly),
+      fileMustExist: Boolean(options.fileMustExist),
+      timeout: this.appStateStore.getSettings().busyTimeoutMs,
+    });
+
+    try {
+      db.pragma(`busy_timeout = ${this.appStateStore.getSettings().busyTimeoutMs}`);
+      db.pragma("foreign_keys");
+      db.prepare("SELECT sqlite_version() AS version").get();
+      return db;
+    } catch (error) {
+      db.close();
+      throw mapSqliteError(error);
+    }
+  }
+
+  closeCurrent() {
+    if (this.current?.db) {
+      this.current.db.close();
+    }
+
+    this.current = null;
+  }
+
+  openConnection({ filePath, label, id, makeActive = true, readOnly = false }) {
+    const resolvedPath = validateSqlitePath(filePath, { mustExist: true });
+    const db = this.openRawDatabase(resolvedPath, {
+      fileMustExist: true,
+      readOnly,
+    });
+
+    this.closeCurrent();
+
+    const connection = this.buildConnectionRecord(resolvedPath, {
+      id,
+      label,
+      readOnly,
+    });
+
+    this.current = {
+      ...connection,
+      db,
+    };
+
+    if (makeActive) {
+      this.appStateStore.upsertRecentConnection(connection);
+    }
+
+    return this.getActiveConnection();
+  }
+
+  createConnection({ filePath, label }) {
+    const resolvedPath = resolveUserPath(filePath);
+    ensureFileDoesNotExist(resolvedPath, "SQLite database");
+    ensureParentDirectory(resolvedPath);
+
+    const extension = path.extname(resolvedPath).toLowerCase();
+
+    if (![".db", ".sqlite", ".sqlite3"].includes(extension)) {
+      throw new ValidationError(
+        "SQLite database must use one of: .db, .sqlite, .sqlite3"
+      );
+    }
+
+    const db = this.openRawDatabase(resolvedPath, {
+      fileMustExist: false,
+      readOnly: false,
+    });
+
+    try {
+      db.exec("VACUUM;");
+    } catch (error) {
+      db.close();
+      throw mapSqliteError(error);
+    }
+
+    db.close();
+
+    return this.openConnection({
+      filePath: resolvedPath,
+      label,
+      makeActive: true,
+      readOnly: false,
+    });
+  }
+
+  selectActiveConnection(id) {
+    const recent = this.appStateStore
+      .getRecentConnections()
+      .find((connection) => connection.id === id);
+
+    if (!recent) {
+      throw new NotFoundError(`Recent connection not found: ${id}`);
+    }
+
+    return this.openConnection({
+      filePath: recent.path,
+      label: recent.label,
+      id: recent.id,
+      makeActive: true,
+      readOnly: recent.readOnly,
+    });
+  }
+
+  removeRecentConnection(id) {
+    const state = this.appStateStore.removeRecentConnection(id);
+
+    if (this.current?.id === id) {
+      this.closeCurrent();
+    }
+
+    return state.recentConnections;
+  }
+
+  updateRecentConnection(id, { filePath, label, readOnly = false }) {
+    const recentConnections = this.appStateStore.getRecentConnections();
+    const existing = recentConnections.find((connection) => connection.id === id);
+
+    if (!existing) {
+      throw new NotFoundError(`Recent connection not found: ${id}`);
+    }
+
+    const resolvedPath = validateSqlitePath(filePath, { mustExist: true });
+    const duplicateConnection = recentConnections.find(
+      (connection) => connection.id !== id && connection.path === resolvedPath
+    );
+
+    if (duplicateConnection) {
+      throw new ConflictError(`A saved connection already targets: ${resolvedPath}`);
+    }
+
+    const normalizedLabel = label?.trim() || path.basename(resolvedPath);
+    const normalizedReadOnly = Boolean(readOnly);
+
+    if (this.current?.id === id) {
+      return this.openConnection({
+        filePath: resolvedPath,
+        label: normalizedLabel,
+        id,
+        makeActive: true,
+        readOnly: normalizedReadOnly,
+      });
+    }
+
+    const db = this.openRawDatabase(resolvedPath, {
+      fileMustExist: true,
+      readOnly: normalizedReadOnly,
+    });
+
+    db.close();
+
+    const metadata = getFileMetadata(resolvedPath);
+    const nextConnection = {
+      ...existing,
+      label: normalizedLabel,
+      path: resolvedPath,
+      lastModifiedAt: metadata.lastModifiedAt,
+      sizeBytes: metadata.sizeBytes,
+      readOnly: normalizedReadOnly,
+    };
+
+    this.appStateStore.updateRecentConnection(id, () => nextConnection);
+
+    return {
+      ...nextConnection,
+      isActive: false,
+    };
+  }
+
+  getActiveConnection() {
+    if (!this.current) {
+      return null;
+    }
+
+    const { db, ...connection } = this.current;
+    return {
+      ...connection,
+      isActive: true,
+    };
+  }
+
+  getActiveDatabase() {
+    if (!this.current?.db) {
+      throw new DatabaseRequiredError();
+    }
+
+    return this.current.db;
+  }
+
+  assertWritable() {
+    const connection = this.getActiveConnection();
+
+    if (!connection) {
+      throw new DatabaseRequiredError();
+    }
+
+    if (connection.readOnly) {
+      throw new ReadOnlyError(
+        `Database is opened in read-only mode: ${connection.path}`
+      );
+    }
+
+    return connection;
+  }
+
+  listRecentConnections() {
+    const activeId = this.current?.id ?? this.appStateStore.getActiveConnectionId();
+
+    return this.appStateStore.getRecentConnections().map((connection) => ({
+      ...connection,
+      isActive: connection.id === activeId,
+    }));
+  }
+
+  getStatus() {
+    const active = this.getActiveConnection();
+
+    if (!active) {
+      return {
+        connected: false,
+        activeConnection: null,
+      };
+    }
+
+    return {
+      connected: true,
+      activeConnection: active,
+    };
+  }
+}
+
+module.exports = {
+  ConnectionManager,
+};

package/server/services/sqlite/dataBrowserService.js

@@ -0,0 +1,255 @@
+const { NotFoundError, ValidationError } = require("../../utils/errors");
+const { quoteIdentifier } = require("../../utils/identifier");
+const {
+  deserializeSqliteValue,
+  serializeRow,
+  serializeRows,
+} = require("../../utils/sqliteTypes");
+const { getRawStructureEntries, getTableDetail } = require("./introspection");
+
+const DEFAULT_LIMIT = 50;
+const MAX_LIMIT = 100;
+
+function buildRowIdentity(tableDetail, row) {
+  if (tableDetail.identityStrategy?.type === "rowid") {
+    return {
+      kind: "rowid",
+      values: {
+        rowid: row.__rowid__,
+      },
+    };
+  }
+
+  if (tableDetail.identityStrategy?.type === "primaryKey") {
+    return {
+      kind: "primaryKey",
+      columns: tableDetail.identityStrategy.columns,
+      values: Object.fromEntries(
+        tableDetail.identityStrategy.columns.map((columnName) => [columnName, row[columnName]])
+      ),
+    };
+  }
+
+  return null;
+}
+
+function normalizePaginationOptions(options = {}) {
+  const limit = Number(options.limit ?? DEFAULT_LIMIT);
+  const offset = Number(options.offset ?? 0);
+
+  if (!Number.isInteger(limit) || limit < 1 || limit > MAX_LIMIT) {
+    throw new ValidationError(`limit must be an integer between 1 and ${MAX_LIMIT}.`);
+  }
+
+  if (!Number.isInteger(offset) || offset < 0) {
+    throw new ValidationError("offset must be a non-negative integer.");
+  }
+
+  return {
+    limit,
+    offset,
+  };
+}
+
+class DataBrowserService {
+  constructor({ connectionManager }) {
+    this.connectionManager = connectionManager;
+  }
+
+  listTables() {
+    const db = this.connectionManager.getActiveDatabase();
+
+    return getRawStructureEntries(db)
+      .filter((entry) => entry.type === "table")
+      .map((entry) => ({
+        name: entry.name,
+      }));
+  }
+
+  getTableData(tableName, options = {}) {
+    const db = this.connectionManager.getActiveDatabase();
+    const tableDetail = getTableDetail(db, tableName);
+    const { limit, offset } = normalizePaginationOptions(options);
+    const selectExpression =
+      tableDetail.identityStrategy?.type === "rowid" ? "rowid AS __rowid__, *" : "*";
+    const orderClause = this.buildOrderClause(tableDetail);
+    const statement = db.prepare(
+      [
+        `SELECT ${selectExpression} FROM ${quoteIdentifier(tableName)}`,
+        orderClause ? `ORDER BY ${orderClause}` : "",
+        "LIMIT ? OFFSET ?",
+      ]
+        .filter(Boolean)
+        .join(" ")
+    );
+    const rawRows = statement.all(limit, offset);
+    const columns = statement
+      .columns()
+      .map((column) => column.name)
+      .filter((columnName) => columnName !== "__rowid__");
+
+    const rows = serializeRows(rawRows).map((row) => {
+      const identity = buildRowIdentity(tableDetail, row);
+
+      if (Object.prototype.hasOwnProperty.call(row, "__rowid__")) {
+        delete row.__rowid__;
+      }
+
+      return {
+        ...row,
+        __identity: identity,
+      };
+    });
+
+    return {
+      name: tableDetail.name,
+      type: tableDetail.type,
+      rowCount: tableDetail.rowCount ?? rows.length,
+      limit,
+      offset,
+      page: Math.floor(offset / limit) + 1,
+      pageCount: Math.max(1, Math.ceil((tableDetail.rowCount ?? rows.length) / limit)),
+      columns,
+      columnMeta: tableDetail.columns,
+      rows,
+      identityStrategy: tableDetail.identityStrategy,
+      notSafelyUpdatable: tableDetail.notSafelyUpdatable,
+    };
+  }
+
+  updateTableRow(tableName, payload = {}) {
+    this.connectionManager.assertWritable();
+
+    const db = this.connectionManager.getActiveDatabase();
+    const tableDetail = getTableDetail(db, tableName, { includeRowCount: false });
+    const values = payload.values ?? {};
+    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 identityColumnSet = new Set(
+      tableDetail.identityStrategy?.type === "primaryKey"
+        ? tableDetail.identityStrategy.columns
+        : []
+    );
+    const editableColumns = tableDetail.columns.filter(
+      (column) => column.visible && !column.generated && !identityColumnSet.has(column.name)
+    );
+    const columnsToUpdate = editableColumns.filter((column) =>
+      Object.prototype.hasOwnProperty.call(values, column.name)
+    );
+
+    if (!columnsToUpdate.length) {
+      throw new ValidationError("No editable column values were provided.");
+    }
+
+    const where = this.buildWhereClause(tableDetail, identity);
+    const setClause = columnsToUpdate
+      .map((column) => `${quoteIdentifier(column.name)} = ?`)
+      .join(", ");
+    const setParams = columnsToUpdate.map((column) =>
+      deserializeSqliteValue(values[column.name])
+    );
+
+    db.prepare(
+      `UPDATE ${quoteIdentifier(tableName)} SET ${setClause} WHERE ${where.clause}`
+    ).run(...setParams, ...where.params);
+
+    const updatedRow = this.getRowByIdentity(db, tableDetail, where);
+
+    if (!updatedRow) {
+      throw new NotFoundError(`Row not found in table: ${tableName}`);
+    }
+
+    return {
+      tableName,
+      row: updatedRow,
+    };
+  }
+
+  buildWhereClause(tableDetail, identity) {
+    if (tableDetail.identityStrategy?.type === "rowid") {
+      const rowid = identity?.values?.rowid;
+
+      if (rowid === undefined) {
+        throw new ValidationError("rowid is required to update this row.");
+      }
+
+      return {
+        clause: "rowid IS ?",
+        params: [deserializeSqliteValue(rowid)],
+      };
+    }
+
+    if (tableDetail.identityStrategy?.type === "primaryKey") {
+      const columns = tableDetail.identityStrategy.columns ?? [];
+
+      if (!columns.length) {
+        throw new ValidationError("Primary key columns are required to update this row.");
+      }
+
+      return {
+        clause: columns.map((columnName) => `${quoteIdentifier(columnName)} IS ?`).join(" AND "),
+        params: columns.map((columnName) => {
+          if (!Object.prototype.hasOwnProperty.call(identity?.values ?? {}, columnName)) {
+            throw new ValidationError(`Missing primary key value for ${columnName}.`);
+          }
+
+          return deserializeSqliteValue(identity.values[columnName]);
+        }),
+      };
+    }
+
+    throw new ValidationError(
+      `Table ${tableDetail.name} cannot be updated because it has no stable row identity.`
+    );
+  }
+
+  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 "";
+  }
+
+  getRowByIdentity(db, tableDetail, where) {
+    const selectExpression =
+      tableDetail.identityStrategy?.type === "rowid" ? "rowid AS __rowid__, *" : "*";
+    const row = db
+      .prepare(
+        `SELECT ${selectExpression} FROM ${quoteIdentifier(tableDetail.name)} WHERE ${where.clause}`
+      )
+      .get(...where.params);
+
+    if (!row) {
+      return null;
+    }
+
+    const serialized = serializeRow(row);
+    const identity = buildRowIdentity(tableDetail, serialized);
+
+    if (Object.prototype.hasOwnProperty.call(serialized, "__rowid__")) {
+      delete serialized.__rowid__;
+    }
+
+    return {
+      ...serialized,
+      __identity: identity,
+    };
+  }
+}
+
+module.exports = {
+  DataBrowserService,
+};

package/server/services/sqlite/exportService.js

@@ -0,0 +1,34 @@
+const { rowsToCsv } = require("../../utils/csv");
+
+class ExportService {
+  constructor({ appStateStore, sqlExecutor }) {
+    this.appStateStore = appStateStore;
+    this.sqlExecutor = sqlExecutor;
+  }
+
+  getDelimiter() {
+    return this.appStateStore.getSettings().csvDelimiter || ",";
+  }
+
+  exportQuery(sql) {
+    const result = this.sqlExecutor.execute(sql, {
+      persistHistory: false,
+      requireReader: true,
+    });
+
+    return {
+      filename: "query-results.csv",
+      csv: rowsToCsv({
+        columns: result.columns,
+        rows: result.rows,
+        delimiter: this.getDelimiter(),
+      }),
+      columns: result.columns,
+      rowCount: result.rows.length,
+    };
+  }
+}
+
+module.exports = {
+  ExportService,
+};

package/server/services/sqlite/importService.js

@@ -0,0 +1,111 @@
+const fs = require("node:fs");
+const { ReadOnlyError, ValidationError, mapSqliteError } = require("../../utils/errors");
+const { validateSqlDumpPath } = require("../../utils/fileValidation");
+const { splitSqlStatements } = require("./sqlExecutor");
+
+class ImportService {
+  constructor({ connectionManager }) {
+    this.connectionManager = connectionManager;
+  }
+
+  containsExplicitTransaction(sql) {
+    return /\b(BEGIN|COMMIT|ROLLBACK|SAVEPOINT|RELEASE)\b/i.test(sql);
+  }
+
+  importSql({
+    sqlFilePath,
+    targetPath,
+    targetConnectionId,
+    createNew = false,
+    label,
+  }) {
+    const dumpPath = validateSqlDumpPath(sqlFilePath);
+    const sql = fs.readFileSync(dumpPath, "utf8");
+    let createdNewDatabase = false;
+
+    if (!sql.trim()) {
+      throw new ValidationError("SQL dump is empty.");
+    }
+
+    let activeConnection = null;
+
+    if (createNew) {
+      if (!targetPath) {
+        throw new ValidationError("targetPath is required when createNew is true.");
+      }
+
+      activeConnection = this.connectionManager.createConnection({
+        filePath: targetPath,
+        label,
+      });
+      createdNewDatabase = true;
+    } else if (targetConnectionId) {
+      activeConnection = this.connectionManager.selectActiveConnection(targetConnectionId);
+    } else if (targetPath) {
+      activeConnection = this.connectionManager.openConnection({
+        filePath: targetPath,
+        label,
+        makeActive: true,
+      });
+    } else {
+      activeConnection = this.connectionManager.getActiveConnection();
+    }
+
+    if (!activeConnection) {
+      throw new ValidationError(
+        "An active SQLite database or explicit target is required for import."
+      );
+    }
+
+    if (activeConnection.readOnly) {
+      throw new ReadOnlyError(
+        `Cannot import SQL into a read-only database: ${activeConnection.path}`
+      );
+    }
+
+    const db = this.connectionManager.getActiveDatabase();
+    const warnings = [];
+    const startedAt = Date.now();
+    const statementCount = splitSqlStatements(sql).length;
+
+    try {
+      if (this.containsExplicitTransaction(sql)) {
+        warnings.push(
+          "SQL dump contains explicit transaction control. Import executed without an additional wrapper transaction."
+        );
+        db.exec(sql);
+      } else {
+        db.exec("BEGIN");
+        try {
+          db.exec(sql);
+          db.exec("COMMIT");
+        } catch (error) {
+          db.exec("ROLLBACK");
+          throw error;
+        }
+      }
+    } catch (error) {
+      if (createdNewDatabase) {
+        try {
+          this.connectionManager.closeCurrent();
+          fs.rmSync(activeConnection.path, { force: true });
+        } catch (cleanupError) {
+          // Keep original SQLite error surface.
+        }
+      }
+      throw mapSqliteError(error);
+    }
+
+    return {
+      importedInto: activeConnection,
+      sourceDumpPath: dumpPath,
+      statementCount,
+      timingMs: Date.now() - startedAt,
+      warnings,
+    };
+  }
+}
+
+module.exports = {
+  ImportService,
+};