sqlite-hub 0.11.1 → 0.12.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,9 +332,15 @@ 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()

package/server/services/sqlite/sqlExecutor.js

@@ -223,6 +223,8 @@ function mapEditableColumns(tableDetail, columnDefinitions) {
       visible: isRowId ? true : Boolean(columnMeta?.visible),
       generated: Boolean(columnMeta?.generated),
       identity: identityColumns.has(definition.column),
+      notNull: Boolean(columnMeta?.notNull),
+      allowedValues: columnMeta?.allowedValues ?? [],
     };
   });
 }

package/server/services/sqlite/tableFilter.js

@@ -0,0 +1,75 @@
+const { ValidationError } = require("../../utils/errors");
+const { quoteIdentifier } = require("../../utils/identifier");
+
+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 normalizeTableFilter(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],
+  };
+}
+
+module.exports = {
+  FILTER_OPERATORS,
+  normalizeTableFilter,
+};

package/server/utils/csv.js

@@ -1,10 +1,13 @@
-function escapeCsvCell(value, delimiter) {
+function stringifyDelimitedCell(value) {
   if (value === null || value === undefined) {
     return "";
   }
 
-  const stringValue =
-    typeof value === "object" ? JSON.stringify(value) : String(value);
+  return typeof value === "object" ? JSON.stringify(value) : String(value);
+}
+
+function escapeCsvCell(value, delimiter) {
+  const stringValue = stringifyDelimitedCell(value);
 
   if (
     stringValue.includes('"') ||
@@ -18,7 +21,7 @@ function escapeCsvCell(value, delimiter) {
   return stringValue;
 }
 
-function rowsToCsv({ columns, rows, delimiter = "," }) {
+function rowsToDelimitedText({ columns, rows, delimiter = "," }) {
   const header = columns.map((column) => escapeCsvCell(column, delimiter)).join(delimiter);
   const body = rows.map((row) =>
     columns
@@ -29,6 +32,29 @@ function rowsToCsv({ columns, rows, delimiter = "," }) {
   return [header, ...body].join("\n");
 }
 
+function rowsToCsv({ columns, rows, delimiter = "," }) {
+  return rowsToDelimitedText({ columns, rows, delimiter });
+}
+
+function escapeMarkdownCell(value) {
+  return stringifyDelimitedCell(value)
+    .replaceAll("\\", "\\\\")
+    .replaceAll("|", "\\|")
+    .replace(/\r\n|\r|\n/g, "<br>");
+}
+
+function rowsToMarkdownTable({ columns, rows }) {
+  const header = `| ${columns.map(escapeMarkdownCell).join(" | ")} |`;
+  const separator = `| ${columns.map(() => "---").join(" | ")} |`;
+  const body = rows.map(
+    (row) => `| ${columns.map((column) => escapeMarkdownCell(row[column])).join(" | ")} |`
+  );
+
+  return [header, separator, ...body].join("\n");
+}
+
 module.exports = {
   rowsToCsv,
+  rowsToDelimitedText,
+  rowsToMarkdownTable,
 };

package/tests/check-constraint-options.test.js

@@ -0,0 +1,76 @@
+const Database = require("better-sqlite3");
+const assert = require("node:assert/strict");
+const test = require("node:test");
+const { getTableDetail } = require("../server/services/sqlite/introspection");
+const { SqlExecutor } = require("../server/services/sqlite/sqlExecutor");
+
+test("table detail exposes string options from simple CHECK IN constraints", () => {
+  const db = new Database(":memory:");
+
+  try {
+    db.exec(`
+      CREATE TABLE stream_company_mentions (
+        id INTEGER PRIMARY KEY,
+        mention_type TEXT,
+        CHECK (
+          mention_type IS NULL
+          OR mention_type IN (
+            'company',
+            'stock_company',
+            'brand',
+            'product',
+            'person',
+            'organization',
+            'terrorists',
+            'events',
+            'collective_terms',
+            'countries',
+            'none',
+            'unknown'
+          )
+        )
+      );
+      INSERT INTO stream_company_mentions (mention_type) VALUES ('company');
+    `);
+
+    const tableDetail = getTableDetail(db, "stream_company_mentions");
+    const mentionTypeColumn = tableDetail.columns.find(
+      (column) => column.name === "mention_type"
+    );
+
+    assert.deepEqual(mentionTypeColumn.allowedValues, [
+      "company",
+      "stock_company",
+      "brand",
+      "product",
+      "person",
+      "organization",
+      "terrorists",
+      "events",
+      "collective_terms",
+      "countries",
+      "none",
+      "unknown",
+    ]);
+
+    const executor = new SqlExecutor({
+      connectionManager: {
+        getActiveDatabase: () => db,
+        getActiveConnection: () => ({ id: "test" }),
+      },
+      appStateStore: {
+        recordQueryExecution: () => 1,
+      },
+    });
+    const result = executor.execute(
+      "SELECT id, mention_type FROM stream_company_mentions"
+    );
+    const editableColumn = result.editing.columns.find(
+      (column) => column.sourceColumn === "mention_type"
+    );
+
+    assert.deepEqual(editableColumn.allowedValues, mentionTypeColumn.allowedValues);
+  } finally {
+    db.close();
+  }
+});