sqlite-hub 0.4.0 → 0.6.0

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

@@ -0,0 +1,233 @@
+const { quoteIdentifier } = require("../../../utils/identifier");
+const { getRawStructureEntries } = require("../introspection");
+
+const SUPPORTED_TABLE_DESIGNER_TYPES = [
+  "TEXT",
+  "INTEGER",
+  "REAL",
+  "BLOB",
+  "NUMERIC",
+  "BOOLEAN",
+  "DATE",
+  "DATETIME",
+];
+
+function normalizeDesignerType(value) {
+  const normalized = String(value ?? "").trim().toUpperCase();
+  return normalized || "TEXT";
+}
+
+function createDesignerWarning({
+  code,
+  title,
+  message,
+  tone = "alert",
+  blocking = false,
+}) {
+  return {
+    code,
+    title,
+    message,
+    tone,
+    blocking,
+  };
+}
+
+function buildSingleColumnUniqueSet(indexes = []) {
+  const uniqueColumns = new Set();
+
+  indexes.forEach((index) => {
+    if (!index?.unique || index.partial || !Array.isArray(index.columns) || index.columns.length !== 1) {
+      return;
+    }
+
+    const columnName = index.columns[0]?.name;
+
+    if (columnName) {
+      uniqueColumns.add(columnName);
+    }
+  });
+
+  return uniqueColumns;
+}
+
+function buildSimpleForeignKeyMap(foreignKeys = []) {
+  const map = new Map();
+
+  foreignKeys.forEach((foreignKey) => {
+    if (!Array.isArray(foreignKey?.mappings) || foreignKey.mappings.length !== 1) {
+      return;
+    }
+
+    const mapping = foreignKey.mappings[0];
+
+    if (!mapping?.from || !mapping?.to || map.has(mapping.from)) {
+      return;
+    }
+
+    map.set(mapping.from, {
+      table: foreignKey.referencedTable,
+      column: mapping.to,
+    });
+  });
+
+  return map;
+}
+
+function buildSchemaWarnings(tableDetail) {
+  const warnings = [];
+  const generatedColumns = (tableDetail.columns ?? []).filter((column) => column.generated);
+  const compositePrimaryKeyColumns = (tableDetail.columns ?? []).filter(
+    (column) => Number(column.primaryKeyPosition ?? 0) > 0
+  );
+  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)
+  );
+
+  if (generatedColumns.length) {
+    warnings.push(
+      createDesignerWarning({
+        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.",
+      })
+    );
+  }
+
+  if (compositePrimaryKeyColumns.length > 1) {
+    warnings.push(
+      createDesignerWarning({
+        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.",
+      })
+    );
+  }
+
+  if (complexForeignKeys.length) {
+    warnings.push(
+      createDesignerWarning({
+        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.",
+      })
+    );
+  }
+
+  if (complexUniqueIndexes.length) {
+    warnings.push(
+      createDesignerWarning({
+        code: "COMPLEX_UNIQUE_CONSTRAINTS_PRESENT",
+        title: "Complex Unique Constraints Detected",
+        message:
+          "Multi-column or partial UNIQUE constraints are outside Table Designer v1. They remain untouched unless you rebuild the table manually.",
+      })
+    );
+  }
+
+  if (tableDetail.strict) {
+    warnings.push(
+      createDesignerWarning({
+        code: "STRICT_TABLE_PRESENT",
+        title: "STRICT Table",
+        message:
+          "STRICT tables can be renamed and extended with supported columns, but rebuild-style schema edits should be reviewed carefully.",
+        tone: "muted",
+      })
+    );
+  }
+
+  if (tableDetail.withoutRowId) {
+    warnings.push(
+      createDesignerWarning({
+        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.",
+        tone: "muted",
+      })
+    );
+  }
+
+  return warnings;
+}
+
+function mapTableColumnToDraft(column, { uniqueColumns, foreignKeyMap }) {
+  const foreignKey = foreignKeyMap.get(column.name);
+  const type = normalizeDesignerType(column.declaredType || column.affinity || "TEXT");
+  const defaultValue = column.defaultValue ?? "";
+
+  return {
+    id: `existing:${column.cid}:${column.name}`,
+    isNew: false,
+    deleted: false,
+    name: column.name,
+    type,
+    notNull: Boolean(column.notNull),
+    unique: uniqueColumns.has(column.name),
+    primaryKey: Number(column.primaryKeyPosition ?? 0) > 0,
+    defaultValue,
+    referencesTable: foreignKey?.table ?? "",
+    referencesColumn: foreignKey?.column ?? "",
+    originalName: column.name,
+    originalType: type,
+    originalNotNull: Boolean(column.notNull),
+    originalUnique: uniqueColumns.has(column.name),
+    originalPrimaryKey: Number(column.primaryKeyPosition ?? 0) > 0,
+    originalDefaultValue: defaultValue,
+    originalReferencesTable: foreignKey?.table ?? "",
+    originalReferencesColumn: foreignKey?.column ?? "",
+  };
+}
+
+function buildTableDesignerDraft(tableDetail) {
+  const uniqueColumns = buildSingleColumnUniqueSet(tableDetail.indexes);
+  const foreignKeyMap = buildSimpleForeignKeyMap(tableDetail.foreignKeys);
+  const columns = (tableDetail.columns ?? [])
+    .filter((column) => column.visible !== false && !column.generated)
+    .map((column) => mapTableColumnToDraft(column, { uniqueColumns, foreignKeyMap }));
+  const schemaWarnings = buildSchemaWarnings(tableDetail);
+
+  return {
+    mode: "edit",
+    originalTableName: tableDetail.name,
+    tableName: tableDetail.name,
+    columns,
+    dirty: false,
+    schemaWarnings,
+    warnings: [...schemaWarnings],
+  };
+}
+
+function listDesignerTables(db) {
+  return getRawStructureEntries(db)
+    .filter((entry) => entry.type === "table")
+    .map((entry) => {
+      const columns = db
+        .prepare(`PRAGMA table_xinfo(${quoteIdentifier(entry.name)})`)
+        .all()
+        .filter((column) => Number(column.hidden ?? 0) === 0)
+        .map((column) => column.name);
+
+      return {
+        name: entry.name,
+        columnCount: columns.length,
+        columns,
+      };
+    })
+    .sort((left, right) => left.name.localeCompare(right.name, undefined, { sensitivity: "base" }));
+}
+
+module.exports = {
+  SUPPORTED_TABLE_DESIGNER_TYPES,
+  buildTableDesignerDraft,
+  createDesignerWarning,
+  listDesignerTables,
+  normalizeDesignerType,
+};

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

