sqlite-hub 0.8.7 → 0.9.1

package/server/services/storage/appStateStore.js

@@ -46,6 +46,66 @@ 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 isChartCompatibleQuery(queryType, rawSql = "") {
+  return (
+    String(queryType ?? "").trim().toLowerCase() === "select" ||
+    detectQueryType(rawSql) === "select"
+  );
+}
 
 class AppStateStore {
   constructor(filePath, options = {}) {
@@ -200,6 +260,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 +284,8 @@ class AppStateStore {
     if (!recentConnectionColumns.has("logoPath")) {
       this.db.exec("ALTER TABLE recent_connections ADD COLUMN logoPath TEXT");
     }
+
+    this.ensureMediaTaggingConfigSchema();
   }
 
   seedDefaultSettings() {
@@ -481,6 +555,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 +754,9 @@ class AppStateStore {
         }),
       previewSql: buildSqlPreview(row.raw_sql ?? row.rawSql),
       lastRun,
+      chartsEligible:
+        isChartCompatibleQuery(queryType, row.raw_sql ?? row.rawSql) &&
+        (!lastRun || String(lastRun.status ?? "").trim().toLowerCase() !== "error"),
     };
   }
 
@@ -661,6 +817,7 @@ class AppStateStore {
     search,
     queryType,
     onlySaved = false,
+    onlyUnsaved = false,
     onlyFavorites = false,
     latestStatus = null,
   } = {}) {
@@ -702,6 +859,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 +897,7 @@ class AppStateStore {
     search = "",
     queryType = null,
     onlySaved = false,
+    onlyUnsaved = false,
     onlyFavorites = false,
     latestStatus = null,
   } = {}) {
@@ -768,6 +930,7 @@ class AppStateStore {
       search,
       queryType,
       onlySaved,
+      onlyUnsaved,
       onlyFavorites,
       latestStatus,
     });
