sqlite-hub 0.3.2 → 0.5.0

package/server/services/storage/queryHistoryUtils.js

@@ -0,0 +1,169 @@
+function stripLineComments(sql = "") {
+  return String(sql)
+    .split(/\r?\n/)
+    .map((line) => line.replace(/--.*$/g, ""))
+    .join("\n");
+}
+
+function stripBlockComments(sql = "") {
+  return String(sql).replace(/\/\*[\s\S]*?\*\//g, " ");
+}
+
+function compactWhitespace(value = "") {
+  return String(value).replace(/\s+/g, " ").trim();
+}
+
+function truncateText(value = "", maxLength = 80) {
+  const text = String(value ?? "").trim();
+
+  if (text.length <= maxLength) {
+    return text;
+  }
+
+  return `${text.slice(0, Math.max(0, maxLength - 3)).trimEnd()}...`;
+}
+
+function normalizeSql(sql = "") {
+  const withoutComments = stripBlockComments(stripLineComments(sql));
+  const compact = compactWhitespace(withoutComments).replace(/;+\s*$/g, "").trim();
+
+  return compact.toLowerCase();
+}
+
+function getLeadingKeywords(sql = "", limit = 3) {
+  const stripped = stripBlockComments(stripLineComments(sql));
+  const matches = stripped.match(/[A-Za-z]+/g) ?? [];
+
+  return matches.slice(0, limit).map((token) => token.toLowerCase());
+}
+
+function resolveEffectiveKeyword(sql = "") {
+  const [firstKeyword, secondKeyword, thirdKeyword] = getLeadingKeywords(sql, 3);
+
+  if (firstKeyword === "with") {
+    return secondKeyword === "recursive" ? thirdKeyword ?? "with" : secondKeyword ?? "with";
+  }
+
+  if (firstKeyword === "explain") {
+    return secondKeyword ?? "explain";
+  }
+
+  return firstKeyword ?? "";
+}
+
+function detectQueryType(sql = "") {
+  const keyword = resolveEffectiveKeyword(sql);
+
+  if (keyword === "select") {
+    return "select";
+  }
+
+  if (keyword === "insert") {
+    return "insert";
+  }
+
+  if (keyword === "update") {
+    return "update";
+  }
+
+  if (keyword === "delete") {
+    return "delete";
+  }
+
+  if (keyword === "pragma") {
+    return "pragma";
+  }
+
+  if (["create", "alter", "drop", "rename", "truncate"].includes(keyword)) {
+    return "ddl";
+  }
+
+  return "other";
+}
+
+function isDestructiveQuery(sql = "") {
+  const keyword = resolveEffectiveKeyword(sql);
+  return ["insert", "update", "delete", "alter", "drop", "replace"].includes(keyword);
+}
+
+function normalizeTableName(candidate = "") {
+  const trimmed = String(candidate ?? "")
+    .trim()
+    .replace(/[;,)]*$/g, "");
+
+  if (!trimmed || trimmed.startsWith("(")) {
+    return null;
+  }
+
+  const segments = trimmed.split(".").filter(Boolean);
+  const finalSegment = segments.at(-1) ?? trimmed;
+  const normalized = finalSegment.replace(/^["`[]|["`\]]$/g, "");
+
+  if (!normalized || ["select", "with", "pragma"].includes(normalized.toLowerCase())) {
+    return null;
+  }
+
+  return normalized;
+}
+
+function collectTableMatches(sql = "", patterns = []) {
+  const text = stripBlockComments(stripLineComments(sql));
+  const tableNames = [];
+
+  patterns.forEach((pattern) => {
+    let match;
+
+    while ((match = pattern.exec(text))) {
+      const tableName = normalizeTableName(match[1]);
+
+      if (tableName) {
+        tableNames.push(tableName);
+      }
+    }
+  });
+
+  return Array.from(new Set(tableNames));
+}
+
+function detectTables(sql = "") {
+  return collectTableMatches(sql, [
+    /\bfrom\s+([^\s,;()]+)/gi,
+    /\bjoin\s+([^\s,;()]+)/gi,
+    /\bupdate(?:\s+or\s+\w+)?\s+([^\s,;()]+)/gi,
+    /\binto\s+([^\s,;()]+)/gi,
+    /\btable\s+(?:if\s+(?:not\s+)?exists\s+)?([^\s,;()]+)/gi,
+  ]);
+}
+
+function buildAutoTitle(rawSql = "", { queryType = "other", tablesDetected = [] } = {}) {
+  const firstMeaningfulLine = String(rawSql)
+    .split(/\r?\n/)
+    .map((line) => line.replace(/--.*$/g, "").trim())
+    .find(Boolean);
+
+  if (firstMeaningfulLine) {
+    return truncateText(firstMeaningfulLine.replace(/;+\s*$/g, ""), 80);
+  }
+
+  const primaryTable = tablesDetected[0] ? ` on ${tablesDetected[0]}` : "";
+
+  if (queryType && queryType !== "other") {
+    return `${queryType.toUpperCase()}${primaryTable}`;
+  }
+
+  return primaryTable ? `Query${primaryTable}` : "SQL query";
+}
+
+function buildSqlPreview(rawSql = "", maxLength = 140) {
+  const compact = compactWhitespace(stripLineComments(rawSql));
+  return truncateText(compact, maxLength) || "SQL query";
+}
+
+module.exports = {
+  buildAutoTitle,
+  buildSqlPreview,
+  detectQueryType,
+  detectTables,
+  isDestructiveQuery,
+  normalizeSql,
+};

package/server/utils/appPaths.js

@@ -6,6 +6,13 @@ const APP_NAME = "sqlite-hub";
 const APP_STATE_DB_FILENAME = "sqlite-hub-state.db";
 const LEGACY_STATE_FILENAME = "app-state.json";
 
+function resolvePackagedDataDirectories(packageRoot) {
+  return [
+    path.resolve(packageRoot, "server", "data"),
+    path.resolve(packageRoot, "data"),
+  ].filter((candidatePath, index, candidates) => candidates.indexOf(candidatePath) === index);
+}
+
 function resolveAppStateDirectory() {
   const homeDirectory = os.homedir();
 
@@ -28,7 +35,7 @@ function resolveAppStateDirectory() {
 }
 
 function resolvePackagedDataDirectory(packageRoot) {
-  return path.resolve(packageRoot, "data");
+  return resolvePackagedDataDirectories(packageRoot)[0];
 }
 
 function resolvePackagedAppStateDbPath(packageRoot) {
@@ -36,7 +43,11 @@ function resolvePackagedAppStateDbPath(packageRoot) {
 }
 
 function resolvePackagedLegacyStatePath(packageRoot) {
-  return path.join(resolvePackagedDataDirectory(packageRoot), LEGACY_STATE_FILENAME);
+  const candidates = resolvePackagedDataDirectories(packageRoot).map((directoryPath) =>
+    path.join(directoryPath, LEGACY_STATE_FILENAME)
+  );
+
+  return candidates.find((candidatePath) => fs.existsSync(candidatePath)) ?? candidates[0];
 }
 
 function resolveHomebrewCellarInfo(packageRoot) {
@@ -83,23 +94,34 @@ function collectHomebrewLegacyStateDbPaths(packageRoot) {
   return fs
     .readdirSync(cellarInfo.cellarRoot, { withFileTypes: true })
     .filter((entry) => entry.isDirectory() && entry.name !== cellarInfo.currentVersion)
-    .map((entry) => {
-      const candidatePath = path.join(
-        cellarInfo.cellarRoot,
-        entry.name,
-        "libexec",
-        "lib",
-        "node_modules",
-        APP_NAME,
-        "data",
-        APP_STATE_DB_FILENAME
-      );
-
-      return {
+    .flatMap((entry) =>
+      [
+        path.join(
+          cellarInfo.cellarRoot,
+          entry.name,
+          "libexec",
+          "lib",
+          "node_modules",
+          APP_NAME,
+          "server",
+          "data",
+          APP_STATE_DB_FILENAME
+        ),
+        path.join(
+          cellarInfo.cellarRoot,
+          entry.name,
+          "libexec",
+          "lib",
+          "node_modules",
+          APP_NAME,
+          "data",
+          APP_STATE_DB_FILENAME
+        ),
+      ].map((candidatePath) => ({
         path: candidatePath,
         mtimeMs: safeStatMtimeMs(candidatePath),
-      };
-    })
+      }))
+    )
     .filter((candidate) => candidate.mtimeMs >= 0)
     .sort((left, right) => right.mtimeMs - left.mtimeMs)
     .map((candidate) => candidate.path);
@@ -107,7 +129,9 @@ function collectHomebrewLegacyStateDbPaths(packageRoot) {
 
 function collectLegacyDatabasePaths(packageRoot) {
   return [
-    resolvePackagedAppStateDbPath(packageRoot),
+    ...resolvePackagedDataDirectories(packageRoot).map((directoryPath) =>
+      path.join(directoryPath, APP_STATE_DB_FILENAME)
+    ),
     ...collectHomebrewLegacyStateDbPaths(packageRoot),
   ].filter((candidatePath, index, candidates) => candidates.indexOf(candidatePath) === index);
 }

package/{js → frontend/js}/components/bottomTabs.js

@@ -3,8 +3,8 @@ import { escapeHtml } from "../utils/format.js";
 export function renderBottomTabs(activeTab, counts = {}) {
   const tabs = [
     { key: "results", label: "results", meta: counts.resultRows ?? 0 },
-    { key: "messages", label: "messages", meta: counts.messages ?? 0 },
     { key: "performance", label: "performance", meta: counts.statementCount ?? 0 },
+    { key: "messages", label: "messages", meta: counts.messages ?? 0 },
   ];
 
   return `