sqlite-hub 1.1.1 → 1.2.0

package/server/services/storage/appStateStore.js

@@ -44,6 +44,7 @@ const STATE_DATABASE_FILENAME = "sqlite-hub-state.db";
 const MAX_CONNECTION_LOGO_SIZE_BYTES = 5 * 1024 * 1024;
 const MAX_DOCUMENT_CONTENT_BYTES = 5 * 1024 * 1024;
 const MAX_DOCUMENT_FILENAME_LENGTH = 160;
+const QUERY_EXECUTION_SOURCES = new Set(["api", "cli", "user", "mcp"]);
 const CONNECTION_LOGO_EXTENSION_BY_MIME_TYPE = {
   "image/jpeg": "jpg",
   "image/png": "png",
@@ -125,6 +126,24 @@ function buildDocumentTitleFromFilename(filename) {
   return title || "Untitled";
 }
 
+function normalizeQueryExecutionSource(value, fallback = "user") {
+  const normalized = String(value ?? fallback)
+    .trim()
+    .toLowerCase();
+
+  return QUERY_EXECUTION_SOURCES.has(normalized) ? normalized : fallback;
+}
+
+function requireQueryExecutionSource(value) {
+  const normalized = normalizeQueryExecutionSource(value, null);
+
+  if (!normalized) {
+    throw new ValidationError(`Unsupported query execution source: ${value}`);
+  }
+
+  return normalized;
+}
+
 function normalizeDocumentTitle(value, filename) {
   const title = String(value ?? "").trim();
 
@@ -152,7 +171,6 @@ const CONNECTION_LOGO_EXTENSION_BY_FILE_EXTENSION = {
   ".png": "png",
   ".webp": "webp",
 };
-const QUERY_HISTORY_MIGRATION_KEY = "queryHistoryV1Migrated";
 const MEDIA_TAGGING_CONFIG_FIELDS = [
   {
     column: "tag_table",
@@ -301,8 +319,6 @@ class AppStateStore {
     if (!importedLegacyDatabase && this.shouldImportLegacyState()) {
       this.tryImportLegacyState();
     }
-
-    this.migrateLegacySqlHistory();
   }
 
   configureDatabase() {
@@ -379,6 +395,7 @@ class AppStateStore {
         status TEXT NOT NULL CHECK(status IN ('success', 'error')),
         error_message TEXT,
         affected_rows INTEGER,
+        executed_by TEXT NOT NULL DEFAULT 'user' CHECK(executed_by IN ('api', 'cli', 'user', 'mcp')),
         FOREIGN KEY (history_id) REFERENCES query_history(id) ON DELETE CASCADE
       );
 
@@ -470,6 +487,52 @@ class AppStateStore {
 
       CREATE INDEX IF NOT EXISTS idx_api_tokens_database_created
       ON api_tokens(database_key, created_at DESC, id ASC);
+
+      CREATE TABLE IF NOT EXISTS backups (
+        id TEXT PRIMARY KEY,
+        connectionId TEXT,
+        name TEXT NOT NULL,
+        notes TEXT,
+        path TEXT NOT NULL,
+        sizeBytes INTEGER NOT NULL DEFAULT 0,
+        status TEXT NOT NULL DEFAULT 'creating'
+          CHECK(status IN ('creating', 'verifying', 'verified', 'failed', 'restoring')),
+        type TEXT NOT NULL DEFAULT 'manual'
+          CHECK(type IN (
+            'manual',
+            'automatic',
+            'pre_restore',
+            'pre_migration',
+            'pre_import',
+            'pre_schema_change'
+          )),
+        sourcePath TEXT NOT NULL,
+        sourceLabel TEXT,
+        sqliteHubVersion TEXT,
+        sqliteVersion TEXT,
+        journalMode TEXT,
+        schemaVersion INTEGER,
+        tableCount INTEGER,
+        rowCount INTEGER,
+        checksumSha256 TEXT,
+        createdAt TEXT NOT NULL,
+        verifiedAt TEXT,
+        lastRestoredAt TEXT,
+        errorMessage TEXT,
+        FOREIGN KEY (connectionId)
+          REFERENCES recent_connections(id)
+          ON UPDATE CASCADE
+          ON DELETE SET NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_backups_connection_created
+      ON backups(connectionId, createdAt DESC);
+
+      CREATE INDEX IF NOT EXISTS idx_backups_status
+      ON backups(status);
+
+      CREATE UNIQUE INDEX IF NOT EXISTS idx_backups_path
+      ON backups(path);
     `);
 
     const recentConnectionColumns = new Set(
@@ -483,9 +546,27 @@ class AppStateStore {
       this.db.exec("ALTER TABLE recent_connections ADD COLUMN logoPath TEXT");
     }
 
+    this.ensureQueryRunsSchema();
     this.ensureMediaTaggingConfigSchema();
   }
 
+  ensureQueryRunsSchema() {
+    const queryRunColumns = new Set(
+      this.db
+        .prepare("PRAGMA table_info(query_runs)")
+        .all()
+        .map((column) => column.name)
+    );
+
+    if (!queryRunColumns.has("executed_by")) {
+      this.db.exec(`
+        ALTER TABLE query_runs
+        ADD COLUMN executed_by TEXT NOT NULL DEFAULT 'user'
+        CHECK(executed_by IN ('api', 'cli', 'user', 'mcp'))
+      `);
+    }
+  }
+
   seedDefaultSettings() {
     const insertSetting = this.db.prepare(`
       INSERT INTO settings (key, value)
@@ -901,6 +982,7 @@ class AppStateStore {
       id: Number(row.id),
       historyId: Number(row.history_id ?? row.historyId),
       executedAt: row.executed_at ?? row.executedAt ?? null,
+      executedBy: normalizeQueryExecutionSource(row.executed_by ?? row.executedBy),
       durationMs: this.normalizeQueryHistoryInteger(row.duration_ms ?? row.durationMs),
       rowCount: this.normalizeQueryHistoryInteger(row.row_count ?? row.rowCount),
       status: row.status ?? "success",
@@ -924,6 +1006,7 @@ class AppStateStore {
             id: row.last_run_id ?? row.lastRunId,
             history_id: row.id,
             executed_at: row.last_run_executed_at ?? row.lastRunExecutedAt,
+            executed_by: row.last_run_executed_by ?? row.lastRunExecutedBy,
             duration_ms: row.last_run_duration_ms ?? row.lastRunDurationMs,
             row_count: row.last_run_row_count ?? row.lastRunRowCount,
             status: row.last_run_status ?? row.lastRunStatus,
@@ -1161,6 +1244,7 @@ class AppStateStore {
           q.last_used_at,
           latest.id AS last_run_id,
           latest.executed_at AS last_run_executed_at,
+          latest.executed_by AS last_run_executed_by,
           latest.duration_ms AS last_run_duration_ms,
           latest.row_count AS last_run_row_count,
           latest.status AS last_run_status,
@@ -1196,87 +1280,6 @@ class AppStateStore {
     };
   }
 
-  migrateLegacySqlHistory() {
-    if (this.getMetaValue(QUERY_HISTORY_MIGRATION_KEY) === "1") {
-      return;
-    }
-
-    const hasLegacyTable = Boolean(
-      this.db
-        .prepare(
-          "SELECT 1 AS exists_flag FROM sqlite_master WHERE type = 'table' AND name = 'sql_history'"
-        )
-        .get()
-    );
-
-    if (!hasLegacyTable) {
-      this.setMetaValue(QUERY_HISTORY_MIGRATION_KEY, "1");
-      return;
-    }
-
-    const legacyCount = Number(
-      this.db.prepare("SELECT COUNT(*) AS count FROM sql_history").get()?.count ?? 0
-    );
-
-    if (!legacyCount) {
-      this.setMetaValue(QUERY_HISTORY_MIGRATION_KEY, "1");
-      return;
-    }
-
-    const currentHistoryCount = Number(
-      this.db.prepare("SELECT COUNT(*) AS count FROM query_history").get()?.count ?? 0
-    );
-    const currentRunCount = Number(
-      this.db.prepare("SELECT COUNT(*) AS count FROM query_runs").get()?.count ?? 0
-    );
-
-    if (currentHistoryCount > 0 || currentRunCount > 0) {
-      this.setMetaValue(QUERY_HISTORY_MIGRATION_KEY, "1");
-      return;
-    }
-
-    const legacyRows = this.db
-      .prepare(`
-        SELECT
-          connectionId,
-          connectionLabel,
-          sql,
-          timingMs,
-          rowCount,
-          affectedRowCount,
-          executedAt
-        FROM sql_history
-        ORDER BY executedAt ASC, id ASC
-      `)
-      .all();
-
-    this.db.transaction(() => {
-      legacyRows.forEach((entry) => {
-        const databaseKey =
-          this.normalizeQueryHistoryText(entry.connectionId) ??
-          this.normalizeQueryHistoryText(entry.connectionLabel) ??
-          "legacy:default";
-        const rawSql = String(entry.sql ?? "");
-
-        if (!normalizeSql(rawSql)) {
-          return;
-        }
-
-        this.recordQueryExecutionInTransaction({
-          databaseKey,
-          rawSql,
-          status: "success",
-          durationMs: entry.timingMs,
-          rowCount: entry.rowCount,
-          affectedRows: entry.affectedRowCount,
-          executedAt: entry.executedAt ?? new Date().toISOString(),
-        });
-      });
-    })();
-
-    this.setMetaValue(QUERY_HISTORY_MIGRATION_KEY, "1");
-  }
-
   recordQueryExecution(entry = {}) {
     return this.db.transaction(() => this.recordQueryExecutionInTransaction(entry))();
   }
@@ -1290,10 +1293,12 @@ class AppStateStore {
     affectedRows = null,
     errorMessage = null,
     executedAt = null,
+    executedBy = "user",
   } = {}) {
     const normalizedDatabaseKey = this.normalizeQueryHistoryText(databaseKey);
     const normalizedRawSql = String(rawSql ?? "");
     const normalizedSql = normalizeSql(normalizedRawSql);
+    const normalizedExecutedBy = requireQueryExecutionSource(executedBy);
 
     if (!normalizedDatabaseKey) {
       throw new ValidationError("Query history requires a database key.");
@@ -1382,9 +1387,10 @@ class AppStateStore {
           row_count,
           status,
           error_message,
-          affected_rows
+          affected_rows,
+          executed_by
         )
-        VALUES (?, ?, ?, ?, ?, ?, ?)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?)
       `)
       .run(
         historyId,
@@ -1393,7 +1399,8 @@ class AppStateStore {
         this.normalizeQueryHistoryInteger(rowCount),
         status,
         this.normalizeQueryHistoryText(errorMessage),
-        this.normalizeQueryHistoryInteger(affectedRows)
+        this.normalizeQueryHistoryInteger(affectedRows),
+        normalizedExecutedBy
       );
 
     return historyId;
@@ -1438,6 +1445,7 @@ class AppStateStore {
           charts.chart_types,
           latest.id AS last_run_id,
           latest.executed_at AS last_run_executed_at,
+          latest.executed_by AS last_run_executed_by,
           latest.duration_ms AS last_run_duration_ms,
           latest.row_count AS last_run_row_count,
           latest.status AS last_run_status,
@@ -1497,6 +1505,7 @@ class AppStateStore {
           q.last_used_at,
           latest.id AS last_run_id,
           latest.executed_at AS last_run_executed_at,
+          latest.executed_by AS last_run_executed_by,
           latest.duration_ms AS last_run_duration_ms,
           latest.row_count AS last_run_row_count,
           latest.status AS last_run_status,
@@ -1551,6 +1560,7 @@ class AppStateStore {
           q.last_used_at,
           latest.id AS last_run_id,
           latest.executed_at AS last_run_executed_at,
+          latest.executed_by AS last_run_executed_by,
           latest.duration_ms AS last_run_duration_ms,
           latest.row_count AS last_run_row_count,
           latest.status AS last_run_status,
@@ -1596,6 +1606,7 @@ class AppStateStore {
           id,
           history_id,
           executed_at,
+          executed_by,
           duration_ms,
           row_count,
           status,
@@ -1948,6 +1959,286 @@ class AppStateStore {
       .run(normalizedDatabaseKey).changes;
   }
 
+  decorateBackupRow(row = {}) {
+    return {
+      id: String(row.id ?? ""),
+      connectionId: this.normalizeQueryHistoryText(row.connectionId),
+      name: String(row.name ?? ""),
+      notes: this.normalizeQueryHistoryText(row.notes),
+      path: String(row.path ?? ""),
+      sizeBytes: Number(row.sizeBytes ?? 0),
+      status: String(row.status ?? "creating"),
+      type: String(row.type ?? "manual"),
+      sourcePath: String(row.sourcePath ?? ""),
+      sourceLabel: this.normalizeQueryHistoryText(row.sourceLabel),
+      sqliteHubVersion: this.normalizeQueryHistoryText(row.sqliteHubVersion),
+      sqliteVersion: this.normalizeQueryHistoryText(row.sqliteVersion),
+      journalMode: this.normalizeQueryHistoryText(row.journalMode),
+      schemaVersion: this.normalizeQueryHistoryInteger(row.schemaVersion),
+      tableCount: this.normalizeQueryHistoryInteger(row.tableCount),
+      rowCount: this.normalizeQueryHistoryInteger(row.rowCount),
+      checksumSha256: this.normalizeQueryHistoryText(row.checksumSha256),
+      createdAt: row.createdAt ?? null,
+      verifiedAt: row.verifiedAt ?? null,
+      lastRestoredAt: row.lastRestoredAt ?? null,
+      errorMessage: this.normalizeQueryHistoryText(row.errorMessage),
+    };
+  }
+
+  listBackups({ connectionId = null, includeAll = false } = {}) {
+    const normalizedConnectionId = this.normalizeQueryHistoryText(connectionId);
+    const whereSql = includeAll || !normalizedConnectionId ? "" : "WHERE connectionId = ?";
+    const params = includeAll || !normalizedConnectionId ? [] : [normalizedConnectionId];
+
+    return this.db
+      .prepare(
+        `
+          SELECT
+            id,
+            connectionId,
+            name,
+            notes,
+            path,
+            sizeBytes,
+            status,
+            type,
+            sourcePath,
+            sourceLabel,
+            sqliteHubVersion,
+            sqliteVersion,
+            journalMode,
+            schemaVersion,
+            tableCount,
+            rowCount,
+            checksumSha256,
+            createdAt,
+            verifiedAt,
+            lastRestoredAt,
+            errorMessage
+          FROM backups
+          ${whereSql}
+          ORDER BY createdAt DESC, id ASC
+        `
+      )
+      .all(...params)
+      .map((row) => this.decorateBackupRow(row));
+  }
+
+  listBackupsByDirectory(directoryPath) {
+    const normalizedDirectory = String(directoryPath ?? "").trim();
+
+    if (!normalizedDirectory) {
+      return [];
+    }
+
+    return this.db
+      .prepare(
+        `
+          SELECT
+            id,
+            connectionId,
+            name,
+            notes,
+            path,
+            sizeBytes,
+            status,
+            type,
+            sourcePath,
+            sourceLabel,
+            sqliteHubVersion,
+            sqliteVersion,
+            journalMode,
+            schemaVersion,
+            tableCount,
+            rowCount,
+            checksumSha256,
+            createdAt,
+            verifiedAt,
+            lastRestoredAt,
+            errorMessage
+          FROM backups
+          WHERE path LIKE ?
+          ORDER BY createdAt DESC, id ASC
+        `
+      )
+      .all(`${normalizedDirectory}%`)
+      .map((row) => this.decorateBackupRow(row));
+  }
+
+  getBackup(backupId) {
+    const id = String(backupId ?? "").trim();
+
+    if (!id) {
+      return null;
+    }
+
+    const row = this.db
+      .prepare(
+        `
+          SELECT
+            id,
+            connectionId,
+            name,
+            notes,
+            path,
+            sizeBytes,
+            status,
+            type,
+            sourcePath,
+            sourceLabel,
+            sqliteHubVersion,
+            sqliteVersion,
+            journalMode,
+            schemaVersion,
+            tableCount,
+            rowCount,
+            checksumSha256,
+            createdAt,
+            verifiedAt,
+            lastRestoredAt,
+            errorMessage
+          FROM backups
+          WHERE id = ?
+        `
+      )
+      .get(id);
+
+    return row ? this.decorateBackupRow(row) : null;
+  }
+
+  createBackupRecord(record = {}) {
+    this.db
+      .prepare(
+        `
+          INSERT INTO backups (
+            id,
+            connectionId,
+            name,
+            notes,
+            path,
+            sizeBytes,
+            status,
+            type,
+            sourcePath,
+            sourceLabel,
+            sqliteHubVersion,
+            sqliteVersion,
+            journalMode,
+            schemaVersion,
+            tableCount,
+            rowCount,
+            checksumSha256,
+            createdAt,
+            verifiedAt,
+            lastRestoredAt,
+            errorMessage
+          )
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        `
+      )
+      .run(
+        record.id,
+        this.normalizeQueryHistoryText(record.connectionId),
+        String(record.name ?? "Backup").trim() || "Backup",
+        this.normalizeQueryHistoryText(record.notes),
+        String(record.path ?? "").trim(),
+        Number(record.sizeBytes ?? 0),
+        record.status ?? "creating",
+        record.type ?? "manual",
+        String(record.sourcePath ?? "").trim(),
+        this.normalizeQueryHistoryText(record.sourceLabel),
+        this.normalizeQueryHistoryText(record.sqliteHubVersion),
+        this.normalizeQueryHistoryText(record.sqliteVersion),
+        this.normalizeQueryHistoryText(record.journalMode),
+        this.normalizeQueryHistoryInteger(record.schemaVersion),
+        this.normalizeQueryHistoryInteger(record.tableCount),
+        this.normalizeQueryHistoryInteger(record.rowCount),
+        this.normalizeQueryHistoryText(record.checksumSha256),
+        record.createdAt ?? new Date().toISOString(),
+        record.verifiedAt ?? null,
+        record.lastRestoredAt ?? null,
+        this.normalizeQueryHistoryText(record.errorMessage)
+      );
+
+    return this.getBackup(record.id);
+  }
+
+  updateBackupRecord(backupId, changes = {}) {
+    const backup = this.getBackup(backupId);
+
+    if (!backup) {
+      throw new NotFoundError(`Backup not found: ${backupId}`);
+    }
+
+    const next = {
+      ...backup,
+      ...changes,
+    };
+
+    this.db
+      .prepare(
+        `
+          UPDATE backups
+          SET
+            connectionId = ?,
+            name = ?,
+            notes = ?,
+            path = ?,
+            sizeBytes = ?,
+            status = ?,
+            type = ?,
+            sourcePath = ?,
+            sourceLabel = ?,
+            sqliteHubVersion = ?,
+            sqliteVersion = ?,
+            journalMode = ?,
+            schemaVersion = ?,
+            tableCount = ?,
+            rowCount = ?,
+            checksumSha256 = ?,
+            verifiedAt = ?,
+            lastRestoredAt = ?,
+            errorMessage = ?
+          WHERE id = ?
+        `
+      )
+      .run(
+        this.normalizeQueryHistoryText(next.connectionId),
+        String(next.name ?? "Backup").trim() || "Backup",
+        this.normalizeQueryHistoryText(next.notes),
+        String(next.path ?? "").trim(),
+        Number(next.sizeBytes ?? 0),
+        next.status ?? "creating",
+        next.type ?? "manual",
+        String(next.sourcePath ?? "").trim(),
+        this.normalizeQueryHistoryText(next.sourceLabel),
+        this.normalizeQueryHistoryText(next.sqliteHubVersion),
+        this.normalizeQueryHistoryText(next.sqliteVersion),
+        this.normalizeQueryHistoryText(next.journalMode),
+        this.normalizeQueryHistoryInteger(next.schemaVersion),
+        this.normalizeQueryHistoryInteger(next.tableCount),
+        this.normalizeQueryHistoryInteger(next.rowCount),
+        this.normalizeQueryHistoryText(next.checksumSha256),
+        next.verifiedAt ?? null,
+        next.lastRestoredAt ?? null,
+        this.normalizeQueryHistoryText(next.errorMessage),
+        backup.id
+      );
+
+    return this.getBackup(backup.id);
+  }
+
+  deleteBackupRecord(backupId) {
+    const backup = this.getBackup(backupId);
+
+    if (!backup) {
+      throw new NotFoundError(`Backup not found: ${backupId}`);
+    }
+
+    this.db.prepare("DELETE FROM backups WHERE id = ?").run(backup.id);
+    return backup;
+  }
+
   trimRecentConnections() {
     const maxRecentConnections = Number(
       this.getSettings().maxRecentConnections ?? DEFAULT_STATE.settings.maxRecentConnections
@@ -2094,7 +2385,7 @@ class AppStateStore {
 
     this.deleteConnectionLogo(existing?.logoPath);
 
-    return this.getState();
+    return this.getRecentConnections();
   }
 
   updateRecentConnection(id, updater) {

package/tests/api-token-auth.test.js

@@ -41,7 +41,9 @@ async function startApi(t) {
       return [{ name: "companies" }];
     },
     executeRawQuery(databaseId, sql, options = {}) {
-      serviceCalls.push(`${databaseId}:query:${sql}:${options.storeName ?? ""}`);
+      serviceCalls.push(
+        `${databaseId}:query:${sql}:${options.storeName ?? ""}:${options.executedBy ?? ""}`
+      );
       if (sql === "READONLY") {
         throw new ReadOnlyError("Cannot execute raw SQL against a read-only database.");
       }
@@ -66,6 +68,27 @@ async function startApi(t) {
         },
       };
     },
+    executeSavedQuery(databaseId, queryName, options = {}) {
+      serviceCalls.push(`${databaseId}:saved:${queryName}:${options.executedBy ?? ""}`);
+      return {
+        query: {
+          id: 7,
+          title: queryName,
+          rawSql: "SELECT 1",
+        },
+        result: {
+          sql: "SELECT 1",
+          statementCount: 1,
+          statements: [],
+          rows: [],
+          columns: [],
+          affectedRowCount: 0,
+          resultKind: "resultSet",
+          timingMs: 3,
+          historyId: 7,
+        },
+      };
+    },
   };
   const app = express();
 
@@ -211,7 +234,7 @@ test("query API executes raw SQL with a database token", async (t) => {
   assert.equal(payload.metadata.stored, true);
   assert.equal(payload.metadata.databaseId, fixture.databaseA.id);
   assert.deepEqual(fixture.serviceCalls, [
-    `${fixture.databaseA.id}:query:SELECT 1:Stored API Query`,
+    `${fixture.databaseA.id}:query:SELECT 1:Stored API Query:api`,
   ]);
 });
 
@@ -234,3 +257,23 @@ test("query API rejects read-only raw SQL execution", async (t) => {
   assert.equal(response.status, 403);
   assert.equal(payload.error.code, "SQLITE_READONLY");
 });
+
+test("saved query API records executions as api", async (t) => {
+  const fixture = await startApi(t);
+  const created = fixture.tokenService.createToken(fixture.databaseA.id, "Automation");
+  const response = await fetch(
+    `${fixture.baseUrl}/databases/${fixture.databaseA.id}/queries/Hype-Reversal/execute`,
+    {
+      method: "POST",
+      headers: { Authorization: `Bearer ${created.token}` },
+    }
+  );
+  const payload = await response.json();
+
+  assert.equal(response.status, 200);
+  assert.equal(payload.data.historyId, 7);
+  assert.equal(payload.metadata.query.title, "Hype-Reversal");
+  assert.deepEqual(fixture.serviceCalls, [
+    `${fixture.databaseA.id}:saved:Hype-Reversal:api`,
+  ]);
+});