@@ -1096,7 +1259,8 @@ class AppStateStore {
         ORDER BY q.last_used_at DESC, q.id DESC
       `)
       .all(normalizedDatabaseKey)
-      .map((row) => this.decorateQueryHistoryRow(row));
+      .map((row) => this.decorateQueryHistoryRow(row))
+      .filter((item) => item.chartsEligible);
   }
 
   getQueryHistoryItemById(historyId) {
@@ -1144,6 +1308,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 +1367,16 @@ class AppStateStore {
     return item;
   }
 
+  getChartQueryHistoryItemForDatabase(historyId, databaseKey) {
+    const item = this.getQueryHistoryItemForDatabase(historyId, databaseKey);
+
+    if (!isChartCompatibleQuery(item.queryType, item.rawSql)) {
+      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 +1481,7 @@ class AppStateStore {
   }
 
   getQueryHistoryChartsDetail(historyId, databaseKey) {
-    const item = this.getQueryHistoryItemForDatabase(historyId, databaseKey);
+    const item = this.getChartQueryHistoryItemForDatabase(historyId, databaseKey);
 
     return {
       item,
@@ -1318,7 +1540,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 +2082,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 = {

package/server/services/storage/queryHistoryUtils.js

@@ -37,11 +37,174 @@ function getLeadingKeywords(sql = "", limit = 3) {
   return matches.slice(0, limit).map((token) => token.toLowerCase());
 }
 
+function readWordAt(value = "", index = 0) {
+  const match = String(value).slice(index).match(/^[A-Za-z]+/);
+  return match ? match[0].toLowerCase() : "";
+}
+
+function skipWhitespace(value = "", index = 0) {
+  let cursor = index;
+
+  while (cursor < value.length && /\s/.test(value[cursor])) {
+    cursor += 1;
+  }
+
+  return cursor;
+}
+
+function advanceQuotedSql(value = "", index = 0) {
+  const quote = value[index];
+  const closingQuote = quote === "[" ? "]" : quote;
+  let cursor = index + 1;
+
+  while (cursor < value.length) {
+    if (value[cursor] === closingQuote) {
+      if ((quote === "'" || quote === '"') && value[cursor + 1] === closingQuote) {
+        cursor += 2;
+        continue;
+      }
+
+      return cursor + 1;
+    }
+
+    cursor += 1;
+  }
+
+  return value.length;
+}
+
+function isSqlWordBoundary(value = "", index = 0) {
+  return index < 0 || index >= value.length || !/[A-Za-z0-9_]/.test(value[index]);
+}
+
+function findTopLevelWord(value = "", word = "", startIndex = 0) {
+  const normalizedWord = String(word).toLowerCase();
+  let cursor = startIndex;
+  let depth = 0;
+
+  while (cursor < value.length) {
+    const char = value[cursor];
+
+    if (char === "'" || char === '"' || char === "`" || char === "[") {
+      cursor = advanceQuotedSql(value, cursor);
+      continue;
+    }
+
+    if (char === "(") {
+      depth += 1;
+      cursor += 1;
+      continue;
+    }
+
+    if (char === ")") {
+      depth = Math.max(0, depth - 1);
+      cursor += 1;
+      continue;
+    }
+
+    if (
+      depth === 0 &&
+      value.slice(cursor, cursor + normalizedWord.length).toLowerCase() === normalizedWord &&
+      isSqlWordBoundary(value, cursor - 1) &&
+      isSqlWordBoundary(value, cursor + normalizedWord.length)
+    ) {
+      return cursor;
+    }
+
+    cursor += 1;
+  }
+
+  return -1;
+}
+
+function findMatchingParen(value = "", openIndex = 0) {
+  let cursor = openIndex;
+  let depth = 0;
+
+  while (cursor < value.length) {
+    const char = value[cursor];
+
+    if (char === "'" || char === '"' || char === "`" || char === "[") {
+      cursor = advanceQuotedSql(value, cursor);
+      continue;
+    }
+
+    if (char === "(") {
+      depth += 1;
+    } else if (char === ")") {
+      depth -= 1;
+
+      if (depth === 0) {
+        return cursor;
+      }
+    }
+
+    cursor += 1;
+  }
+
+  return -1;
+}
+
+function resolveCteStatementKeyword(sql = "") {
+  const stripped = stripBlockComments(stripLineComments(sql)).trim();
+  let cursor = skipWhitespace(stripped, 0);
+
+  if (readWordAt(stripped, cursor) !== "with") {
+    return "";
+  }
+
+  cursor += 4;
+  cursor = skipWhitespace(stripped, cursor);
+
+  if (readWordAt(stripped, cursor) === "recursive") {
+    cursor += "recursive".length;
+  }
+
+  while (cursor < stripped.length) {
+    const asIndex = findTopLevelWord(stripped, "as", cursor);
+
+    if (asIndex < 0) {
+      return "with";
+    }
+
+    cursor = skipWhitespace(stripped, asIndex + 2);
+
+    if (readWordAt(stripped, cursor) === "not") {
+      cursor = skipWhitespace(stripped, cursor + 3);
+    }
+
+    if (readWordAt(stripped, cursor) === "materialized") {
+      cursor = skipWhitespace(stripped, cursor + "materialized".length);
+    }
+
+    if (stripped[cursor] !== "(") {
+      return "with";
+    }
+
+    const closeIndex = findMatchingParen(stripped, cursor);
+
+    if (closeIndex < 0) {
+      return "with";
+    }
+
+    cursor = skipWhitespace(stripped, closeIndex + 1);
+
+    if (stripped[cursor] === ",") {
+      cursor = skipWhitespace(stripped, cursor + 1);
+      continue;
+    }
+
+    return readWordAt(stripped, cursor) || "with";
+  }
+
+  return "with";
+}
+
 function resolveEffectiveKeyword(sql = "") {
-  const [firstKeyword, secondKeyword, thirdKeyword] = getLeadingKeywords(sql, 3);
+  const [firstKeyword, secondKeyword] = getLeadingKeywords(sql, 3);
 
   if (firstKeyword === "with") {
-    return secondKeyword === "recursive" ? thirdKeyword ?? "with" : secondKeyword ?? "with";
+    return resolveCteStatementKeyword(sql);
   }
 
   if (firstKeyword === "explain") {

package/shortkeys.md

@@ -0,0 +1,5 @@
+# Meddia Tagging
+
+## tagging queue
+
+`shift + enter` triggers tagged & next