sqlite-hub 2.0.0 → 2.1.0

package/server/services/sqlite/tableDesignerService.js

@@ -1,4 +1,5 @@
 const { mapSqliteError, ValidationError } = require("../../utils/errors");
+const { quoteIdentifier } = require("../../utils/identifier");
 const { getTableDetail } = require("./introspection");
 const { analyzeTableDesignerChanges } = require("./tableDesigner/changeAnalysis");
 const {
@@ -19,15 +20,31 @@ function getImportedFillColumns(draft) {
   );
 }
 
+function getImportedRows(draft) {
+  return Array.isArray(draft.importRows) && draft.importRows.length
+    ? draft.importRows
+    : draft.importedCsvRows ?? [];
+}
+
 function coerceImportedCellValue(column, value) {
-  const textValue = String(value ?? "");
-  const trimmedValue = textValue.trim();
+  if (value === null || value === undefined) {
+    return null;
+  }
+
+  const normalizedValue =
+    typeof value === "object" ? JSON.stringify(value) : value;
   const type = normalizeDesignerType(column.type);
+  const textValue = String(normalizedValue ?? "");
+  const trimmedValue = textValue.trim();
 
   if (!trimmedValue) {
     return ["TEXT", "DATE", "DATETIME"].includes(type) ? "" : null;
   }
 
+  if (typeof normalizedValue === "boolean") {
+    return normalizedValue ? 1 : 0;
+  }
+
   if (type === "BOOLEAN") {
     const normalized = trimmedValue.toLowerCase();
 
@@ -54,6 +71,35 @@ function coerceImportedCellValue(column, value) {
   return textValue;
 }
 
+function normalizeCheckExpressionSql(expression) {
+  const normalized = String(expression ?? "").trim();
+
+  if (/^CHECK\s*\(/i.test(normalized)) {
+    return normalized;
+  }
+
+  return `CHECK (${normalized})`;
+}
+
+function assertSafeCheckExpressionFragment(expression) {
+  const normalized = String(expression ?? "").trim();
+
+  if (
+    normalized.includes("\0") ||
+    normalized.includes(";") ||
+    normalized.includes("--") ||
+    normalized.includes("/*") ||
+    normalized.includes("*/")
+  ) {
+    throw new ValidationError(
+      "CHECK expression must be a single SQL fragment without statement separators or comments.",
+      {
+        code: "CHECK_EXPRESSION_INVALID_FRAGMENT",
+      }
+    );
+  }
+}
+
 class TableDesignerService {
   constructor({ connectionManager }) {
     this.connectionManager = connectionManager;
@@ -126,7 +172,9 @@ class TableDesignerService {
     const executeCreateWithImport = db.transaction((nextDraft) => {
       db.exec(buildCreateTableSql(nextDraft));
 
-      if (!nextDraft.fillImportedRows || !nextDraft.importedCsvRows.length) {
+      const importRows = getImportedRows(nextDraft);
+
+      if (!nextDraft.fillImportedRows || !importRows.length) {
         return;
       }
 
@@ -143,10 +191,10 @@ class TableDesignerService {
         )
       );
 
-      nextDraft.importedCsvRows.forEach((row) => {
+      importRows.forEach((row) => {
         insertStatement.run(
           importedColumns.map((column) =>
-            coerceImportedCellValue(column, row[column.importedValueIndex] ?? "")
+            coerceImportedCellValue(column, row[column.importedValueIndex])
           )
         );
       });
@@ -174,6 +222,63 @@ class TableDesignerService {
       tables: listDesignerTables(db),
     };
   }
+
+  validateCheckExpression(payload = {}) {
+    const db = this.connectionManager.getActiveDatabase();
+    const draft = normalizeDraftPayload(payload.draft ?? {});
+    const expression = String(payload.expression ?? "").trim();
+
+    if (!expression) {
+      throw new ValidationError("CHECK expression is required.", {
+        code: "CHECK_EXPRESSION_REQUIRED",
+      });
+    }
+
+    assertSafeCheckExpressionFragment(expression);
+
+    const columns = draft.columns.filter((column) => !column.deleted && column.name);
+
+    if (!columns.length) {
+      throw new ValidationError("At least one named column is required to validate a CHECK expression.", {
+        code: "CHECK_VALIDATION_COLUMNS_REQUIRED",
+      });
+    }
+
+    const tempTableName = `__sqlite_hub_check_validation_${Date.now()}_${Math.random()
+      .toString(16)
+      .slice(2)}`;
+    const tempDraft = {
+      ...draft,
+      tableName: tempTableName,
+      columns,
+      checkConstraints: [
+        {
+          id: "check:validation",
+          expression,
+        },
+      ],
+    };
+    const createSql = buildCreateTableSql(tempDraft).replace(/^CREATE TABLE\s+/i, "CREATE TEMP TABLE ");
+    const dropSql = `DROP TABLE IF EXISTS ${quoteIdentifier(tempTableName)};`;
+
+    try {
+      db.exec(dropSql);
+      db.exec(createSql);
+      db.exec(dropSql);
+      return {
+        valid: true,
+        generatedSql: normalizeCheckExpressionSql(expression),
+      };
+    } catch (error) {
+      try {
+        db.exec(dropSql);
+      } catch {
+        // Ignore cleanup failures; the validation error below is the useful signal.
+      }
+
+      throw mapSqliteError(error);
+    }
+  }
 }
 
 module.exports = {

package/server/services/storage/appStateStore.js

@@ -40,6 +40,7 @@ const CONNECTION_LOGO_DIRECTORY = "db_logos";
 const LEGACY_STATE_FILENAME = "app-state.json";
 const STATE_DATABASE_FILENAME = "sqlite-hub-state.db";
 const MAX_CONNECTION_LOGO_SIZE_BYTES = 5 * 1024 * 1024;
+const MAX_CONNECTION_TAG_NAME_LENGTH = 40;
 const MAX_DOCUMENT_CONTENT_BYTES = 5 * 1024 * 1024;
 const MAX_DOCUMENT_FILENAME_LENGTH = 160;
 const QUERY_EXECUTION_SOURCES = new Set(["api", "cli", "user", "mcp"]);
@@ -251,6 +252,44 @@ const CONNECTION_LOGO_EXTENSION_BY_FILE_EXTENSION = {
   ".png": "png",
   ".webp": "webp",
 };
+
+function normalizeConnectionTagName(value) {
+  const normalizedName = String(value ?? "")
+    .replace(/[\u0000-\u001f\u007f]/g, " ")
+    .trim();
+
+  if (!normalizedName) {
+    throw new ValidationError("Tag name is required.");
+  }
+
+  if (normalizedName.length > MAX_CONNECTION_TAG_NAME_LENGTH) {
+    throw new ValidationError(
+      `Tag name must be ${MAX_CONNECTION_TAG_NAME_LENGTH} characters or fewer.`
+    );
+  }
+
+  return normalizedName;
+}
+
+function normalizeConnectionTagNames(values = []) {
+  if (!Array.isArray(values)) {
+    return [];
+  }
+
+  const namesByKey = new Map();
+
+  for (const value of values) {
+    const name = normalizeConnectionTagName(value);
+    const key = name.toLowerCase();
+
+    if (!namesByKey.has(key)) {
+      namesByKey.set(key, name);
+    }
+  }
+
+  return [...namesByKey.values()];
+}
+
 const MEDIA_TAGGING_CONFIG_FIELDS = [
   {
     column: "tag_table",
@@ -464,6 +503,29 @@ class AppStateStore {
       CREATE INDEX IF NOT EXISTS idx_recent_connections_last_opened
       ON recent_connections(lastOpenedAt DESC, id ASC);
 
+      CREATE TABLE IF NOT EXISTS tags (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        name TEXT NOT NULL COLLATE NOCASE UNIQUE,
+        createdAt TEXT NOT NULL,
+        updatedAt TEXT NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS connection_tags (
+        connectionId TEXT NOT NULL,
+        tagId INTEGER NOT NULL,
+        PRIMARY KEY (connectionId, tagId),
+        FOREIGN KEY (connectionId)
+          REFERENCES recent_connections(id)
+          ON UPDATE CASCADE
+          ON DELETE CASCADE,
+        FOREIGN KEY (tagId)
+          REFERENCES tags(id)
+          ON DELETE CASCADE
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_connection_tags_tag
+      ON connection_tags(tagId, connectionId);
+
       CREATE TABLE IF NOT EXISTS query_history (
         id INTEGER PRIMARY KEY AUTOINCREMENT,
         database_key TEXT NOT NULL,
@@ -2917,8 +2979,142 @@ class AppStateStore {
     });
   }
 
-  getRecentConnections() {
+  decorateConnectionTag(row = {}) {
+    return {
+      id: Number(row.id),
+      name: String(row.name ?? ""),
+      createdAt: row.createdAt ?? null,
+      updatedAt: row.updatedAt ?? null,
+      ...(row.connectionCount === undefined
+        ? {}
+        : { connectionCount: Number(row.connectionCount ?? 0) }),
+    };
+  }
+
+  getConnectionTagsByConnectionIds(connectionIds = []) {
+    const ids = connectionIds
+      .map((id) => String(id ?? "").trim())
+      .filter(Boolean)
+      .filter((id, index, values) => values.indexOf(id) === index);
+
+    if (!ids.length) {
+      return new Map();
+    }
+
+    const placeholders = ids.map(() => "?").join(", ");
+    const rows = this.db
+      .prepare(
+        `
+          SELECT
+            ct.connectionId,
+            t.id,
+            t.name,
+            t.createdAt,
+            t.updatedAt
+          FROM connection_tags ct
+          INNER JOIN tags t
+            ON t.id = ct.tagId
+          WHERE ct.connectionId IN (${placeholders})
+          ORDER BY t.name COLLATE NOCASE ASC, t.id ASC
+        `
+      )
+      .all(...ids);
+    const tagsByConnectionId = new Map(ids.map((id) => [id, []]));
+
+    for (const row of rows) {
+      tagsByConnectionId
+        .get(row.connectionId)
+        ?.push(this.decorateConnectionTag(row));
+    }
+
+    return tagsByConnectionId;
+  }
+
+  getConnectionTags(connectionId) {
+    const normalizedConnectionId = String(connectionId ?? "").trim();
+
+    if (!normalizedConnectionId) {
+      return [];
+    }
+
+    return this.getConnectionTagsByConnectionIds([normalizedConnectionId]).get(
+      normalizedConnectionId
+    ) ?? [];
+  }
+
+  listConnectionTags() {
     return this.db
+      .prepare(
+        `
+          SELECT
+            t.id,
+            t.name,
+            t.createdAt,
+            t.updatedAt,
+            COUNT(ct.connectionId) AS connectionCount
+          FROM tags t
+          LEFT JOIN connection_tags ct
+            ON ct.tagId = t.id
+          GROUP BY t.id
+          ORDER BY t.name COLLATE NOCASE ASC, t.id ASC
+        `
+      )
+      .all()
+      .map((row) => this.decorateConnectionTag(row));
+  }
+
+  getConnectionTagById(tagId) {
+    const row = this.db
+      .prepare(
+        `
+          SELECT id, name, createdAt, updatedAt
+          FROM tags
+          WHERE id = ?
+        `
+      )
+      .get(Number(tagId));
+
+    return row ? this.decorateConnectionTag(row) : null;
+  }
+
+  getConnectionTagByName(name) {
+    const normalizedName = normalizeConnectionTagName(name);
+    const row = this.db
+      .prepare(
+        `
+          SELECT id, name, createdAt, updatedAt
+          FROM tags
+          WHERE name = ? COLLATE NOCASE
+        `
+      )
+      .get(normalizedName);
+
+    return row ? this.decorateConnectionTag(row) : null;
+  }
+
+  getOrCreateConnectionTag(name) {
+    const normalizedName = normalizeConnectionTagName(name);
+    const existingTag = this.getConnectionTagByName(normalizedName);
+
+    if (existingTag) {
+      return existingTag;
+    }
+
+    const timestamp = new Date().toISOString();
+    const result = this.db
+      .prepare(
+        `
+          INSERT INTO tags (name, createdAt, updatedAt)
+          VALUES (?, ?, ?)
+        `
+      )
+      .run(normalizedName, timestamp, timestamp);
+
+    return this.getConnectionTagById(result.lastInsertRowid);
+  }
+
+  getRecentConnections() {
+    const rows = this.db
       .prepare(`
         SELECT
           id,
@@ -2932,8 +3128,108 @@ class AppStateStore {
         FROM recent_connections
         ORDER BY lastOpenedAt DESC, id ASC
       `)
-      .all()
-      .map((connection) => this.decorateConnection(connection));
+      .all();
+    const tagsByConnectionId = this.getConnectionTagsByConnectionIds(
+      rows.map((connection) => connection.id)
+    );
+
+    return rows.map((connection) =>
+      this.decorateConnection(
+        connection,
+        tagsByConnectionId.get(connection.id) ?? []
+      )
+    );
+  }
+
+  getRecentConnection(id) {
+    return (
+      this.getRecentConnections().find(
+        (connection) => connection.id === String(id ?? "").trim()
+      ) ?? null
+    );
+  }
+
+  assertRecentConnectionExists(id) {
+    const normalizedConnectionId = String(id ?? "").trim();
+
+    if (!normalizedConnectionId) {
+      throw new ValidationError("Connection id is required.");
+    }
+
+    const row = this.db
+      .prepare("SELECT id FROM recent_connections WHERE id = ?")
+      .get(normalizedConnectionId);
+
+    if (!row) {
+      throw new NotFoundError(`Recent connection not found: ${normalizedConnectionId}`);
+    }
+
+    return normalizedConnectionId;
+  }
+
+  setConnectionTags(connectionId, tagNames = []) {
+    const normalizedConnectionId = this.assertRecentConnectionExists(connectionId);
+    const normalizedTagNames = normalizeConnectionTagNames(tagNames);
+
+    this.db.transaction(() => {
+      this.db
+        .prepare("DELETE FROM connection_tags WHERE connectionId = ?")
+        .run(normalizedConnectionId);
+
+      for (const tagName of normalizedTagNames) {
+        const tag = this.getOrCreateConnectionTag(tagName);
+
+        this.db
+          .prepare(
+            `
+              INSERT OR IGNORE INTO connection_tags (connectionId, tagId)
+              VALUES (?, ?)
+            `
+          )
+          .run(normalizedConnectionId, tag.id);
+      }
+    })();
+
+    return this.getConnectionTags(normalizedConnectionId);
+  }
+
+  addConnectionTag(connectionId, tagName) {
+    const normalizedConnectionId = this.assertRecentConnectionExists(connectionId);
+    const tag = this.getOrCreateConnectionTag(tagName);
+
+    this.db
+      .prepare(
+        `
+          INSERT OR IGNORE INTO connection_tags (connectionId, tagId)
+          VALUES (?, ?)
+        `
+      )
+      .run(normalizedConnectionId, tag.id);
+
+    return this.getConnectionTags(normalizedConnectionId);
+  }
+
+  removeConnectionTag(connectionId, tagId) {
+    const normalizedConnectionId = this.assertRecentConnectionExists(connectionId);
+
+    this.db
+      .prepare(
+        `
+          DELETE FROM connection_tags
+          WHERE connectionId = ? AND tagId = ?
+        `
+      )
+      .run(normalizedConnectionId, Number(tagId));
+
+    return this.getConnectionTags(normalizedConnectionId);
+  }
+
+  deleteConnectionTag(tagId) {
+    const result = this.db
+      .prepare("DELETE FROM tags WHERE id = ?")
+      .run(Number(tagId));
+
+    return result.changes > 0;
   }
 
   upsertRecentConnection(connection, options = {}) {
@@ -3121,7 +3417,7 @@ class AppStateStore {
     );
   }
 
-  decorateConnection(connection = {}) {
+  decorateConnection(connection = {}, tags = []) {
     const logoPath = this.normalizeLogoPath(connection.logoPath);
 
     return {
@@ -3129,6 +3425,7 @@ class AppStateStore {
       readOnly: Boolean(connection.readOnly),
       logoPath,
       logoUrl: this.getConnectionLogoUrl(logoPath),
+      tags: Array.isArray(tags) ? tags : [],
     };
   }
 
@@ -3696,4 +3993,6 @@ class AppStateStore {
 module.exports = {
   AppStateStore,
   DEFAULT_STATE,
+  MAX_CONNECTION_TAG_NAME_LENGTH,
+  normalizeConnectionTagName,
 };