@@ -0,0 +1,63 @@
+const { quoteIdentifier, quoteIdentifierList } = require("../../../utils/identifier");
+const { normalizeSqlFragment } = require("./validation");
+
+function buildColumnDefinition(column) {
+  const parts = [quoteIdentifier(column.name)];
+  const type = normalizeSqlFragment(column.type);
+  const defaultValue = normalizeSqlFragment(column.defaultValue);
+
+  if (type) {
+    parts.push(type);
+  }
+
+  if (column.primaryKey) {
+    parts.push("PRIMARY KEY");
+  }
+
+  if (column.notNull) {
+    parts.push("NOT NULL");
+  }
+
+  if (column.unique) {
+    parts.push("UNIQUE");
+  }
+
+  if (defaultValue) {
+    parts.push(`DEFAULT ${defaultValue}`);
+  }
+
+  if (column.referencesTable && column.referencesColumn) {
+    parts.push(
+      `REFERENCES ${quoteIdentifier(column.referencesTable)}(${quoteIdentifier(column.referencesColumn)})`
+    );
+  }
+
+  return parts.join(" ");
+}
+
+function buildCreateTableSql(draft) {
+  const columnSql = draft.columns.map((column) => `  ${buildColumnDefinition(column)}`).join(",\n");
+
+  return `CREATE TABLE ${quoteIdentifier(draft.tableName)} (\n${columnSql}\n);`;
+}
+
+function buildAlterTableRenameSql(fromName, toName) {
+  return `ALTER TABLE ${quoteIdentifier(fromName)} RENAME TO ${quoteIdentifier(toName)};`;
+}
+
+function buildAlterTableAddColumnSql(tableName, column) {
+  return `ALTER TABLE ${quoteIdentifier(tableName)} ADD COLUMN ${buildColumnDefinition(column)};`;
+}
+
+function buildInsertRowsSql(tableName, columns) {
+  const placeholders = columns.map(() => "?").join(", ");
+  return `INSERT INTO ${quoteIdentifier(tableName)} (${quoteIdentifierList(columns)}) VALUES (${placeholders});`;
+}
+
+module.exports = {
+  buildAlterTableAddColumnSql,
+  buildAlterTableRenameSql,
+  buildColumnDefinition,
+  buildCreateTableSql,
+  buildInsertRowsSql,
+};

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

