sqlite-hub 0.5.0 → 0.6.0

package/frontend/styles/views.css

@@ -25,6 +25,36 @@
   gap: var(--spacing-8);
 }
 
+.table-designer-view {
+  display: flex;
+  height: 100%;
+  min-height: 0;
+  overflow: hidden;
+}
+
+.table-designer-workspace {
+  display: flex;
+  flex: 1;
+  flex-direction: column;
+  gap: var(--spacing-4);
+  min-height: 0;
+  min-width: 0;
+}
+
+.table-designer-workspace__top,
+.table-designer-workspace__bottom {
+  min-height: 0;
+  min-width: 0;
+}
+
+.table-designer-workspace__top {
+  flex: 1;
+}
+
+.table-designer-workspace__bottom {
+  flex: 0 0 34%;
+}
+
 .landing-view {
   align-items: center;
   display: flex;
@@ -82,3 +112,13 @@
 .system-placeholder-card.is-primary {
   border-bottom-color: var(--color-primary-container);
 }
+
+@media (max-width: 1023px) {
+  .table-designer-view {
+    flex-direction: column;
+  }
+
+  .table-designer-workspace__bottom {
+    flex-basis: 280px;
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "sqlite-hub",
-    "version": "0.5.0",
+    "version": "0.6.0",
     "description": "SQLite-only local management app backend and SPA shell",
     "main": "server/server.js",
     "bin": {

package/server/routes/tableDesigner.js

@@ -0,0 +1,60 @@
+const express = require("express");
+const { route, successResponse } = require("../utils/errors");
+
+function createTableDesignerRouter({ tableDesignerService }) {
+  const router = express.Router();
+
+  router.get(
+    "/",
+    route((req, res) => {
+      const data = tableDesignerService.getOverview();
+
+      res.json(
+        successResponse({
+          data,
+          readOnly: false,
+        })
+      );
+    })
+  );
+
+  router.get(
+    "/:tableName",
+    route((req, res) => {
+      const data = tableDesignerService.getTableDraft(req.params.tableName);
+
+      res.json(
+        successResponse({
+          data,
+          readOnly: false,
+        })
+      );
+    })
+  );
+
+  router.post(
+    "/save",
+    route((req, res) => {
+      const data = tableDesignerService.saveDraft(req.body ?? {});
+      const isCreate = String(req.body?.draft?.mode ?? req.body?.mode ?? "").trim() !== "edit";
+      const fillsImportedRows = Boolean(req.body?.draft?.fillImportedRows ?? req.body?.fillImportedRows);
+
+      res.json(
+        successResponse({
+          message: isCreate
+            ? fillsImportedRows
+              ? "Table created and filled from CSV."
+              : "Table created."
+            : "Table schema updated.",
+          data,
+        })
+      );
+    })
+  );
+
+  return router;
+}
+
+module.exports = {
+  createTableDesignerRouter,
+};

package/server/server.js

@@ -11,11 +11,13 @@ const { BackupService } = require("./services/sqlite/backupService");
 const { ExportService } = require("./services/sqlite/exportService");
 const { StructureService } = require("./services/sqlite/structureService");
 const { DataBrowserService } = require("./services/sqlite/dataBrowserService");
+const { TableDesignerService } = require("./services/sqlite/tableDesignerService");
 const { createConnectionsRouter } = require("./routes/connections");
 const { createOverviewRouter } = require("./routes/overview");
 const { createSqlRouter } = require("./routes/sql");
 const { createStructureRouter } = require("./routes/structure");
 const { createDataRouter } = require("./routes/data");
+const { createTableDesignerRouter } = require("./routes/tableDesigner");
 const { createSettingsRouter } = require("./routes/settings");
 const { createExportRouter } = require("./routes/export");
 
@@ -46,6 +48,7 @@ const exportService = new ExportService({
 });
 const structureService = new StructureService({ connectionManager, appStateStore });
 const dataBrowserService = new DataBrowserService({ connectionManager });
+const tableDesignerService = new TableDesignerService({ connectionManager });
 
 connectionManager.initialize();
 
@@ -78,6 +81,7 @@ app.use("/api/db", createOverviewRouter({ overviewService }));
 app.use("/api/sql", createSqlRouter({ appStateStore, connectionManager, sqlExecutor }));
 app.use("/api/structure", createStructureRouter({ structureService }));
 app.use("/api/data", createDataRouter({ dataBrowserService }));
+app.use("/api/table-designer", createTableDesignerRouter({ tableDesignerService }));
 app.use("/api/settings", createSettingsRouter({ appStateStore }));
 app.use("/api/export", createExportRouter({ exportService }));
 

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

@@ -0,0 +1,295 @@
+const {
+  buildAlterTableAddColumnSql,
+  buildAlterTableRenameSql,
+  buildCreateTableSql,
+} = require("./sql");
+const { createDesignerWarning } = require("./schemaMapping");
+const { normalizeIdentifierKey, normalizeSqlFragment } = require("./validation");
+
+function normalizeComparableValue(value) {
+  return normalizeSqlFragment(value);
+}
+
+function hasColumnChanged(originalColumn, draftColumn) {
+  return (
+    normalizeIdentifierKey(originalColumn.name) !== normalizeIdentifierKey(draftColumn.name) ||
+    normalizeComparableValue(originalColumn.type) !== normalizeComparableValue(draftColumn.type) ||
+    Boolean(originalColumn.notNull) !== Boolean(draftColumn.notNull) ||
+    Boolean(originalColumn.unique) !== Boolean(draftColumn.unique) ||
+    Boolean(originalColumn.primaryKey) !== Boolean(draftColumn.primaryKey) ||
+    normalizeComparableValue(originalColumn.defaultValue) !==
+      normalizeComparableValue(draftColumn.defaultValue) ||
+    normalizeIdentifierKey(originalColumn.referencesTable) !==
+      normalizeIdentifierKey(draftColumn.referencesTable) ||
+    normalizeIdentifierKey(originalColumn.referencesColumn) !==
+      normalizeIdentifierKey(draftColumn.referencesColumn)
+  );
+}
+
+function hasMeaningfulNewDraftContent(draft) {
+  return (
+    Boolean(String(draft.tableName ?? "").trim()) ||
+    draft.columns.some((column) =>
+      !column.deleted &&
+      [
+        Boolean(String(column.name ?? "").trim()),
+        Boolean(String(column.defaultValue ?? "").trim()),
+        Boolean(String(column.referencesTable ?? "").trim()),
+        Boolean(String(column.referencesColumn ?? "").trim()),
+        Boolean(column.notNull),
+        Boolean(column.unique),
+        Boolean(column.primaryKey),
+        String(column.type ?? "").trim().toUpperCase() !== "TEXT",
+      ].some(Boolean)
+    )
+  );
+}
+
+function isAlterAddColumnSafe(column) {
+  const defaultValue = normalizeComparableValue(column.defaultValue);
+  const normalizedDefault = defaultValue.toUpperCase();
+
+  if (column.primaryKey) {
+    return {
+      safe: false,
+      reason: `Column ${column.name} cannot be added with PRIMARY KEY via ALTER TABLE in SQLite.`,
+    };
+  }
+
+  if (column.unique) {
+    return {
+      safe: false,
+      reason: `Column ${column.name} cannot be added with UNIQUE via ALTER TABLE in SQLite.`,
+    };
+  }
+
+  if (column.notNull && !defaultValue) {
+    return {
+      safe: false,
+      reason:
+        `Column ${column.name} uses NOT NULL without a default value. SQLite requires a table rebuild for that change.`,
+    };
+  }
+
+  if (["CURRENT_TIME", "CURRENT_DATE", "CURRENT_TIMESTAMP"].includes(normalizedDefault)) {
+    return {
+      safe: false,
+      reason:
+        `Column ${column.name} uses a dynamic default value that SQLite does not allow in ALTER TABLE ADD COLUMN.`,
+    };
+  }
+
+  if (/^\(.+\)$/.test(defaultValue)) {
+    return {
+      safe: false,
+      reason:
+        `Column ${column.name} uses an expression default value. SQLite requires a rebuild for that ADD COLUMN operation.`,
+    };
+  }
+
+  if (
+    column.referencesTable &&
+    column.referencesColumn &&
+    defaultValue &&
+    normalizedDefault !== "NULL"
+  ) {
+    return {
+      safe: false,
+      reason:
+        `Column ${column.name} adds a foreign key with a non-NULL default value. SQLite requires a table rebuild for that change.`,
+    };
+  }
+
+  return {
+    safe: true,
+    reason: "",
+  };
+}
+
+function buildRiskyChangeWarning(title, message) {
+  return createDesignerWarning({
+    code: "TABLE_REBUILD_REQUIRED",
+    title,
+    message,
+    blocking: true,
+  });
+}
+
+function analyzeEditDraft(draft, originalDraft) {
+  const originalColumnsByName = new Map(
+    originalDraft.columns.map((column) => [normalizeIdentifierKey(column.originalName || column.name), column])
+  );
+  const matchedOriginalNames = new Set();
+  const newColumns = [];
+  const warnings = [];
+  const executableStatements = [];
+
+  draft.columns.forEach((column) => {
+    if (column.deleted) {
+      if (normalizeIdentifierKey(column.originalName || column.name)) {
+        warnings.push(
+          buildRiskyChangeWarning(
+            "Column Delete Requires Rebuild",
+            `Deleting column ${column.originalName || column.name} requires a SQLite table rebuild.`
+          )
+        );
+      }
+
+      return;
+    }
+
+    const originalNameKey = normalizeIdentifierKey(column.originalName);
+
+    if (originalNameKey && originalColumnsByName.has(originalNameKey)) {
+      const originalColumn = originalColumnsByName.get(originalNameKey);
+      matchedOriginalNames.add(originalNameKey);
+
+      if (hasColumnChanged(originalColumn, column)) {
+        if (normalizeIdentifierKey(originalColumn.name) !== normalizeIdentifierKey(column.name)) {
+          warnings.push(
+            buildRiskyChangeWarning(
+              "Column Rename Requires Rebuild",
+              `Renaming column ${originalColumn.name} to ${column.name} is intentionally blocked in Table Designer v1.`
+            )
+          );
+        }
+
+        if (normalizeComparableValue(originalColumn.type) !== normalizeComparableValue(column.type)) {
+          warnings.push(
+            buildRiskyChangeWarning(
+              "Column Type Change Requires Rebuild",
+              `Changing the type of ${originalColumn.name} from ${originalColumn.type} to ${column.type} requires a SQLite table rebuild.`
+            )
+          );
+        }
+
+        if (Boolean(originalColumn.notNull) !== Boolean(column.notNull)) {
+          warnings.push(
+            buildRiskyChangeWarning(
+              "NOT NULL Change Requires Rebuild",
+              `Changing the NOT NULL setting on ${originalColumn.name} requires a SQLite table rebuild.`
+            )
+          );
+        }
+
+        if (Boolean(originalColumn.unique) !== Boolean(column.unique)) {
+          warnings.push(
+            buildRiskyChangeWarning(
+              "UNIQUE Change Requires Rebuild",
+              `Changing the UNIQUE setting on ${originalColumn.name} requires a SQLite table rebuild.`
+            )
+          );
+        }
+
+        if (Boolean(originalColumn.primaryKey) !== Boolean(column.primaryKey)) {
+          warnings.push(
+            buildRiskyChangeWarning(
+              "Primary Key Change Requires Rebuild",
+              `Changing the primary key definition on ${originalColumn.name} requires a SQLite table rebuild.`
+            )
+          );
+        }
+
+        if (
+          normalizeComparableValue(originalColumn.defaultValue) !==
+          normalizeComparableValue(column.defaultValue)
+        ) {
+          warnings.push(
+            buildRiskyChangeWarning(
+              "Default Value Change Requires Rebuild",
+              `Changing the default value on ${originalColumn.name} requires a SQLite table rebuild.`
+            )
+          );
+        }
+
+        if (
+          normalizeIdentifierKey(originalColumn.referencesTable) !==
+            normalizeIdentifierKey(column.referencesTable) ||
+          normalizeIdentifierKey(originalColumn.referencesColumn) !==
+            normalizeIdentifierKey(column.referencesColumn)
+        ) {
+          warnings.push(
+            buildRiskyChangeWarning(
+              "Foreign Key Change Requires Rebuild",
+              `Changing the foreign key on ${originalColumn.name} requires a SQLite table rebuild.`
+            )
+          );
+        }
+      }
+
+      return;
+    }
+
+    newColumns.push(column);
+  });
+
+  originalDraft.columns.forEach((column) => {
+    const key = normalizeIdentifierKey(column.originalName || column.name);
+    const isExplicitlyDeleted = draft.columns.some(
+      (draftColumn) =>
+        draftColumn.deleted &&
+        normalizeIdentifierKey(draftColumn.originalName || draftColumn.name) === key
+    );
+
+    if (!matchedOriginalNames.has(key) && !isExplicitlyDeleted) {
+      warnings.push(
+        buildRiskyChangeWarning(
+          "Column Delete Requires Rebuild",
+          `Deleting column ${column.name} requires a SQLite table rebuild.`
+        )
+      );
+    }
+  });
+
+  const tableRenameChanged =
+    normalizeIdentifierKey(draft.tableName) !== normalizeIdentifierKey(originalDraft.tableName);
+
+  if (tableRenameChanged) {
+    executableStatements.push(
+      buildAlterTableRenameSql(originalDraft.tableName, draft.tableName)
+    );
+  }
+
+  newColumns.forEach((column) => {
+    const addColumnSafety = isAlterAddColumnSafe(column);
+
+    if (!addColumnSafety.safe) {
+      warnings.push(
+        buildRiskyChangeWarning("Column Add Requires Rebuild", addColumnSafety.reason)
+      );
+      return;
+    }
+
+    executableStatements.push(
+      buildAlterTableAddColumnSql(tableRenameChanged ? draft.tableName : originalDraft.tableName, column)
+    );
+  });
+
+  const dirty = Boolean(executableStatements.length || warnings.length);
+
+  return {
+    dirty,
+    executable: warnings.length === 0,
+    statements: warnings.length === 0 ? executableStatements : [],
+    previewStatements: executableStatements,
+    warnings,
+  };
+}
+
+function analyzeTableDesignerChanges({ draft, originalDraft = null }) {
+  if (!originalDraft) {
+    return {
+      dirty: hasMeaningfulNewDraftContent(draft),
+      executable: true,
+      statements: [buildCreateTableSql(draft)],
+      previewStatements: [buildCreateTableSql(draft)],
+      warnings: [],
+    };
+  }
+
+  return analyzeEditDraft(draft, originalDraft);
+}
+
+module.exports = {
+  analyzeTableDesignerChanges,
+};

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,
+};