@fragno-dev/db 0.2.2 → 0.4.1

package/src/migration-engine/auto-from-schema.ts

@@ -1,5 +1,243 @@
-import { type AnySchema } from "../schema/create";
-import type { MigrationOperation, ColumnInfo } from "./shared";
+import {
+  type AnySchema,
+  type AnyColumn,
+  type TableSubOperation,
+  type SchemaOperation,
+} from "../schema/create";
+import type {
+  MigrationOperation,
+  ColumnInfo,
+  ColumnOperation,
+  ForeignKeyInfo,
+  SqliteAlterTableMetadata,
+  SqliteCopyColumn,
+} from "./shared";
+
+type IndexInfo = { name: string; columns: string[]; unique: boolean };
+
+type TableState = {
+  columns: Record<string, AnyColumn>;
+  columnOrder: string[];
+  indexes: Record<string, IndexInfo>;
+  foreignKeys: ForeignKeyInfo[];
+};
+
+function cloneTableState(state: TableState): TableState {
+  return {
+    columns: { ...state.columns },
+    columnOrder: [...state.columnOrder],
+    indexes: { ...state.indexes },
+    foreignKeys: [...state.foreignKeys],
+  };
+}
+
+function createTableState(operations: TableSubOperation[]): TableState {
+  const state: TableState = {
+    columns: {},
+    columnOrder: [],
+    indexes: {},
+    foreignKeys: [],
+  };
+
+  for (const subOp of operations) {
+    if (subOp.type === "add-column") {
+      state.columns[subOp.columnName] = subOp.column;
+      state.columnOrder.push(subOp.columnName);
+    } else if (subOp.type === "add-index") {
+      state.indexes[subOp.name] = {
+        name: subOp.name,
+        columns: [...subOp.columns],
+        unique: subOp.unique,
+      };
+    }
+  }
+
+  return state;
+}
+
+function applyTableSubOperations(state: TableState, operations: TableSubOperation[]): void {
+  for (const subOp of operations) {
+    if (subOp.type === "add-column") {
+      if (!state.columns[subOp.columnName]) {
+        state.columnOrder.push(subOp.columnName);
+      }
+      state.columns[subOp.columnName] = subOp.column;
+    } else if (subOp.type === "update-column") {
+      state.columns[subOp.columnName] = subOp.column;
+    } else if (subOp.type === "rename-column") {
+      if (state.columns[subOp.from]) {
+        state.columns[subOp.to] = state.columns[subOp.from]!;
+        delete state.columns[subOp.from];
+      }
+      const orderIndex = state.columnOrder.indexOf(subOp.from);
+      if (orderIndex !== -1) {
+        state.columnOrder[orderIndex] = subOp.to;
+      }
+      state.indexes = renameColumnInIndexes(state.indexes, subOp.from, subOp.to);
+      state.foreignKeys = renameColumnInForeignKeys(state.foreignKeys, subOp.from, subOp.to);
+    } else if (subOp.type === "drop-column") {
+      if (state.columns[subOp.name]) {
+        delete state.columns[subOp.name];
+      }
+      state.columnOrder = state.columnOrder.filter((colName) => colName !== subOp.name);
+      state.indexes = dropColumnFromIndexes(state.indexes, subOp.name);
+      state.foreignKeys = dropColumnFromForeignKeys(state.foreignKeys, subOp.name);
+    } else if (subOp.type === "add-index") {
+      state.indexes[subOp.name] = {
+        name: subOp.name,
+        columns: [...subOp.columns],
+        unique: subOp.unique,
+      };
+    }
+  }
+}
+
+function renameColumnInIndexes(
+  indexes: Record<string, IndexInfo>,
+  from: string,
+  to: string,
+): Record<string, IndexInfo> {
+  const next: Record<string, IndexInfo> = {};
+
+  for (const [name, index] of Object.entries(indexes)) {
+    if (!index.columns.includes(from)) {
+      next[name] = index;
+      continue;
+    }
+
+    next[name] = {
+      ...index,
+      columns: index.columns.map((column) => (column === from ? to : column)),
+    };
+  }
+
+  return next;
+}
+
+function dropColumnFromIndexes(
+  indexes: Record<string, IndexInfo>,
+  columnName: string,
+): Record<string, IndexInfo> {
+  const next: Record<string, IndexInfo> = {};
+
+  for (const [name, index] of Object.entries(indexes)) {
+    if (index.columns.includes(columnName)) {
+      continue;
+    }
+    next[name] = index;
+  }
+
+  return next;
+}
+
+function renameColumnInForeignKeys(
+  foreignKeys: ForeignKeyInfo[],
+  from: string,
+  to: string,
+): ForeignKeyInfo[] {
+  return foreignKeys.map((foreignKey) => {
+    if (!foreignKey.columns.includes(from)) {
+      return foreignKey;
+    }
+
+    return {
+      ...foreignKey,
+      columns: foreignKey.columns.map((column) => (column === from ? to : column)),
+    };
+  });
+}
+
+function dropColumnFromForeignKeys(
+  foreignKeys: ForeignKeyInfo[],
+  columnName: string,
+): ForeignKeyInfo[] {
+  return foreignKeys.filter((foreignKey) => !foreignKey.columns.includes(columnName));
+}
+
+function buildCopyColumns(
+  columnOrder: string[],
+  operations: TableSubOperation[],
+): SqliteCopyColumn[] {
+  const mappings = columnOrder.map((columnName) => ({ from: columnName, to: columnName }));
+
+  for (const op of operations) {
+    if (op.type === "rename-column") {
+      for (const mapping of mappings) {
+        if (mapping.to === op.from) {
+          mapping.to = op.to;
+        }
+      }
+    } else if (op.type === "drop-column") {
+      for (let i = mappings.length - 1; i >= 0; i -= 1) {
+        if (mappings[i]?.to === op.name) {
+          mappings.splice(i, 1);
+        }
+      }
+    }
+  }
+
+  return mappings;
+}
+
+function applyRenameDropToColumnList(
+  columns: string[],
+  operations: TableSubOperation[],
+): string[] | null {
+  let next = [...columns];
+
+  for (const op of operations) {
+    if (op.type === "rename-column") {
+      next = next.map((column) => (column === op.from ? op.to : column));
+      continue;
+    }
+
+    if (op.type === "drop-column" && next.includes(op.name)) {
+      return null;
+    }
+  }
+
+  return next;
+}
+
+function applyReferenceOperation(
+  state: TableState,
+  operation: Extract<SchemaOperation, { type: "add-reference" }>,
+): void {
+  if (operation.config.foreignKey === false) {
+    return;
+  }
+  state.foreignKeys.push({
+    name: operation.referenceName,
+    columns: [operation.config.from.column],
+    referencedTable: operation.config.to.table,
+    referencedColumns: [operation.config.to.column],
+  });
+}
+
+function buildTableStates(schema: AnySchema, version: number): Map<string, TableState> {
+  const tableStates = new Map<string, TableState>();
+  const operations = schema.operations.slice(0, version);
+
+  for (const op of operations) {
+    if (op.type === "add-table") {
+      tableStates.set(op.tableName, createTableState(op.operations));
+    } else if (op.type === "alter-table") {
+      const state = tableStates.get(op.tableName);
+      if (!state) {
+        continue;
+      }
+      applyTableSubOperations(state, op.operations);
+    } else if (op.type === "add-reference") {
+      const state = tableStates.get(op.tableName);
+      if (!state) {
+        continue;
+      }
+      applyReferenceOperation(state, op);
+    }
+  }
+
+  return tableStates;
+}
 
 /**
  * Generate migration operations from a schema's operation history
@@ -16,7 +254,7 @@ import type { MigrationOperation, ColumnInfo } from "./shared";
  *
  * @example
  * ```ts
- * const mySchema = schema(s => s
+ * const mySchema = schema("my", s => s
  *   .addTable("users", t => t.addColumn("id", idColumn()))       // version 1
  *   .addTable("posts", t => t.addColumn("id", idColumn()))       // version 2
  * );
@@ -56,6 +294,25 @@ export function generateMigrationFromSchema(
 
   // Convert schema operations to migration operations
   const migrationOperations: MigrationOperation[] = [];
+  const tableStates = buildTableStates(targetSchema, fromVersion);
+
+  const toColumnInfo = (columnName: string, col: AnyColumn): ColumnInfo => {
+    return {
+      name: columnName,
+      type: col.type,
+      isNullable: col.isNullable,
+      role: col.role,
+      default: col.default
+        ? "value" in col.default
+          ? { value: col.default.value }
+          : "dbSpecial" in col.default
+            ? { dbSpecial: col.default.dbSpecial }
+            : "runtime" in col.default && typeof col.default.runtime === "string"
+              ? { runtime: col.default.runtime }
+              : undefined
+        : undefined,
+    };
+  };
 
   for (const op of relevantOperations) {
     if (op.type === "add-table") {
@@ -64,22 +321,7 @@ export function generateMigrationFromSchema(
 
       for (const subOp of op.operations) {
         if (subOp.type === "add-column") {
-          const col = subOp.column;
-          columns.push({
-            name: subOp.columnName,
-            type: col.type,
-            isNullable: col.isNullable,
-            role: col.role,
-            default: col.default
-              ? "value" in col.default
-                ? { value: col.default.value }
-                : "dbSpecial" in col.default
-                  ? { dbSpecial: col.default.dbSpecial }
-                  : "runtime" in col.default && typeof col.default.runtime === "string"
-                    ? { runtime: col.default.runtime }
-                    : undefined
-              : undefined,
-          });
+          columns.push(toColumnInfo(subOp.columnName, subOp.column));
         }
       }
 
@@ -112,35 +354,97 @@ export function generateMigrationFromSchema(
           });
         }
       }
+
+      tableStates.set(op.tableName, createTableState(op.operations));
     } else if (op.type === "alter-table") {
-      const columnOps = op.operations.filter((o) => o.type === "add-column");
+      const columnOps: ColumnOperation[] = [];
+      const tableState = tableStates.get(op.tableName);
+
+      for (const subOp of op.operations) {
+        if (subOp.type === "add-column") {
+          columnOps.push({
+            type: "create-column",
+            value: toColumnInfo(subOp.columnName, subOp.column),
+          });
+        } else if (subOp.type === "update-column") {
+          columnOps.push({
+            type: "update-column",
+            name: subOp.columnName,
+            value: toColumnInfo(subOp.columnName, subOp.column),
+            updateNullable: subOp.updateNullable,
+            updateDefault: subOp.updateDefault,
+            updateDataType: subOp.updateDataType,
+          });
+        } else if (subOp.type === "rename-column") {
+          columnOps.push({
+            type: "rename-column",
+            from: subOp.from,
+            to: subOp.to,
+          });
+        } else if (subOp.type === "drop-column") {
+          columnOps.push({
+            type: "drop-column",
+            name: subOp.name,
+          });
+        }
+      }
 
       if (columnOps.length > 0) {
-        migrationOperations.push({
+        const hasUpdateColumn = columnOps.some((colOp) => colOp.type === "update-column");
+        const alterTableOperation: MigrationOperation = {
           type: "alter-table",
           name: op.tableName,
-          value: columnOps.map((o) => {
-            const col = o.column;
-            return {
-              type: "create-column" as const,
-              value: {
-                name: o.columnName,
-                type: col.type,
-                isNullable: col.isNullable,
-                role: col.role,
-                default: col.default
-                  ? "value" in col.default
-                    ? { value: col.default.value }
-                    : "dbSpecial" in col.default
-                      ? { dbSpecial: col.default.dbSpecial }
-                      : "runtime" in col.default && typeof col.default.runtime === "string"
-                        ? { runtime: col.default.runtime }
-                        : undefined
-                  : undefined,
-              },
-            };
-          }),
-        });
+          value: columnOps,
+        };
+
+        if (hasUpdateColumn) {
+          if (!tableState) {
+            throw new Error(`Table ${op.tableName} not found in schema state`);
+          }
+
+          const nextState = cloneTableState(tableState);
+          applyTableSubOperations(nextState, op.operations);
+
+          const metadata: SqliteAlterTableMetadata = {
+            recreateTable: {
+              columns: nextState.columnOrder.map((colName) =>
+                toColumnInfo(colName, nextState.columns[colName]!),
+              ),
+              copyColumns: buildCopyColumns(tableState.columnOrder, op.operations),
+              indexes: Object.values(tableState.indexes).flatMap((idx) => {
+                const columns = applyRenameDropToColumnList(idx.columns, op.operations);
+                if (!columns) {
+                  return [];
+                }
+                return [
+                  {
+                    name: idx.name,
+                    columns,
+                    unique: idx.unique,
+                  },
+                ];
+              }),
+              foreignKeys: tableState.foreignKeys.flatMap((fk) => {
+                const columns = applyRenameDropToColumnList(fk.columns, op.operations);
+                if (!columns) {
+                  return [];
+                }
+                return [
+                  {
+                    name: fk.name,
+                    columns,
+                    referencedTable: fk.referencedTable,
+                    referencedColumns: [...fk.referencedColumns],
+                  },
+                ];
+              }),
+            },
+          };
+
+          alterTableOperation.metadata = metadata;
+        }
+
+        migrationOperations.push(alterTableOperation);
       }
 
       // Add indexes as separate operations
@@ -155,17 +459,34 @@ export function generateMigrationFromSchema(
           });
         }
       }
+
+      if (tableState) {
+        const nextState = cloneTableState(tableState);
+        applyTableSubOperations(nextState, op.operations);
+        tableStates.set(op.tableName, nextState);
+      }
     } else if (op.type === "add-reference") {
+      if (!op.referenceName || op.referenceName.trim().length === 0) {
+        throw new Error(`referenceName is required for add-reference on ${op.tableName}`);
+      }
+      if (op.config.foreignKey === false) {
+        continue;
+      }
       migrationOperations.push({
         type: "add-foreign-key",
         table: op.tableName,
         value: {
-          name: `${op.tableName}_${op.config.to.table}_${op.referenceName}_fk`,
+          name: op.referenceName,
           columns: [op.config.from.column],
           referencedTable: op.config.to.table,
           referencedColumns: [op.config.to.column],
         },
       });
+
+      const tableState = tableStates.get(op.tableName);
+      if (tableState) {
+        applyReferenceOperation(tableState, op);
+      }
     }
   }
 

package/src/migration-engine/create.test.ts

@@ -1,10 +1,11 @@
 import { describe, expect, it, vi } from "vitest";
-import { createMigrator, type MigrationEngineOptions } from "./create";
+
 import { schema, idColumn, column, referenceColumn } from "../schema/create";
+import { createMigrator, type MigrationEngineOptions } from "./create";
 import type { MigrationOperation } from "./shared";
 
 describe("createMigrator", () => {
-  const testSchema = schema((s) => {
+  const testSchema = schema("test", (s) => {
     return s
       .addTable("users", (t) => {
         return t.addColumn("id", idColumn()).addColumn("name", column("string"));
@@ -296,7 +297,7 @@ describe("createMigrator", () => {
 
   describe("with foreign keys", () => {
     it("should handle schema with foreign keys", async () => {
-      const fkSchema = schema((s) => {
+      const fkSchema = schema("fk", (s) => {
         return s
           .addTable("users", (t) => {
             return t.addColumn("id", idColumn());

package/src/migration-engine/create.ts

@@ -1,6 +1,6 @@
-import { type MigrationOperation } from "./shared";
 import type { AnySchema } from "../schema/create";
 import { generateMigrationFromSchema as defaultGenerateMigrationFromSchema } from "./auto-from-schema";
+import { type MigrationOperation } from "./shared";
 
 type Awaitable<T> = T | Promise<T>;