sqlite-hub 2.0.0 → 2.1.0

package/server/services/mcpToolService.js

@@ -76,6 +76,28 @@ const MCP_TOOL_DEFINITIONS = [
       ["databaseId", "sql"]
     ),
   },
+  {
+    name: "get_stored_queries",
+    description: "List saved SQL Editor queries for a database. This is the MCP equivalent of `sqlite-hub --database:name --queries`.",
+    inputSchema: objectSchema({
+      databaseId: databaseIdProperty(),
+      limit: { type: "integer", minimum: 1, maximum: 500, default: 100 },
+    }, ["databaseId"]),
+  },
+  {
+    name: "execute_stored_query",
+    description: "Execute a saved SQL Editor query by id, title, display title, or SQL fragment. This is the MCP equivalent of `sqlite-hub --database:name --execute:\"query\"`.",
+    inputSchema: objectSchema(
+      {
+        databaseId: databaseIdProperty(),
+        queryName: {
+          type: "string",
+          description: "Saved query id, title, display title, or SQL fragment.",
+        },
+      },
+      ["databaseId", "queryName"]
+    ),
+  },
   {
     name: "explain_query_plan",
     description: "Run SQLite EXPLAIN QUERY PLAN for a read-only query and return structured plan rows.",
@@ -227,6 +249,12 @@ class McpToolService {
             executedBy: "mcp",
             maxRows: args.maxRows,
           });
+        case "get_stored_queries":
+          return this.databaseService.listSavedQueries(args.databaseId, args.limit);
+        case "execute_stored_query":
+          return this.databaseService.executeSavedQuery(args.databaseId, args.queryName, {
+            executedBy: "mcp",
+          });
         case "explain_query_plan":
           return this.databaseService.explainQueryPlan(args.databaseId, args.sql);
         case "read_documents":

package/server/services/sqlite/connectionManager.js

@@ -216,7 +216,7 @@ class ConnectionManager {
     return recentConnections;
   }
 
