sqlite-hub 2.0.1 → 2.2.0

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 = {

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 = {