sqlite-hub 0.11.1 → 0.16.0

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

@@ -74,6 +74,95 @@ function buildSimpleForeignKeyMap(foreignKeys = []) {
   return map;
 }
 
+function buildUniqueConstraintExpression(index = {}) {
+  const columns = (index.columns ?? [])
+    .map((column) => column?.name)
+    .filter(Boolean);
+
+  if (!columns.length) {
+    return "UNIQUE constraint";
+  }
+
+  return `UNIQUE (${columns.map((columnName) => quoteIdentifier(columnName)).join(", ")})`;
+}
+
+function mapComplexUniqueConstraint(index = {}) {
+  const sql = String(index.sql ?? "").trim();
+  const columns = (index.columns ?? [])
+    .map((column) => ({
+      name: column.name ?? "",
+      descending: Boolean(column.descending),
+      collation: column.collation ?? "",
+    }))
+    .filter((column) => column.name);
+
+  return {
+    id: `unique:${index.name}`,
+    name: index.name ?? "",
+    originalName: index.name ?? "",
+    columns,
+    partial: Boolean(index.partial),
+    origin: index.origin ?? "",
+    sql,
+    originalSql: sql,
+    expression: sql || buildUniqueConstraintExpression(index),
+    originalExpression: sql || buildUniqueConstraintExpression(index),
+    editable: true,
+    preserved: true,
+  };
+}
+
+function buildComplexUniqueConstraints(indexes = []) {
+  return indexes
+    .filter((index) => index?.unique && (index.partial || (index.columns?.length ?? 0) !== 1))
+    .map(mapComplexUniqueConstraint);
+}
+
+function expressionMentionsColumn(expression = "", columnName = "") {
+  const normalizedExpression = String(expression ?? "").toLowerCase();
+  const normalizedColumn = String(columnName ?? "").toLowerCase();
+
+  if (!normalizedColumn) {
+    return false;
+  }
+
+  return (
+    new RegExp(`(^|[^a-z0-9_$])${normalizedColumn.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}([^a-z0-9_$]|$)`).test(
+      normalizedExpression
+    ) ||
+    normalizedExpression.includes(`"${normalizedColumn.replaceAll('"', '""')}"`) ||
+    normalizedExpression.includes(`\`${normalizedColumn.replaceAll("`", "``")}\``) ||
+    normalizedExpression.includes(`[${normalizedColumn}]`)
+  );
+}
+
+function buildCheckConstraints(tableDetail) {
+  const visibleColumns = (tableDetail.columns ?? []).filter(
+    (column) => column.visible !== false && !column.generated
+  );
+
+  return (tableDetail.checkConstraints ?? []).map((constraint, index) => {
+    const expression = String(constraint.expression ?? "").trim();
+    const columns = visibleColumns
+      .filter((column) => expressionMentionsColumn(expression, column.name))
+      .map((column) => ({
+        name: column.name,
+        allowedValues: Array.isArray(column.allowedValues) ? column.allowedValues : [],
+      }));
+
+    return {
+      id: `check:${constraint.id ?? index}`,
+      name: `CHECK ${index + 1}`,
+      originalName: `CHECK ${index + 1}`,
+      columns,
+      expression: expression ? `CHECK (${expression})` : "CHECK constraint",
+      originalExpression: expression ? `CHECK (${expression})` : "CHECK constraint",
+      editable: true,
+      preserved: true,
+    };
+  });
+}
+
 function buildSchemaWarnings(tableDetail) {
   const warnings = [];
   const generatedColumns = (tableDetail.columns ?? []).filter((column) => column.generated);
@@ -83,9 +172,7 @@ function buildSchemaWarnings(tableDetail) {
   const complexForeignKeys = (tableDetail.foreignKeys ?? []).filter(
     (foreignKey) => (foreignKey.mappings?.length ?? 0) !== 1
   );
-  const complexUniqueIndexes = (tableDetail.indexes ?? []).filter(
-    (index) => index.unique && (index.partial || (index.columns?.length ?? 0) !== 1)
-  );
+  const complexUniqueConstraints = buildComplexUniqueConstraints(tableDetail.indexes);
 
   if (generatedColumns.length) {
     warnings.push(
@@ -93,7 +180,7 @@ function buildSchemaWarnings(tableDetail) {
         code: "GENERATED_COLUMNS_PRESENT",
         title: "Generated Columns Detected",
         message:
-          "Generated or hidden columns are not editable in Table Designer v1. Safe operations like table rename or adding simple columns still work.",
+          "Generated or hidden columns are inspectable but not editable in Table Designer v2. Safe operations like table rename or adding simple columns still work.",
       })
     );
   }
@@ -104,7 +191,7 @@ function buildSchemaWarnings(tableDetail) {
         code: "COMPOSITE_PRIMARY_KEY_PRESENT",
         title: "Composite Primary Key Detected",
         message:
-          "This table uses more than one primary key column. Table Designer v1 preserves it, but changing primary key structure requires a manual table rebuild.",
+          "This table uses more than one primary key column. Table Designer v2 preserves it, but changing primary key structure requires a manual table rebuild.",
       })
     );
   }