-  updateRecentConnection(id, { filePath, label, readOnly = false, logoUpload = null, clearLogo = false }) {
+  updateRecentConnection(id, { filePath, label, readOnly = false, logoUpload = null, clearLogo = false, tags = null }) {
     const recentConnections = this.appStateStore.getRecentConnections();
     const existing = recentConnections.find((connection) => connection.id === id);
 
@@ -245,7 +245,7 @@ class ConnectionManager {
 
     try {
       if (this.current?.id === id) {
-        return this.openConnection({
+        const connection = this.openConnection({
           filePath: resolvedPath,
           label: normalizedLabel,
           id,
@@ -253,6 +253,15 @@ class ConnectionManager {
           readOnly: normalizedReadOnly,
           logoPath: nextLogoPath,
         });
+
+        if (Array.isArray(tags)) {
+          this.appStateStore.setConnectionTags(id, tags);
+        }
+
+        return {
+          ...connection,
+          tags: this.appStateStore.getConnectionTags(id),
+        };
       }
 
       const db = this.openRawDatabase(resolvedPath, {
@@ -275,9 +284,14 @@ class ConnectionManager {
 
       this.appStateStore.updateRecentConnection(id, () => nextConnection);
 
+      if (Array.isArray(tags)) {
+        this.appStateStore.setConnectionTags(id, tags);
+      }
+
       return {
         ...nextConnection,
         logoUrl: this.appStateStore.getConnectionLogoUrl(nextLogoPath),
+        tags: this.appStateStore.getConnectionTags(id),
         isActive: false,
       };
     } catch (error) {
@@ -295,8 +309,11 @@ class ConnectionManager {
     }
 
     const { db, ...connection } = this.current;
+    const storedConnection = this.appStateStore.getRecentConnection(connection.id);
+
     return {
       ...connection,
+      tags: storedConnection?.tags ?? [],
       isActive: true,
     };
   }
@@ -334,6 +351,10 @@ class ConnectionManager {
     }));
   }
 
+  listConnectionTags() {
+    return this.appStateStore.listConnectionTags();
+  }
+
   getStatus() {
     const active = this.getActiveConnection();
 

package/server/services/sqlite/dataBrowserService.js

@@ -83,6 +83,14 @@ function isUnchangedSubmittedValue(currentValue, submittedValue) {
   return formatPreviewValue(currentValue) === formatPreviewValue(submittedValue);
 }
 
+function assertDataTableWritable(tableDetail) {
+  if (tableDetail.isShadow) {
+    throw new ValidationError(
+      `Shadow table ${tableDetail.name} is read-only in Data.`
+    );
+  }
+}
+
 class DataBrowserService {
   constructor({ connectionManager }) {
     this.connectionManager = connectionManager;
@@ -102,6 +110,9 @@ class DataBrowserService {
         return {
           name: entry.name,
           columnCount,
+          tableKind: entry.tableKind ?? "table",
+          isVirtual: Boolean(entry.isVirtual),
+          isShadow: Boolean(entry.isShadow),
         };
       });
   }
@@ -161,6 +172,10 @@ class DataBrowserService {
     return {
       name: tableDetail.name,
       type: tableDetail.type,
+      tableKind: tableDetail.tableKind,
+      isVirtual: Boolean(tableDetail.isVirtual),
+      isShadow: Boolean(tableDetail.isShadow),
+      readOnly: Boolean(tableDetail.isShadow),
       rowCount,
       limit,
       offset,
@@ -253,6 +268,8 @@ class DataBrowserService {
     const tableDetail = getTableDetail(db, tableName, { includeRowCount: false });
     const identity = payload.identity ?? null;
 
+    assertDataTableWritable(tableDetail);
+
     if (tableDetail.notSafelyUpdatable) {
       throw new ValidationError(
         `Table ${tableName} cannot be safely updated because it has no stable row identity.`
@@ -299,6 +316,8 @@ class DataBrowserService {
     const db = this.connectionManager.getActiveDatabase();
     const tableDetail = getTableDetail(db, tableName, { includeRowCount: false });
 
+    assertDataTableWritable(tableDetail);
+
     return insertSyntheticRows(db, tableDetail, payload);
   }
 
@@ -351,6 +370,8 @@ class DataBrowserService {
     const values = payload.values ?? {};
     const identity = payload.identity ?? null;
 
+    assertDataTableWritable(tableDetail);
+
     if (tableDetail.notSafelyUpdatable) {
       throw new ValidationError(
         `Table ${tableName} cannot be safely updated because it has no stable row identity.`

package/server/services/sqlite/introspection.js

@@ -19,6 +19,37 @@ function getTableListMap(db) {
   }
 }
 
+function normalizeTableKind(entry = {}, tableListEntry = null) {
+  const pragmaType = String(tableListEntry?.type ?? "")
+    .trim()
+    .toLowerCase();
+
+  if (pragmaType) {
+    return pragmaType;
+  }
+
+  if (entry.type === "table" && /^\s*CREATE\s+VIRTUAL\s+TABLE\b/i.test(entry.sql || "")) {
+    return "virtual";
+  }
+
+  return entry.type;
+}
+
+function decorateStructureEntry(entry, tableListMap = null) {
+  if (entry.type !== "table") {
+    return entry;
+  }
+
+  const tableKind = normalizeTableKind(entry, tableListMap?.get(entry.name));
+
+  return {
+    ...entry,
+    tableKind,
+    isVirtual: tableKind === "virtual",
+    isShadow: tableKind === "shadow",
+  };
+}
+
 function getMasterEntry(db, type, name) {
   const entry = db
     .prepare(
@@ -34,6 +65,8 @@ function getMasterEntry(db, type, name) {
 }
 
 function getRawStructureEntries(db) {
+  const tableListMap = getTableListMap(db);
+
   return db
     .prepare(
       [
@@ -43,7 +76,8 @@ function getRawStructureEntries(db) {
         "ORDER BY type ASC, name ASC",
       ].join(" ")
     )
-    .all();
+    .all()
+    .map((entry) => decorateStructureEntry(entry, tableListMap));
 }
 
 function normalizeColumn(column, visibleSet) {
@@ -607,11 +641,15 @@ function getTableDetail(db, tableName, options = {}) {
     typeof tableListEntry?.wr === "number"
       ? Boolean(tableListEntry.wr)
       : /WITHOUT\s+ROWID/i.test(entry.sql || "");
+  const tableKind = normalizeTableKind(entry, tableListEntry);
 
   const tableDetail = {
     type: entry.type,
     name: entry.name,
     ddl: entry.sql,
+    tableKind,
+    isVirtual: tableKind === "virtual",
+    isShadow: tableKind === "shadow",
     withoutRowId,
     strict: Boolean(tableListEntry?.strict),
     columns,

package/server/services/sqlite/structureService.js

@@ -3,6 +3,65 @@ const { quoteIdentifier } = require("../../utils/identifier");
 const { serializeRows } = require("../../utils/sqliteTypes");
 const { TypeGenerationService } = require("../typeGenerationService");
 
+function resolveShadowOwnerTableName(shadowTable, tables) {
+  if (!shadowTable?.isShadow) {
+    return null;
+  }
+
+  return (
+    tables
+      .filter((table) => table.isVirtual && shadowTable.name.startsWith(`${table.name}_`))
+      .sort((left, right) => right.name.length - left.name.length)[0]?.name ?? null
+  );
+}
+
+function unquoteSqlIdentifier(identifier) {
+  const value = String(identifier ?? "").trim();
+
+  if (value.length >= 2 && value[0] === '"' && value.at(-1) === '"') {
+    return value.slice(1, -1).replace(/""/g, '"');
+  }
+
+  if (value.length >= 2 && value[0] === "`" && value.at(-1) === "`") {
+    return value.slice(1, -1).replace(/``/g, "`");
+  }
+
+  if (value.length >= 2 && value[0] === "[" && value.at(-1) === "]") {
+    return value.slice(1, -1);
+  }
+
+  return value;
+}
+
+function extractVirtualTableModule(ddl = "") {
+  const match = String(ddl ?? "").match(
+    /\bUSING\s+("[^"]+(?:""[^"]*)*"|`[^`]+(?:``[^`]*)*`|\[[^\]]+\]|[A-Za-z_][A-Za-z0-9_]*)/i
+  );
+
+  return match ? unquoteSqlIdentifier(match[1]) : null;
+}
+
+function serializeGraphTable(table, shadowOwnerTableName = null) {
+  const isVirtual = Boolean(table.isVirtual);
+
+  return {
+    type: table.type,
+    name: table.name,
+    ddl: table.ddl,
+    tableKind: table.tableKind,
+    isVirtual,
+    isShadow: Boolean(table.isShadow),
+    virtualModule: isVirtual ? extractVirtualTableModule(table.ddl) : null,
+    shadowOwnerTable: shadowOwnerTableName,
+    withoutRowId: table.withoutRowId,
+    strict: table.strict,
+    columns: table.columns,
+    foreignKeys: table.foreignKeys,
+    identityStrategy: table.identityStrategy,
+    notSafelyUpdatable: table.notSafelyUpdatable,
+  };
+}
+
 class StructureService {
   constructor({ connectionManager, appStateStore }) {
     this.connectionManager = connectionManager;
@@ -35,17 +94,9 @@ class StructureService {
         triggers: entries.filter((entry) => entry.type === "trigger"),
       },
       graph: {
-        tables: tables.map((table) => ({
-          type: table.type,
-          name: table.name,
-          ddl: table.ddl,
-          withoutRowId: table.withoutRowId,
-          strict: table.strict,
-          columns: table.columns,
-          foreignKeys: table.foreignKeys,
-          identityStrategy: table.identityStrategy,
-          notSafelyUpdatable: table.notSafelyUpdatable,
-        })),
+        tables: tables.map((table) =>
+          serializeGraphTable(table, resolveShadowOwnerTableName(table, tables))
+        ),
         relationshipCount,
       },
     };
@@ -65,6 +116,10 @@ class StructureService {
       type: table.type,
       name: table.name,
       ddl: table.ddl,
+      tableKind: table.tableKind,
+      isVirtual: Boolean(table.isVirtual),
+      isShadow: Boolean(table.isShadow),
+      virtualModule: table.isVirtual ? extractVirtualTableModule(table.ddl) : null,
       withoutRowId: table.withoutRowId,
       strict: table.strict,
       columns: table.columns,

package/server/services/sqlite/tableAdvisor.js

@@ -763,12 +763,18 @@ function analyzeTable(db, tableName) {
     score: calculateScore(issues),
     issueCount: issues.length,
     rowCount: Number(tableDetail.rowCount ?? 0),
+    tableKind: tableDetail.tableKind,
+    isVirtual: Boolean(tableDetail.isVirtual),
+    isShadow: Boolean(tableDetail.isShadow),
     issues,
     columnProfiles,
     table: {
       columnCount: (tableDetail.columns ?? []).filter((column) => column.visible && !column.generated).length,
       indexCount: (tableDetail.indexes ?? []).length,
       foreignKeyCount: (tableDetail.foreignKeys ?? []).length,
+      tableKind: tableDetail.tableKind,
+      isVirtual: Boolean(tableDetail.isVirtual),
+      isShadow: Boolean(tableDetail.isShadow),
     },
     analyzedAt: new Date().toISOString(),
   };

package/server/services/sqlite/tableDesigner/schemaMapping.js

@@ -159,6 +159,9 @@ function buildCheckConstraints(tableDetail) {
       originalExpression: expression ? `CHECK (${expression})` : "CHECK constraint",
       editable: true,
       preserved: true,
+      source: "detected",
+      presetId: "",
+      presetFields: {},
     };
   });
 }
@@ -300,7 +303,7 @@ function buildTableDesignerDraft(tableDetail) {
 
 function listDesignerTables(db) {
   return getRawStructureEntries(db)
-    .filter((entry) => entry.type === "table")
+    .filter((entry) => entry.type === "table" && !entry.isShadow)
     .map((entry) => {
       const columns = db
         .prepare(`PRAGMA table_xinfo(${quoteIdentifier(entry.name)})`)
@@ -312,6 +315,9 @@ function listDesignerTables(db) {
         name: entry.name,
         columnCount: columns.length,
         columns,
+        tableKind: entry.tableKind ?? "table",
+        isVirtual: Boolean(entry.isVirtual),
+        isShadow: Boolean(entry.isShadow),
       };
     })
     .sort((left, right) => left.name.localeCompare(right.name, undefined, { sensitivity: "base" }));

package/server/services/sqlite/tableDesigner/sql.js

@@ -35,10 +35,39 @@ function buildColumnDefinition(column) {
   return parts.join(" ");
 }
 
+function normalizeCheckExpressionSql(expression) {
+  const normalized = normalizeSqlFragment(expression);
+
+  if (!normalized) {
+    return "";
+  }
+
+  if (/^CHECK\s*\(/i.test(normalized)) {
+    return normalized;
+  }
+
+  return `CHECK (${normalized})`;
+}
+
+function buildCheckConstraintSql(constraint) {
+  if (constraint.deleted) {
+    return "";
+  }
+
+  return normalizeCheckExpressionSql(constraint.expression);
+}
+
 function buildCreateTableSql(draft) {
-  const columnSql = draft.columns.map((column) => `  ${buildColumnDefinition(column)}`).join(",\n");
+  const columnSql = draft.columns
+    .filter((column) => !column.deleted)
+    .map((column) => `  ${buildColumnDefinition(column)}`);
+  const checkSql = (draft.checkConstraints ?? [])
+    .map(buildCheckConstraintSql)
+    .filter(Boolean)
+    .map((constraintSql) => `  ${constraintSql}`);
+  const definitionSql = [...columnSql, ...checkSql].join(",\n");
 
-  return `CREATE TABLE ${quoteIdentifier(draft.tableName)} (\n${columnSql}\n);`;
+  return `CREATE TABLE ${quoteIdentifier(draft.tableName)} (\n${definitionSql}\n);`;
 }
 
 function buildAlterTableRenameSql(fromName, toName) {

package/server/services/sqlite/tableDesigner/validation.js

@@ -10,6 +10,36 @@ function normalizeSqlFragment(value) {
   return String(value ?? "").trim();
 }
 
+function normalizeImportFormat(value) {
+  const normalized = String(value ?? "").trim().toLowerCase();
+
+  return ["csv", "tsv", "json"].includes(normalized) ? normalized : "";
+}
+
+function normalizeImportedCellValue(value) {
+  if (value === null || value === undefined) {
+    return null;
+  }
+
+  if (["boolean", "number", "string"].includes(typeof value)) {
+    return value;
+  }
+
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+
+function normalizeImportedRows(rows) {
+  return Array.isArray(rows)
+    ? rows.map((row) =>
+        Array.isArray(row) ? row.map((cell) => normalizeImportedCellValue(cell)) : []
+      )
+    : [];
+}
+
 function assertSafeSqlFragment(value, label, { allowEmpty = true } = {}) {
   const normalized = normalizeSqlFragment(value);
 
@@ -96,6 +126,7 @@ function normalizeCheckConstraintPayload(constraint = {}, index = 0) {
     id: String(constraint.id ?? `check:${index}`),
     name: String(constraint.name ?? `CHECK ${index + 1}`).trim(),
     originalName: String(constraint.originalName ?? constraint.name ?? `CHECK ${index + 1}`).trim(),
+    deleted: normalizeBoolean(constraint.deleted),
     columns: Array.isArray(constraint.columns)
       ? constraint.columns
           .map((column) => ({
@@ -110,11 +141,28 @@ function normalizeCheckConstraintPayload(constraint = {}, index = 0) {
     originalExpression: String(constraint.originalExpression ?? constraint.expression ?? "").trim(),
     editable: normalizeBoolean(constraint.editable),
     preserved: constraint.preserved === undefined ? true : normalizeBoolean(constraint.preserved),
+    columnId: String(constraint.columnId ?? "").trim(),
+    source: String(constraint.source ?? (constraint.originalExpression ? "detected" : "user")).trim(),
+    presetId: String(constraint.presetId ?? "").trim(),
+    presetFields:
+      constraint.presetFields && typeof constraint.presetFields === "object"
+        ? Object.fromEntries(
+            Object.entries(constraint.presetFields).map(([key, value]) => [key, String(value ?? "")])
+          )
+        : {},
   };
 }
 
 function normalizeDraftPayload(payload = {}) {
   const mode = String(payload.mode ?? "create").trim() === "edit" ? "edit" : "create";
+  const importRows = normalizeImportedRows(payload.importRows ?? payload.importedCsvRows);
+  const importSourceFileName = String(
+    payload.importSourceFileName ?? payload.importedCsvFileName ?? ""
+  ).trim();
+  const importDelimiter = String(payload.importDelimiter ?? payload.importedCsvDelimiter ?? "").trim();
+  const importFormat = normalizeImportFormat(
+    payload.importFormat ?? (importSourceFileName ? "csv" : "")
+  );
 
   return {
     mode,
@@ -137,13 +185,13 @@ function normalizeDraftPayload(payload = {}) {
     schemaWarnings: Array.isArray(payload.schemaWarnings) ? payload.schemaWarnings : [],
     warnings: Array.isArray(payload.warnings) ? payload.warnings : [],
     fillImportedRows: normalizeBoolean(payload.fillImportedRows),
-    importedCsvFileName: String(payload.importedCsvFileName ?? "").trim(),
-    importedCsvDelimiter: String(payload.importedCsvDelimiter ?? "").trim(),
-    importedCsvRows: Array.isArray(payload.importedCsvRows)
-      ? payload.importedCsvRows.map((row) =>
-          Array.isArray(row) ? row.map((cell) => String(cell ?? "")) : []
-        )
-      : [],
+    importFormat,
+    importSourceFileName,
+    importDelimiter,
+    importRows,
+    importedCsvFileName: importSourceFileName,
+    importedCsvDelimiter: importDelimiter,
+    importedCsvRows: importRows,
     dirty: normalizeBoolean(payload.dirty),
   };
 }
@@ -290,9 +338,21 @@ function validateTableDesignerDraft(draft, { catalogTables = [], originalDraft =
     throw new ValidationError("Imported row fill is only available when creating a table.");
   }
 
-  if (draft.fillImportedRows && !draft.importedCsvRows.length) {
-    throw new ValidationError("Fill requires imported CSV rows.");
+  if (draft.fillImportedRows && !draft.importRows.length) {
+    throw new ValidationError("Fill requires imported rows.");
   }
+
+  (draft.checkConstraints ?? [])
+    .filter((constraint) => !constraint.deleted)
+    .forEach((constraint) => {
+      const label = constraint.name || "CHECK constraint";
+
+      if (!String(constraint.expression ?? "").trim()) {
+        throw new ValidationError(`${constraint.name || "CHECK constraint"} needs an expression.`);
+      }
+
+      assertSafeSqlFragment(constraint.expression, label, { allowEmpty: false });
+    });
 }
 
 module.exports = {