@@ -0,0 +1,245 @@
+const { ValidationError } = require("../../../utils/errors");
+const { assertValidIdentifier } = require("../../../utils/identifier");
+const { normalizeDesignerType } = require("./schemaMapping");
+
+function normalizeBoolean(value) {
+  return value === true || value === "true" || value === 1 || value === "1";
+}
+
+function normalizeSqlFragment(value) {
+  return String(value ?? "").trim();
+}
+
+function assertSafeSqlFragment(value, label, { allowEmpty = true } = {}) {
+  const normalized = normalizeSqlFragment(value);
+
+  if (!normalized) {
+    if (allowEmpty) {
+      return "";
+    }
+
+    throw new ValidationError(`${label} is required.`);
+  }
+
+  if (
+    normalized.includes("\0") ||
+    normalized.includes(";") ||
+    normalized.includes("--") ||
+    normalized.includes("/*") ||
+    normalized.includes("*/")
+  ) {
+    throw new ValidationError(
+      `${label} must be a single SQL fragment without statement separators or comments.`
+    );
+  }
+
+  return normalized;
+}
+
+function normalizeColumnPayload(column = {}, index = 0) {
+  const importedValueIndex =
+    column.importedValueIndex === null || column.importedValueIndex === undefined
+      ? null
+      : Number(column.importedValueIndex);
+
+  return {
+    id: String(column.id ?? `column:${index}`),
+    isNew: normalizeBoolean(column.isNew),
+    deleted: normalizeBoolean(column.deleted),
+    name: String(column.name ?? "").trim(),
+    type: normalizeDesignerType(column.type),
+    notNull: normalizeBoolean(column.notNull),
+    unique: normalizeBoolean(column.unique),
+    primaryKey: normalizeBoolean(column.primaryKey),
+    defaultValue: assertSafeSqlFragment(column.defaultValue, "Default value"),
+    referencesTable: String(column.referencesTable ?? "").trim(),
+    referencesColumn: String(column.referencesColumn ?? "").trim(),
+    originalName: String(column.originalName ?? "").trim(),
+    originalType: normalizeDesignerType(column.originalType || column.type),
+    originalNotNull: normalizeBoolean(column.originalNotNull),
+    originalUnique: normalizeBoolean(column.originalUnique),
+    originalPrimaryKey: normalizeBoolean(column.originalPrimaryKey),
+    originalDefaultValue: assertSafeSqlFragment(column.originalDefaultValue, "Original default value"),
+    originalReferencesTable: String(column.originalReferencesTable ?? "").trim(),
+    originalReferencesColumn: String(column.originalReferencesColumn ?? "").trim(),
+    importedValueIndex: Number.isInteger(importedValueIndex) ? importedValueIndex : null,
+  };
+}
+
+function normalizeDraftPayload(payload = {}) {
+  const mode = String(payload.mode ?? "create").trim() === "edit" ? "edit" : "create";
+
+  return {
+    mode,
+    originalTableName: String(payload.originalTableName ?? "").trim(),
+    tableName: String(payload.tableName ?? "").trim(),
+    columns: Array.isArray(payload.columns)
+      ? payload.columns.map((column, index) => normalizeColumnPayload(column, index))
+      : [],
+    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 ?? "")) : []
+        )
+      : [],
+    dirty: normalizeBoolean(payload.dirty),
+  };
+}
+
+function normalizeIdentifierKey(value) {
+  return String(value ?? "").trim().toLowerCase();
+}
+
+function buildSelfReferenceColumns(draft) {
+  return draft.columns
+    .filter((column) => !column.deleted)
+    .map((column) => column.name)
+    .filter(Boolean);
+}
+
+function validatePrimaryKeys(draft, originalDraft) {
+  const currentPrimaryKeyColumns = draft.columns.filter(
+    (column) => !column.deleted && column.primaryKey
+  );
+
+  if (currentPrimaryKeyColumns.length <= 1) {
+    return;
+  }
+
+  if (!originalDraft) {
+    throw new ValidationError(
+      "Table Designer v1 supports a single primary key column when creating a table."
+    );
+  }
+
+  const originalPrimaryKeyNames = new Set(
+    originalDraft.columns
+      .filter((column) => column.primaryKey)
+      .map((column) => normalizeIdentifierKey(column.originalName || column.name))
+  );
+  const currentPrimaryKeyNames = new Set(
+    currentPrimaryKeyColumns.map((column) =>
+      normalizeIdentifierKey(column.originalName || column.name)
+    )
+  );
+
+  const isUnchangedCompositePrimaryKey =
+    originalPrimaryKeyNames.size > 1 &&
+    originalPrimaryKeyNames.size === currentPrimaryKeyNames.size &&
+    [...currentPrimaryKeyNames].every((name) => originalPrimaryKeyNames.has(name));
+
+  if (!isUnchangedCompositePrimaryKey) {
+    throw new ValidationError(
+      "Table Designer v1 does not support editing composite primary keys."
+    );
+  }
+}
+
+function validateTableDesignerDraft(draft, { catalogTables = [], originalDraft = null } = {}) {
+  if (!["create", "edit"].includes(draft.mode)) {
+    throw new ValidationError("Draft mode must be create or edit.");
+  }
+
+  assertValidIdentifier(draft.tableName, "Table name");
+
+  if (draft.mode === "edit") {
+    assertValidIdentifier(draft.originalTableName, "Original table name");
+  }
+
+  if (!draft.columns.length) {
+    throw new ValidationError("At least one column is required.");
+  }
+
+  const activeColumns = draft.columns.filter((column) => !column.deleted);
+
+  if (!activeColumns.length) {
+    throw new ValidationError("At least one column is required.");
+  }
+
+  const catalogByName = new Map(
+    catalogTables.map((table) => [normalizeIdentifierKey(table.name), table])
+  );
+  const normalizedTableName = normalizeIdentifierKey(draft.tableName);
+  const normalizedOriginalTableName = normalizeIdentifierKey(draft.originalTableName);
+
+  if (
+    catalogByName.has(normalizedTableName) &&
+    (draft.mode === "create" || normalizedTableName !== normalizedOriginalTableName)
+  ) {
+    throw new ValidationError(`A table named ${draft.tableName} already exists.`);
+  }
+
+  const seenColumns = new Set();
+
+  activeColumns.forEach((column) => {
+    assertValidIdentifier(column.name, "Column name");
+    assertSafeSqlFragment(column.type, `Type for ${column.name}`, { allowEmpty: false });
+
+    const normalizedColumnName = normalizeIdentifierKey(column.name);
+
+    if (seenColumns.has(normalizedColumnName)) {
+      throw new ValidationError(`Duplicate column name: ${column.name}`);
+    }
+
+    seenColumns.add(normalizedColumnName);
+
+    const hasReferenceTable = Boolean(column.referencesTable);
+    const hasReferenceColumn = Boolean(column.referencesColumn);
+
+    if (hasReferenceTable !== hasReferenceColumn) {
+      throw new ValidationError(
+        `Column ${column.name} must define both a referenced table and a referenced column.`
+      );
+    }
+
+    if (!hasReferenceTable || !hasReferenceColumn) {
+      return;
+    }
+
+    const normalizedReferenceTable = normalizeIdentifierKey(column.referencesTable);
+    const referencedTable =
+      normalizedReferenceTable === normalizedTableName
+        ? {
+            name: draft.tableName,
+            columns: buildSelfReferenceColumns(draft),
+          }
+        : catalogByName.get(normalizedReferenceTable);
+
+    if (!referencedTable) {
+      throw new ValidationError(
+        `Referenced table ${column.referencesTable} does not exist in the current SQLite schema.`
+      );
+    }
+
+    const hasReferencedColumn = (referencedTable.columns ?? []).some(
+      (candidate) => normalizeIdentifierKey(candidate) === normalizeIdentifierKey(column.referencesColumn)
+    );
+
+    if (!hasReferencedColumn) {
+      throw new ValidationError(
+        `Referenced column ${column.referencesColumn} does not exist on ${referencedTable.name}.`
+      );
+    }
+  });
+
+  validatePrimaryKeys(draft, originalDraft);
+
+  if (draft.mode === "edit" && draft.fillImportedRows) {
+    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.");
+  }
+}
+
+module.exports = {
+  normalizeDraftPayload,
+  normalizeIdentifierKey,
+  normalizeSqlFragment,
+  validateTableDesignerDraft,
+};