@@ -115,18 +202,19 @@ function buildSchemaWarnings(tableDetail) {
         code: "COMPLEX_FOREIGN_KEYS_PRESENT",
         title: "Complex Foreign Keys Detected",
         message:
-          "Composite or multi-mapping foreign keys cannot be edited directly in Table Designer v1. They are preserved until a rebuild is done manually.",
+          "Composite or multi-mapping foreign keys cannot be edited directly in Table Designer v2. They are preserved until a rebuild is done manually.",
       })
     );
   }
 
-  if (complexUniqueIndexes.length) {
+  if (complexUniqueConstraints.length) {
     warnings.push(
       createDesignerWarning({
         code: "COMPLEX_UNIQUE_CONSTRAINTS_PRESENT",
-        title: "Complex Unique Constraints Detected",
+        title: "Table Designer v2 Unique Constraints",
         message:
-          "Multi-column or partial UNIQUE constraints are outside Table Designer v1. They remain untouched unless you rebuild the table manually.",
+          "Multi-column and partial UNIQUE constraints are detected, shown in the v2 constraints panel, and preserved by SQLite-safe saves. Editing them still requires manual SQL review.",
+        tone: "muted",
       })
     );
   }
@@ -149,7 +237,7 @@ function buildSchemaWarnings(tableDetail) {
         code: "WITHOUT_ROWID_PRESENT",
         title: "WITHOUT ROWID Table",
         message:
-          "WITHOUT ROWID tables can be inspected here, but rebuild-style changes are intentionally blocked in v1.",
+          "WITHOUT ROWID tables can be inspected here, but rebuild-style changes are intentionally blocked in v2.",
         tone: "muted",
       })
     );
