sqlite-hub 2.0.1 → 2.1.0

package/server/services/sqlite/introspection.js

@@ -19,6 +19,37 @@ function getTableListMap(db) {
   }
 }
 
+function normalizeTableKind(entry = {}, tableListEntry = null) {
+  const pragmaType = String(tableListEntry?.type ?? "")
+    .trim()
+    .toLowerCase();
+
+  if (pragmaType) {
+    return pragmaType;
+  }
+
+  if (entry.type === "table" && /^\s*CREATE\s+VIRTUAL\s+TABLE\b/i.test(entry.sql || "")) {
+    return "virtual";
+  }
+
+  return entry.type;
+}
+
+function decorateStructureEntry(entry, tableListMap = null) {
+  if (entry.type !== "table") {
+    return entry;
+  }
+
+  const tableKind = normalizeTableKind(entry, tableListMap?.get(entry.name));
+
+  return {
+    ...entry,
+    tableKind,
+    isVirtual: tableKind === "virtual",
+    isShadow: tableKind === "shadow",
+  };
+}
+
 function getMasterEntry(db, type, name) {
   const entry = db
     .prepare(
@@ -34,6 +65,8 @@ function getMasterEntry(db, type, name) {
 }
 
 function getRawStructureEntries(db) {
+  const tableListMap = getTableListMap(db);
+
   return db
     .prepare(
       [
@@ -43,7 +76,8 @@ function getRawStructureEntries(db) {
         "ORDER BY type ASC, name ASC",
       ].join(" ")
     )
-    .all();
+    .all()
+    .map((entry) => decorateStructureEntry(entry, tableListMap));
 }
 
 function normalizeColumn(column, visibleSet) {
@@ -607,11 +641,15 @@ function getTableDetail(db, tableName, options = {}) {
     typeof tableListEntry?.wr === "number"
       ? Boolean(tableListEntry.wr)
       : /WITHOUT\s+ROWID/i.test(entry.sql || "");
+  const tableKind = normalizeTableKind(entry, tableListEntry);
 
   const tableDetail = {
     type: entry.type,
     name: entry.name,
     ddl: entry.sql,
+    tableKind,
+    isVirtual: tableKind === "virtual",
+    isShadow: tableKind === "shadow",
     withoutRowId,
     strict: Boolean(tableListEntry?.strict),
     columns,

package/server/services/sqlite/structureService.js

@@ -3,6 +3,65 @@ const { quoteIdentifier } = require("../../utils/identifier");
 const { serializeRows } = require("../../utils/sqliteTypes");
 const { TypeGenerationService } = require("../typeGenerationService");
 
+function resolveShadowOwnerTableName(shadowTable, tables) {
+  if (!shadowTable?.isShadow) {
+    return null;
+  }
+
+  return (
+    tables
+      .filter((table) => table.isVirtual && shadowTable.name.startsWith(`${table.name}_`))
+      .sort((left, right) => right.name.length - left.name.length)[0]?.name ?? null
+  );
+}
+
+function unquoteSqlIdentifier(identifier) {
+  const value = String(identifier ?? "").trim();
+
+  if (value.length >= 2 && value[0] === '"' && value.at(-1) === '"') {
+    return value.slice(1, -1).replace(/""/g, '"');
+  }
+
+  if (value.length >= 2 && value[0] === "`" && value.at(-1) === "`") {
+    return value.slice(1, -1).replace(/``/g, "`");
+  }
+
+  if (value.length >= 2 && value[0] === "[" && value.at(-1) === "]") {
+    return value.slice(1, -1);
+  }
+
+  return value;
+}
+
+function extractVirtualTableModule(ddl = "") {
+  const match = String(ddl ?? "").match(
+    /\bUSING\s+("[^"]+(?:""[^"]*)*"|`[^`]+(?:``[^`]*)*`|\[[^\]]+\]|[A-Za-z_][A-Za-z0-9_]*)/i
+  );
+
+  return match ? unquoteSqlIdentifier(match[1]) : null;
+}
+
+function serializeGraphTable(table, shadowOwnerTableName = null) {
+  const isVirtual = Boolean(table.isVirtual);
+
+  return {
+    type: table.type,
+    name: table.name,
+    ddl: table.ddl,
+    tableKind: table.tableKind,
+    isVirtual,
+    isShadow: Boolean(table.isShadow),
+    virtualModule: isVirtual ? extractVirtualTableModule(table.ddl) : null,
+    shadowOwnerTable: shadowOwnerTableName,
+    withoutRowId: table.withoutRowId,
+    strict: table.strict,
+    columns: table.columns,
+    foreignKeys: table.foreignKeys,
+    identityStrategy: table.identityStrategy,
+    notSafelyUpdatable: table.notSafelyUpdatable,
+  };
+}
+
 class StructureService {
   constructor({ connectionManager, appStateStore }) {
     this.connectionManager = connectionManager;
@@ -35,17 +94,9 @@ class StructureService {
         triggers: entries.filter((entry) => entry.type === "trigger"),
       },
       graph: {
-        tables: tables.map((table) => ({
-          type: table.type,
-          name: table.name,
-          ddl: table.ddl,
-          withoutRowId: table.withoutRowId,
-          strict: table.strict,
-          columns: table.columns,
-          foreignKeys: table.foreignKeys,
-          identityStrategy: table.identityStrategy,
-          notSafelyUpdatable: table.notSafelyUpdatable,
-        })),
+        tables: tables.map((table) =>
+          serializeGraphTable(table, resolveShadowOwnerTableName(table, tables))
+        ),
         relationshipCount,
       },
     };
@@ -65,6 +116,10 @@ class StructureService {
       type: table.type,
       name: table.name,
       ddl: table.ddl,
+      tableKind: table.tableKind,
+      isVirtual: Boolean(table.isVirtual),
+      isShadow: Boolean(table.isShadow),
+      virtualModule: table.isVirtual ? extractVirtualTableModule(table.ddl) : null,
       withoutRowId: table.withoutRowId,
       strict: table.strict,
       columns: table.columns,

package/server/services/sqlite/tableAdvisor.js

@@ -763,12 +763,18 @@ function analyzeTable(db, tableName) {
     score: calculateScore(issues),
     issueCount: issues.length,
     rowCount: Number(tableDetail.rowCount ?? 0),
+    tableKind: tableDetail.tableKind,
+    isVirtual: Boolean(tableDetail.isVirtual),
+    isShadow: Boolean(tableDetail.isShadow),
     issues,
     columnProfiles,
     table: {
       columnCount: (tableDetail.columns ?? []).filter((column) => column.visible && !column.generated).length,
       indexCount: (tableDetail.indexes ?? []).length,
       foreignKeyCount: (tableDetail.foreignKeys ?? []).length,
+      tableKind: tableDetail.tableKind,
+      isVirtual: Boolean(tableDetail.isVirtual),
+      isShadow: Boolean(tableDetail.isShadow),
     },
     analyzedAt: new Date().toISOString(),
   };

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