sqlite-hub 0.11.1 → 0.16.0

package/server/services/sqlite/dataBrowserService.js

@@ -6,19 +6,11 @@ const {
   serializeRows,
 } = require("../../utils/sqliteTypes");
 const { getRawStructureEntries, getTableDetail } = require("./introspection");
+const { normalizeTableFilter } = require("./tableFilter");
 const { buildTableOrderClause, normalizeTableSort } = require("./tableSort");
 
 const DEFAULT_LIMIT = 50;
 const MAX_LIMIT = 250;
-const FILTER_OPERATORS = new Set(["=", "!=", "<", ">", "<=", ">=", "equals"]);
-
-function escapeLikePattern(value) {
-  return String(value).replace(/[\\%_]/g, (character) => `\\${character}`);
-}
-
-function isTextColumn(column) {
-  return String(column?.affinity ?? "").toUpperCase() === "TEXT";
-}
 
 function buildRowIdentity(tableDetail, row) {
   if (tableDetail.identityStrategy?.type === "rowid") {
@@ -61,64 +53,6 @@ function normalizePaginationOptions(options = {}) {
   };
 }
 
-function normalizeFilterOptions(tableDetail, options = {}) {
-  const columnName = String(options.filterColumn ?? "").trim();
-  const operator = String(options.filterOperator ?? "=").trim();
-  const value = options.filterValue;
-
-  if (!columnName || value === undefined || value === null || String(value).trim() === "") {
-    return null;
-  }
-
-  if (!FILTER_OPERATORS.has(operator)) {
-    throw new ValidationError(
-      `filterOperator must be one of: ${Array.from(FILTER_OPERATORS).join(", ")}.`
-    );
-  }
-
-  const filterColumn = tableDetail.columns.find(
-    (column) => column.visible && column.name === columnName
-  );
-
-  if (!filterColumn) {
-    throw new ValidationError(`Unknown filter column: ${columnName}.`);
-  }
-
-  const normalizedValue = String(value);
-  const quotedColumn = quoteIdentifier(filterColumn.name);
-
-  if (operator === "equals") {
-    return {
-      column: filterColumn.name,
-      operator,
-      value: normalizedValue,
-      matchMode: "equals",
-      clause: `${quotedColumn}${isTextColumn(filterColumn) ? " COLLATE NOCASE" : ""} = ?`,
-      params: [normalizedValue],
-    };
-  }
-
-  if (isTextColumn(filterColumn) && (operator === "=" || operator === "!=")) {
-    return {
-      column: filterColumn.name,
-      operator,
-      value: normalizedValue,
-      matchMode: operator === "=" ? "contains" : "notContains",
-      clause: `${quotedColumn} COLLATE NOCASE ${operator === "=" ? "LIKE" : "NOT LIKE"} ? ESCAPE '\\'`,
-      params: [`%${escapeLikePattern(normalizedValue)}%`],
-    };
-  }
-
-  return {
-    column: filterColumn.name,
-    operator,
-    value: normalizedValue,
-    matchMode: "comparison",
-    clause: `${quotedColumn} ${operator} ?`,
-    params: [normalizedValue],
-  };
-}
-
 function formatPreviewValue(value) {
   if (value && typeof value === "object" && value.__type === "blob") {
     return `BLOB ${value.sizeBytes ?? 0} bytes`;
@@ -167,7 +101,7 @@ class DataBrowserService {
     const tableDetail = getTableDetail(db, tableName);
     const { limit, offset } = normalizePaginationOptions(options);
     const sort = normalizeTableSort(tableDetail, options);
-    const filter = normalizeFilterOptions(tableDetail, options);
+    const filter = normalizeTableFilter(tableDetail, options);
     const selectExpression =
       tableDetail.identityStrategy?.type === "rowid" ? "rowid AS __rowid__, *" : "*";
     const orderClause = buildTableOrderClause(tableDetail, sort);

package/server/services/sqlite/exportService.js

@@ -1,7 +1,12 @@
 const { quoteIdentifier } = require("../../utils/identifier");
 const { serializeRows } = require("../../utils/sqliteTypes");
-const { rowsToCsv } = require("../../utils/csv");
+const {
+  rowsToCsv,
+  rowsToDelimitedText,
+  rowsToMarkdownTable,
+} = require("../../utils/csv");
 const { getTableDetail } = require("./introspection");
+const { normalizeTableFilter } = require("./tableFilter");
 const { buildTableOrderClause, normalizeTableSort } = require("./tableSort");
 const {
   buildAutoTitle,
@@ -23,6 +28,43 @@ function sanitizeFilenameBase(value, fallback = "query-results") {
   return sanitized.slice(0, 120);
 }
 
+const EXPORT_FORMATS = {
+  csv: {
+    extension: "csv",
+    mimeType: "text/csv; charset=utf-8",
+  },
+  tsv: {
+    extension: "tsv",
+    mimeType: "text/tab-separated-values; charset=utf-8",
+  },
+  md: {
+    extension: "md",
+    mimeType: "text/markdown; charset=utf-8",
+  },
+};
+
+function normalizeExportFormat(format) {
+  const normalized = String(format ?? "csv").toLowerCase();
+
+  if (!EXPORT_FORMATS[normalized]) {
+    throw new Error(`Unsupported export format: ${format}`);
+  }
+
+  return normalized;
+}
+
+function renderExportContent({ columns, rows, format, csvDelimiter }) {
+  if (format === "tsv") {
+    return rowsToDelimitedText({ columns, rows, delimiter: "\t" });
+  }
+
+  if (format === "md") {
+    return rowsToMarkdownTable({ columns, rows });
+  }
+
+  return rowsToCsv({ columns, rows, delimiter: csvDelimiter });
+}
+
 class ExportService {
   constructor({ appStateStore, connectionManager, sqlExecutor }) {
     this.appStateStore = appStateStore;
@@ -34,7 +76,9 @@ class ExportService {
     return this.appStateStore.getSettings().csvDelimiter || ",";
   }
 
-  exportQuery(sql) {
+  exportQuery(sql, options = {}) {
+    const format = normalizeExportFormat(options.format);
+    const formatConfig = EXPORT_FORMATS[format];
     const activeConnection = this.connectionManager.getActiveConnection();
     const historyItem = activeConnection
       ? this.appStateStore.findQueryHistoryItemBySql(activeConnection.id, sql)
@@ -50,44 +94,59 @@ class ExportService {
       persistHistory: false,
       requireReader: true,
     });
+    const content = renderExportContent({
+      columns: result.columns,
+      rows: result.rows,
+      format,
+      csvDelimiter: this.getDelimiter(),
+    });
 
     return {
-      filename: `${filenameBase}.csv`,
-      csv: rowsToCsv({
-        columns: result.columns,
-        rows: result.rows,
-        delimiter: this.getDelimiter(),
-      }),
+      filename: `${filenameBase}.${formatConfig.extension}`,
+      content,
+      csv: format === "csv" ? content : undefined,
+      format,
+      mimeType: formatConfig.mimeType,
       columns: result.columns,
       rowCount: result.rows.length,
     };
   }
 
   exportTable(tableName, options = {}) {
+    const format = normalizeExportFormat(options.format);
+    const formatConfig = EXPORT_FORMATS[format];
     const db = this.connectionManager.getActiveDatabase();
     const tableDetail = getTableDetail(db, tableName, { includeRowCount: false });
     const sort = normalizeTableSort(tableDetail, options);
+    const filter = normalizeTableFilter(tableDetail, options);
     const orderClause = buildTableOrderClause(tableDetail, sort);
+    const whereClause = filter ? `WHERE ${filter.clause}` : "";
     const statement = db.prepare(
       [
         "SELECT * FROM",
         quoteIdentifier(tableName),
+        whereClause,
         orderClause ? "ORDER BY" : "",
         orderClause,
       ]
         .filter(Boolean)
         .join(" ")
     );
-    const rows = serializeRows(statement.all());
+    const rows = serializeRows(statement.all(...(filter?.params ?? [])));
     const columns = statement.columns().map((column) => column.name);
+    const content = renderExportContent({
+      columns,
+      rows,
+      format,
+      csvDelimiter: this.getDelimiter(),
+    });
 
     return {
-      filename: `${tableName}.csv`,
-      csv: rowsToCsv({
-        columns,
-        rows,
-        delimiter: this.getDelimiter(),
-      }),
+      filename: `${tableName}.${formatConfig.extension}`,
+      content,
+      csv: format === "csv" ? content : undefined,
+      format,
+      mimeType: formatConfig.mimeType,
       columns,
       rowCount: rows.length,
     };

package/server/services/sqlite/introspection.js

@@ -64,6 +64,198 @@ function normalizeColumn(column, visibleSet) {
   };
 }
 
+function isIdentifierCharacter(character) {
+  return /[A-Za-z0-9_$]/.test(character);
+}
+
+function skipQuotedSql(text, index) {
+  const quote = text[index];
+  let cursor = index + 1;
+
+  while (cursor < text.length) {
+    if (text[cursor] === quote) {
+      if (text[cursor + 1] === quote) {
+        cursor += 2;
+        continue;
+      }
+
+      return cursor + 1;
+    }
+
+    cursor += 1;
+  }
+
+  return text.length;
+}
+
+function findMatchingParenthesis(text, openIndex) {
+  let depth = 0;
+
+  for (let index = openIndex; index < text.length; index += 1) {
+    const character = text[index];
+
+    if (character === "'" || character === '"' || character === "`") {
+      index = skipQuotedSql(text, index) - 1;
+      continue;
+    }
+
+    if (character === "[") {
+      const closeIndex = text.indexOf("]", index + 1);
+      index = closeIndex === -1 ? text.length : closeIndex;
+      continue;
+    }
+
+    if (character === "(") {
+      depth += 1;
+      continue;
+    }
+
+    if (character === ")") {
+      depth -= 1;
+
+      if (depth === 0) {
+        return index;
+      }
+    }
+  }
+
+  return -1;
+}
+
+function extractCheckExpressions(ddl = "") {
+  const expressions = [];
+  const checkPattern = /\bCHECK\s*\(/gi;
+  let match;
+
+  while ((match = checkPattern.exec(ddl))) {
+    const openIndex = ddl.indexOf("(", match.index);
+    const closeIndex = findMatchingParenthesis(ddl, openIndex);
+
+    if (closeIndex === -1) {
+      continue;
+    }
+
+    expressions.push(ddl.slice(openIndex + 1, closeIndex));
+    checkPattern.lastIndex = closeIndex + 1;
+  }
+
+  return expressions;
+}
+
+function normalizeIdentifier(value) {
+  const text = String(value ?? "").trim();
+
+  if (text.startsWith('"') && text.endsWith('"')) {
+    return text.slice(1, -1).replace(/""/g, '"').toLowerCase();
+  }
+
+  if (text.startsWith("`") && text.endsWith("`")) {
+    return text.slice(1, -1).replace(/``/g, "`").toLowerCase();
+  }
+
+  if (text.startsWith("[") && text.endsWith("]")) {
+    return text.slice(1, -1).replace(/\]\]/g, "]").toLowerCase();
+  }
+
+  return text.toLowerCase();
+}
+
+function parseSqlStringList(text = "") {
+  const values = [];
+  let index = 0;
+
+  while (index < text.length) {
+    if (text[index] !== "'") {
+      index += 1;
+      continue;
+    }
+
+    let value = "";
+    index += 1;
+
+    while (index < text.length) {
+      if (text[index] === "'") {
+        if (text[index + 1] === "'") {
+          value += "'";
+          index += 2;
+          continue;
+        }
+
+        index += 1;
+        values.push(value);
+        break;
+      }
+
+      value += text[index];
+      index += 1;
+    }
+  }
+
+  return values;
+}
+
+function findColumnInListExpression(expression, columnName) {
+  const normalizedColumnName = normalizeIdentifier(columnName);
+  const identifierPattern = /(?:"(?:[^"]|"")+"|`(?:[^`]|``)+`|\[[^\]]+\]|[A-Za-z_][A-Za-z0-9_$]*)\s+IN\s*\(/gi;
+  let match;
+
+  while ((match = identifierPattern.exec(expression))) {
+    const matchedIdentifier = match[0].replace(/\s+IN\s*\($/i, "").trim();
+
+    if (normalizeIdentifier(matchedIdentifier) !== normalizedColumnName) {
+      continue;
+    }
+
+    const before = expression[match.index - 1] ?? "";
+
+    if (before && isIdentifierCharacter(before)) {
+      continue;
+    }
+
+    const openIndex = expression.indexOf("(", match.index + matchedIdentifier.length);
+    const closeIndex = findMatchingParenthesis(expression, openIndex);
+
+    if (closeIndex === -1) {
+      continue;
+    }
+
+    const values = parseSqlStringList(expression.slice(openIndex + 1, closeIndex));
+
+    if (values.length) {
+      return values;
+    }
+  }
+
+  return [];
+}
+
+function parseCheckAllowedValues(ddl = "", columns = []) {
+  const allowedValuesByColumn = new Map();
+  const expressions = extractCheckExpressions(ddl);
+
+  columns.forEach((column) => {
+    const values = [];
+    const seen = new Set();
+
+    expressions.forEach((expression) => {
+      findColumnInListExpression(expression, column.name).forEach((value) => {
+        if (seen.has(value)) {
+          return;
+        }
+
+        seen.add(value);
+        values.push(value);
+      });
+    });
+
+    if (values.length) {
+      allowedValuesByColumn.set(column.name, values);
+    }
+  });
+
+  return allowedValuesByColumn;
+}
+
 function groupForeignKeys(rows) {
   const grouped = new Map();
 
@@ -140,19 +332,33 @@ function getTableDetail(db, tableName, options = {}) {
     .all();
   const visibleSet = new Set(tableInfo.map((column) => column.name));
 
-  const columns = extendedInfo
+  let columns = extendedInfo
     .map((column) => normalizeColumn(column, visibleSet))
     .sort((left, right) => left.cid - right.cid);
+  const allowedValuesByColumn = parseCheckAllowedValues(entry.sql, columns);
+
+  columns = columns.map((column) => ({
+    ...column,
+    allowedValues: allowedValuesByColumn.get(column.name) ?? [],
+  }));
 
   const foreignKeys = groupForeignKeys(
     db.prepare(`PRAGMA foreign_key_list(${quoteIdentifier(tableName)})`).all()
   );
+  const checkConstraints = extractCheckExpressions(entry.sql).map((expression, index) => ({
+    id: index,
+    expression: expression.trim(),
+  }));
 
   const indexList = db
     .prepare(`PRAGMA index_list(${quoteIdentifier(tableName)})`)
     .all()
     .map((indexEntry) => {
       let indexColumns = [];
+      const indexSql =
+        db
+          .prepare("SELECT sql FROM sqlite_master WHERE type = 'index' AND name = ?")
+          .get(indexEntry.name)?.sql ?? null;
 
       try {
         indexColumns = db
@@ -182,6 +388,7 @@ function getTableDetail(db, tableName, options = {}) {
         unique: Boolean(indexEntry.unique),
         origin: indexEntry.origin,
         partial: Boolean(indexEntry.partial),
+        sql: indexSql,
         columns: indexColumns,
       };
     });
@@ -204,6 +411,7 @@ function getTableDetail(db, tableName, options = {}) {
     withoutRowId,
     strict: Boolean(tableListEntry?.strict),
     columns,
+    checkConstraints,
     foreignKeys,
     indexes: indexList,
     indexCount: indexList.length,

package/server/services/sqlite/sqlExecutor.js

@@ -204,6 +204,13 @@ function mapEditableColumns(tableDetail, columnDefinitions) {
   const tableColumnsByName = new Map(
     tableDetail.columns.map((column) => [column.name, column])
   );
+  const foreignKeyColumnNames = new Set(
+    (tableDetail.foreignKeys ?? []).flatMap((foreignKey) =>
+      (foreignKey.mappings ?? [])
+        .map((mapping) => String(mapping.from ?? "").trim())
+        .filter(Boolean)
+    )
+  );
   const identityColumns = new Set(
     tableDetail.identityStrategy?.type === "primaryKey"
       ? tableDetail.identityStrategy.columns ?? []
@@ -223,10 +230,31 @@ function mapEditableColumns(tableDetail, columnDefinitions) {
       visible: isRowId ? true : Boolean(columnMeta?.visible),
       generated: Boolean(columnMeta?.generated),
       identity: identityColumns.has(definition.column),
+      declaredType: columnMeta?.declaredType ?? "",
+      affinity: columnMeta?.affinity ?? "",
+      primaryKeyPosition: Number(columnMeta?.primaryKeyPosition ?? 0),
+      foreignKey: foreignKeyColumnNames.has(definition.column),
+      notNull: Boolean(columnMeta?.notNull),
+      allowedValues: columnMeta?.allowedValues ?? [],
     };
   });
 }
 
+function buildTableMeta(tableDetail) {
+  return {
+    columns: (tableDetail.columns ?? []).map((column) => ({
+      name: column.name,
+      declaredType: column.declaredType,
+      affinity: column.affinity,
+      primaryKeyPosition: Number(column.primaryKeyPosition ?? 0),
+      foreignKey: (tableDetail.foreignKeys ?? []).some((foreignKey) =>
+        (foreignKey.mappings ?? []).some((mapping) => mapping.from === column.name)
+      ),
+    })),
+    foreignKeys: tableDetail.foreignKeys ?? [],
+  };
+}
+
 function hasRequiredIdentityColumns(tableDetail, editableColumns) {
   const availableSourceColumns = new Set(editableColumns.map((column) => column.sourceColumn));
 
@@ -299,6 +327,7 @@ function resolveEditableResult(db, columnDefinitions, serializedRows) {
       reason: getEditableResultReason(tableDetail),
       columns: editableColumns,
       identityStrategy: tableDetail.identityStrategy,
+      tableMeta: buildTableMeta(tableDetail),
     };
   }
 
@@ -317,6 +346,7 @@ function resolveEditableResult(db, columnDefinitions, serializedRows) {
     reason: "",
     columns: editableColumns,
     identityStrategy: tableDetail.identityStrategy,
+    tableMeta: buildTableMeta(tableDetail),
     rows,
   };
 }
@@ -376,6 +406,7 @@ class SqlExecutor {
                   reason: editableResult.reason ?? "",
                   columns: editableResult.columns ?? [],
                   identityStrategy: editableResult.identityStrategy ?? null,
+                  tableMeta: editableResult.tableMeta ?? null,
                 }
               : null,
           };

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

@@ -26,6 +26,17 @@ function hasColumnChanged(originalColumn, draftColumn) {
   );
 }
 
+function hasConstraintChanged(constraint) {
+  return (
+    normalizeComparableValue(constraint.name) !==
+      normalizeComparableValue(constraint.originalName ?? constraint.name) ||
+    normalizeComparableValue(constraint.expression || constraint.sql) !==
+      normalizeComparableValue(
+        constraint.originalExpression ?? constraint.originalSql ?? constraint.expression ?? constraint.sql
+      )
+  );
+}
+
 function hasMeaningfulNewDraftContent(draft) {
   return (
     Boolean(String(draft.tableName ?? "").trim()) ||
@@ -149,7 +160,7 @@ function analyzeEditDraft(draft, originalDraft) {
           warnings.push(
             buildRiskyChangeWarning(
               "Column Rename Requires Rebuild",
-              `Renaming column ${originalColumn.name} to ${column.name} is intentionally blocked in Table Designer v1.`
+              `Renaming column ${originalColumn.name} to ${column.name} is intentionally blocked in Table Designer v2.`
             )
           );
         }
@@ -265,6 +276,19 @@ function analyzeEditDraft(draft, originalDraft) {
     );
   });
 
+  [...(draft.uniqueConstraints ?? []), ...(draft.checkConstraints ?? [])].forEach((constraint) => {
+    if (!hasConstraintChanged(constraint)) {
+      return;
+    }
+
+    warnings.push(
+      buildRiskyChangeWarning(
+        "Constraint Change Requires Rebuild",
+        `Changing ${constraint.originalName || constraint.name || "a table constraint"} requires a SQLite table rebuild.`
+      )
+    );
+  });
+
   const dirty = Boolean(executableStatements.length || warnings.length);
 
   return {