@@ -189,6 +277,8 @@ function mapTableColumnToDraft(column, { uniqueColumns, foreignKeyMap }) {
 function buildTableDesignerDraft(tableDetail) {
   const uniqueColumns = buildSingleColumnUniqueSet(tableDetail.indexes);
   const foreignKeyMap = buildSimpleForeignKeyMap(tableDetail.foreignKeys);
+  const uniqueConstraints = buildComplexUniqueConstraints(tableDetail.indexes);
+  const checkConstraints = buildCheckConstraints(tableDetail);
   const columns = (tableDetail.columns ?? [])
     .filter((column) => column.visible !== false && !column.generated)
     .map((column) => mapTableColumnToDraft(column, { uniqueColumns, foreignKeyMap }));
@@ -199,6 +289,9 @@ function buildTableDesignerDraft(tableDetail) {
     originalTableName: tableDetail.name,
     tableName: tableDetail.name,
     columns,
+    uniqueConstraints,
+    checkConstraints,
+    designerVersion: 2,
     dirty: false,
     schemaWarnings,
     warnings: [...schemaWarnings],
@@ -227,6 +320,8 @@ function listDesignerTables(db) {
 module.exports = {
   SUPPORTED_TABLE_DESIGNER_TYPES,
   buildTableDesignerDraft,
+  buildComplexUniqueConstraints,
+  buildCheckConstraints,
   createDesignerWarning,
   listDesignerTables,
   normalizeDesignerType,

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

@@ -66,6 +66,53 @@ function normalizeColumnPayload(column = {}, index = 0) {
   };
 }
 
+function normalizeUniqueConstraintPayload(constraint = {}, index = 0) {
+  return {
+    id: String(constraint.id ?? `unique:${index}`),
+    name: String(constraint.name ?? "").trim(),
+    originalName: String(constraint.originalName ?? constraint.name ?? "").trim(),
+    columns: Array.isArray(constraint.columns)
+      ? constraint.columns
+          .map((column) => ({
+            name: String(column?.name ?? "").trim(),
+            descending: normalizeBoolean(column?.descending),
+            collation: String(column?.collation ?? "").trim(),
+          }))
+          .filter((column) => column.name)
+      : [],
+    partial: normalizeBoolean(constraint.partial),
+    origin: String(constraint.origin ?? "").trim(),
+    sql: String(constraint.sql ?? "").trim(),
+    originalSql: String(constraint.originalSql ?? constraint.sql ?? "").trim(),
+    expression: String(constraint.expression ?? "").trim(),
+    originalExpression: String(constraint.originalExpression ?? constraint.expression ?? constraint.sql ?? "").trim(),
+    editable: normalizeBoolean(constraint.editable),
+    preserved: constraint.preserved === undefined ? true : normalizeBoolean(constraint.preserved),
+  };
+}
+
+function normalizeCheckConstraintPayload(constraint = {}, index = 0) {
+  return {
+    id: String(constraint.id ?? `check:${index}`),
+    name: String(constraint.name ?? `CHECK ${index + 1}`).trim(),
+    originalName: String(constraint.originalName ?? constraint.name ?? `CHECK ${index + 1}`).trim(),
+    columns: Array.isArray(constraint.columns)
+      ? constraint.columns
+          .map((column) => ({
+            name: String(column?.name ?? "").trim(),
+            allowedValues: Array.isArray(column?.allowedValues)
+              ? column.allowedValues.map((value) => String(value ?? ""))
+              : [],
+          }))
+          .filter((column) => column.name)
+      : [],
+    expression: String(constraint.expression ?? "").trim(),
+    originalExpression: String(constraint.originalExpression ?? constraint.expression ?? "").trim(),
+    editable: normalizeBoolean(constraint.editable),
+    preserved: constraint.preserved === undefined ? true : normalizeBoolean(constraint.preserved),
+  };
+}
+
 function normalizeDraftPayload(payload = {}) {
   const mode = String(payload.mode ?? "create").trim() === "edit" ? "edit" : "create";
 
@@ -76,6 +123,17 @@ function normalizeDraftPayload(payload = {}) {
     columns: Array.isArray(payload.columns)
       ? payload.columns.map((column, index) => normalizeColumnPayload(column, index))
       : [],
+    uniqueConstraints: Array.isArray(payload.uniqueConstraints)
+      ? payload.uniqueConstraints.map((constraint, index) =>
+          normalizeUniqueConstraintPayload(constraint, index)
+        )
+      : [],
+    checkConstraints: Array.isArray(payload.checkConstraints)
+      ? payload.checkConstraints.map((constraint, index) =>
+          normalizeCheckConstraintPayload(constraint, index)
+        )
+      : [],
+    designerVersion: Number(payload.designerVersion) || 1,
     schemaWarnings: Array.isArray(payload.schemaWarnings) ? payload.schemaWarnings : [],
     warnings: Array.isArray(payload.warnings) ? payload.warnings : [],
     fillImportedRows: normalizeBoolean(payload.fillImportedRows),
@@ -112,7 +170,7 @@ function validatePrimaryKeys(draft, originalDraft) {
 
   if (!originalDraft) {
     throw new ValidationError(
-      "Table Designer v1 supports a single primary key column when creating a table."
+      "Table Designer v2 supports a single primary key column when creating a table."
     );
   }
 
@@ -134,7 +192,7 @@ function validatePrimaryKeys(draft, originalDraft) {
 
   if (!isUnchangedCompositePrimaryKey) {
     throw new ValidationError(
-      "Table Designer v1 does not support editing composite primary keys."
+      "Table Designer v2 does not support editing composite primary keys."
     );
   }
 }

package/server/services/sqlite/tableDesignerService.js

@@ -109,7 +109,7 @@ class TableDesignerService {
 
     if (!analysis.executable) {
       throw new ValidationError(
-        "This schema change set would require a SQLite table rebuild. Table Designer v1 keeps the SQL preview available but will not execute those changes automatically.",
+        "This schema change set would require a SQLite table rebuild. Table Designer v2 keeps the SQL preview available but will not execute those changes automatically.",
         {
           code: "TABLE_DESIGNER_REBUILD_REQUIRED",
           warnings: analysis.warnings,

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,90 @@
+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");
+const { buildTableDesignerDraft } = require("../server/services/sqlite/tableDesigner/schemaMapping");
+
+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 designerDraft = buildTableDesignerDraft(tableDetail);
+    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);
+
+    assert.equal(designerDraft.designerVersion, 2);
+    assert.equal(designerDraft.checkConstraints.length, 1);
+    assert.match(designerDraft.checkConstraints[0].expression, /CHECK/i);
+    assert.equal(designerDraft.checkConstraints[0].originalExpression, designerDraft.checkConstraints[0].expression);
+    assert.equal(designerDraft.checkConstraints[0].editable, true);
+    assert.deepEqual(designerDraft.checkConstraints[0].columns, [
+      {
+        name: "mention_type",
+        allowedValues: mentionTypeColumn.allowedValues,
+      },
+    ]);
+  } finally {
+    db.close();
+  }
+});

package/tests/export-filenames.test.js

@@ -0,0 +1,34 @@
+const assert = require("node:assert/strict");
+const { readFileSync } = require("node:fs");
+const path = require("node:path");
+const test = require("node:test");
+
+let exportFilenamesModulePromise = null;
+
+function loadExportFilenamesModule() {
+  if (!exportFilenamesModulePromise) {
+    const source = readFileSync(
+      path.resolve(__dirname, "../frontend/js/utils/exportFilenames.js"),
+      "utf8"
+    );
+    const url = `data:text/javascript;base64,${Buffer.from(source).toString("base64")}`;
+
+    exportFilenamesModulePromise = import(url);
+  }
+
+  return exportFilenamesModulePromise;
+}
+
+test("text export filenames use the selected format extension", async () => {
+  const { buildTextExportFilename } = await loadExportFilenamesModule();
+
+  assert.equal(buildTextExportFilename("query-results.csv", { format: "tsv" }), "query-results.tsv");
+  assert.equal(buildTextExportFilename("white_house_live_streams", { format: "md" }), "white_house_live_streams.md");
+});
+
+test("text export filenames sanitize unsafe names and fallback when empty", async () => {
+  const { buildTextExportFilename } = await loadExportFilenamesModule();
+
+  assert.equal(buildTextExportFilename("", { format: "csv", fallback: "table" }), "table.csv");
+  assert.equal(buildTextExportFilename("../bad:name?.csv", { format: "csv", fallback: "table" }), "bad name.csv");
+});