sqlite-hub 0.8.7 → 0.9.0

package/server/services/storage/appStateStore.js

@@ -46,6 +46,63 @@ const CONNECTION_LOGO_EXTENSION_BY_FILE_EXTENSION = {
   ".webp": "webp",
 };
 const QUERY_HISTORY_MIGRATION_KEY = "queryHistoryV1Migrated";
+const MEDIA_TAGGING_CONFIG_FIELDS = [
+  {
+    column: "tag_table",
+    property: "tagTable",
+    definition: "tag_table TEXT NOT NULL DEFAULT ''",
+  },
+  {
+    column: "media_table",
+    property: "mediaTable",
+    definition: "media_table TEXT NOT NULL DEFAULT ''",
+  },
+  {
+    column: "path_column",
+    property: "pathColumn",
+    definition: "path_column TEXT NOT NULL DEFAULT ''",
+  },
+  {
+    column: "tagged_column",
+    property: "taggedColumn",
+    definition: "tagged_column TEXT NOT NULL DEFAULT ''",
+  },
+  {
+    column: "untagged_query",
+    property: "untaggedQuery",
+    definition: "untagged_query TEXT NOT NULL DEFAULT ''",
+  },
+  {
+    column: "tagged_query",
+    property: "taggedQuery",
+    definition: "tagged_query TEXT NOT NULL DEFAULT ''",
+  },
+  {
+    column: "mapping_table",
+    property: "mappingTable",
+    definition: "mapping_table TEXT NOT NULL DEFAULT ''",
+  },
+];
+
+function normalizeMediaTaggingConfigValue(value) {
+  return String(value ?? "").trim();
+}
+
+function normalizeMediaTaggingConfigRecord(config = {}) {
+  return {
+    tagTable: normalizeMediaTaggingConfigValue(config.tagTable),
+    mediaTable: normalizeMediaTaggingConfigValue(config.mediaTable),
+    pathColumn: normalizeMediaTaggingConfigValue(config.pathColumn),
+    taggedColumn: normalizeMediaTaggingConfigValue(config.taggedColumn),
+    untaggedQuery: String(config.untaggedQuery ?? "").trim(),
+    taggedQuery: String(config.taggedQuery ?? "").trim(),
+    mappingTable: normalizeMediaTaggingConfigValue(config.mappingTable),
+  };
+}
+
+function isChartCompatibleQueryType(queryType) {
+  return String(queryType ?? "").trim().toLowerCase() === "select";
+}
 
 class AppStateStore {
   constructor(filePath, options = {}) {
@@ -200,6 +257,18 @@ class AppStateStore {
 
       CREATE INDEX IF NOT EXISTS idx_query_history_chart_chart_type
       ON query_history_chart(chart_type);
+
+      CREATE TABLE IF NOT EXISTS media_tagging_config (
+        database_key TEXT PRIMARY KEY,
+        tag_table TEXT NOT NULL DEFAULT '',
+        media_table TEXT NOT NULL DEFAULT '',
+        path_column TEXT NOT NULL DEFAULT '',
+        tagged_column TEXT NOT NULL DEFAULT '',
+        untagged_query TEXT NOT NULL DEFAULT '',
+        tagged_query TEXT NOT NULL DEFAULT '',
+        mapping_table TEXT NOT NULL DEFAULT '',
+        updated_at TEXT NOT NULL
+      );
     `);
 
     const recentConnectionColumns = new Set(
@@ -212,6 +281,8 @@ class AppStateStore {
     if (!recentConnectionColumns.has("logoPath")) {
       this.db.exec("ALTER TABLE recent_connections ADD COLUMN logoPath TEXT");
     }
+
+    this.ensureMediaTaggingConfigSchema();
   }
 
   seedDefaultSettings() {
@@ -481,6 +552,85 @@ class AppStateStore {
     }
   }
 
+  ensureMediaTaggingConfigSchema() {
+    const columns = this.db
+      .prepare("PRAGMA table_info(media_tagging_config)")
+      .all()
+      .map((column) => column.name);
+    const columnSet = new Set(columns);
+
+    this.mediaTaggingConfigHasLegacyJsonColumn = columnSet.has("config_json");
+
+    for (const field of MEDIA_TAGGING_CONFIG_FIELDS) {
+      if (!columnSet.has(field.column)) {
+        this.db.exec(`ALTER TABLE media_tagging_config ADD COLUMN ${field.definition}`);
+      }
+    }
+
+    if (this.mediaTaggingConfigHasLegacyJsonColumn) {
+      this.backfillMediaTaggingConfigColumnsFromLegacyJson();
+    }
+  }
+
+  backfillMediaTaggingConfigColumnsFromLegacyJson() {
+    const rows = this.db
+      .prepare(
+        `
+          SELECT database_key, config_json
+          FROM media_tagging_config
+          WHERE config_json IS NOT NULL
+        `
+      )
+      .all();
+
+    if (!rows.length) {
+      return;
+    }
+
+    const updateStatement = this.db.prepare(`
+      UPDATE media_tagging_config
+      SET
+        tag_table = COALESCE(NULLIF(tag_table, ''), ?),
+        media_table = COALESCE(NULLIF(media_table, ''), ?),
+        path_column = COALESCE(NULLIF(path_column, ''), ?),
+        tagged_column = COALESCE(NULLIF(tagged_column, ''), ?),
+        untagged_query = COALESCE(NULLIF(untagged_query, ''), ?),
+        tagged_query = COALESCE(NULLIF(tagged_query, ''), ?),
+        mapping_table = COALESCE(NULLIF(mapping_table, ''), ?)
+      WHERE database_key = ?
+    `);
+
+    this.db.transaction(() => {
+      for (const row of rows) {
+        const parsedConfig = this.parseStoredValue(row.config_json);
+        const normalizedConfig = normalizeMediaTaggingConfigRecord(
+          parsedConfig && typeof parsedConfig === "object" && !Array.isArray(parsedConfig)
+            ? parsedConfig
+            : {}
+        );
+
+        updateStatement.run(
+          normalizedConfig.tagTable,
+          normalizedConfig.mediaTable,
+          normalizedConfig.pathColumn,
+          normalizedConfig.taggedColumn,
+          normalizedConfig.untaggedQuery,
+          normalizedConfig.taggedQuery,
+          normalizedConfig.mappingTable,
+          row.database_key
+        );
+      }
+    })();
+  }
+
+  buildMediaTaggingConfigRecord(row = {}) {
+    return normalizeMediaTaggingConfigRecord(
+      Object.fromEntries(
+        MEDIA_TAGGING_CONFIG_FIELDS.map((field) => [field.property, row[field.column] ?? null])
+      )
+    );
+  }
+
   getMetaValue(key) {
     const row = this.db
       .prepare("SELECT value FROM app_meta WHERE key = ?")
@@ -601,6 +751,9 @@ class AppStateStore {
         }),
       previewSql: buildSqlPreview(row.raw_sql ?? row.rawSql),
       lastRun,
+      chartsEligible:
+        isChartCompatibleQueryType(queryType) &&
+        (!lastRun || String(lastRun.status ?? "").trim().toLowerCase() !== "error"),
     };
   }
 
@@ -661,6 +814,7 @@ class AppStateStore {
     search,
     queryType,
     onlySaved = false,
+    onlyUnsaved = false,
     onlyFavorites = false,
     latestStatus = null,
   } = {}) {
@@ -702,6 +856,10 @@ class AppStateStore {
       clauses.push("q.is_saved = 1");
     }
 
+    if (onlyUnsaved) {
+      clauses.push("q.is_saved = 0");
+    }
+
     if (onlyFavorites) {
       clauses.push("q.is_favorite = 1");
     }
@@ -736,6 +894,7 @@ class AppStateStore {
     search = "",
     queryType = null,
     onlySaved = false,
+    onlyUnsaved = false,
     onlyFavorites = false,
     latestStatus = null,
   } = {}) {
@@ -768,6 +927,7 @@ class AppStateStore {
       search,
       queryType,
       onlySaved,
+      onlyUnsaved,
       onlyFavorites,
       latestStatus,
     });
@@ -1092,6 +1252,7 @@ class AppStateStore {
             LIMIT 1
           )
         WHERE q.database_key = ?
+          AND q.query_type = 'select'
           AND COALESCE(latest.status, 'success') != 'error'
         ORDER BY q.last_used_at DESC, q.id DESC
       `)
@@ -1144,6 +1305,54 @@ class AppStateStore {
     return this.decorateQueryHistoryRow(row);
   }
 
+  findQueryHistoryItemBySql(databaseKey, rawSql) {
+    const normalizedDatabaseKey = this.normalizeQueryHistoryText(databaseKey);
+    const normalizedSql = normalizeSql(rawSql);
+
+    if (!normalizedDatabaseKey || !normalizedSql) {
+      return null;
+    }
+
+    const row = this.db
+      .prepare(`
+        SELECT
+          q.id,
+          q.database_key,
+          q.normalized_sql,
+          q.raw_sql,
+          q.title,
+          q.notes,
+          q.query_type,
+          q.tables_detected,
+          q.is_favorite,
+          q.is_saved,
+          q.is_destructive,
+          q.use_count,
+          q.first_executed_at,
+          q.last_used_at,
+          latest.id AS last_run_id,
+          latest.executed_at AS last_run_executed_at,
+          latest.duration_ms AS last_run_duration_ms,
+          latest.row_count AS last_run_row_count,
+          latest.status AS last_run_status,
+          latest.error_message AS last_run_error_message,
+          latest.affected_rows AS last_run_affected_rows
+        FROM query_history q
+        LEFT JOIN query_runs latest
+          ON latest.id = (
+            SELECT runs.id
+            FROM query_runs runs
+            WHERE runs.history_id = q.id
+            ORDER BY runs.executed_at DESC, runs.id DESC
+            LIMIT 1
+          )
+        WHERE q.database_key = ? AND q.normalized_sql = ?
+      `)
+      .get(normalizedDatabaseKey, normalizedSql);
+
+    return row ? this.decorateQueryHistoryRow(row) : null;
+  }
+
   getQueryHistoryItemForDatabase(historyId, databaseKey) {
     const item = this.getQueryHistoryItemById(historyId);
     const normalizedDatabaseKey = this.normalizeQueryHistoryText(databaseKey);
@@ -1155,6 +1364,16 @@ class AppStateStore {
     return item;
   }
 
+  getChartQueryHistoryItemForDatabase(historyId, databaseKey) {
+    const item = this.getQueryHistoryItemForDatabase(historyId, databaseKey);
+
+    if (!isChartCompatibleQueryType(item.queryType)) {
+      throw new ValidationError("Only SELECT queries can be opened in Charts.");
+    }
+
+    return item;
+  }
+
   getQueryRunsByHistoryId(historyId, limit = 8) {
     const normalizedLimit = Math.max(1, Math.min(50, Number(limit) || 8));
 
@@ -1259,7 +1478,7 @@ class AppStateStore {
   }
 
   getQueryHistoryChartsDetail(historyId, databaseKey) {
-    const item = this.getQueryHistoryItemForDatabase(historyId, databaseKey);
+    const item = this.getChartQueryHistoryItemForDatabase(historyId, databaseKey);
 
     return {
       item,
@@ -1318,7 +1537,7 @@ class AppStateStore {
     tableVisible = true,
     databaseKey = null,
   } = {}) {
-    const item = this.getQueryHistoryItemForDatabase(queryHistoryId, databaseKey);
+    const item = this.getChartQueryHistoryItemForDatabase(queryHistoryId, databaseKey);
     const normalizedChartType = normalizeChartType(chartType);
     const normalizedConfig = normalizeChartConfig(normalizedChartType, config);
     const normalizedResultColumns = normalizeResultColumns(resultColumns);
@@ -1860,6 +2079,106 @@ class AppStateStore {
 
     return this.getSettings();
   }
+
+  getMediaTaggingConfig(databaseKey) {
+    const normalizedDatabaseKey = String(databaseKey ?? "").trim();
+
+    if (!normalizedDatabaseKey) {
+      return null;
+    }
+
+    const row = this.db
+      .prepare(
+        `
+          SELECT
+            tag_table,
+            media_table,
+            path_column,
+            tagged_column,
+            untagged_query,
+            tagged_query,
+            mapping_table,
+            updated_at
+          FROM media_tagging_config
+          WHERE database_key = ?
+        `
+      )
+      .get(normalizedDatabaseKey);
+
+    if (!row) {
+      return null;
+    }
+
+    return {
+      config: structuredClone(this.buildMediaTaggingConfigRecord(row)),
+      updatedAt: row.updated_at ?? null,
+    };
+  }
+
+  setMediaTaggingConfig(databaseKey, config) {
+    const normalizedDatabaseKey = String(databaseKey ?? "").trim();
+
+    if (!normalizedDatabaseKey) {
+      throw new ValidationError("Media tagging configuration requires a database key.");
+    }
+
+    const updatedAt = new Date().toISOString();
+    const normalizedConfig = normalizeMediaTaggingConfigRecord(config);
+    const values = [
+      normalizedDatabaseKey,
+      normalizedConfig.tagTable,
+      normalizedConfig.mediaTable,
+      normalizedConfig.pathColumn,
+      normalizedConfig.taggedColumn,
+      normalizedConfig.untaggedQuery,
+      normalizedConfig.taggedQuery,
+      normalizedConfig.mappingTable,
+    ];
+    const explicitColumns = [
+      "database_key",
+      ...MEDIA_TAGGING_CONFIG_FIELDS.map((field) => field.column),
+    ];
+    const assignments = MEDIA_TAGGING_CONFIG_FIELDS.map(
+      (field) => `${field.column} = excluded.${field.column}`
+    );
+
+    if (this.mediaTaggingConfigHasLegacyJsonColumn) {
+      explicitColumns.push("config_json");
+      assignments.push("config_json = excluded.config_json");
+      values.push(JSON.stringify(normalizedConfig));
+    }
+
+    explicitColumns.push("updated_at");
+    assignments.push("updated_at = excluded.updated_at");
+    values.push(updatedAt);
+
+    this.db
+      .prepare(
+        `
+          INSERT INTO media_tagging_config (${explicitColumns.join(", ")})
+          VALUES (${explicitColumns.map(() => "?").join(", ")})
+          ON CONFLICT(database_key) DO UPDATE SET
+            ${assignments.join(",\n            ")}
+        `
+      )
+      .run(...values);
+
+    return this.getMediaTaggingConfig(normalizedDatabaseKey);
+  }
+
+  clearMediaTaggingConfig(databaseKey) {
+    const normalizedDatabaseKey = String(databaseKey ?? "").trim();
+
+    if (!normalizedDatabaseKey) {
+      return false;
+    }
+
+    const result = this.db
+      .prepare("DELETE FROM media_tagging_config WHERE database_key = ?")
+      .run(normalizedDatabaseKey);
+
+    return result.changes > 0;
+  }
 }
 
 module.exports = {