@fragno-dev/db 0.3.0 → 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
@@ -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,10 +459,19 @@ 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,
@@ -169,6 +482,11 @@ export function generateMigrationFromSchema(
           referencedColumns: [op.config.to.column],
         },
       });
+
+      const tableState = tableStates.get(op.tableName);
+      if (tableState) {
+        applyReferenceOperation(tableState, op);
+      }
     }
   }
 

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

@@ -1,6 +1,7 @@
 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", () => {

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>;
 

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

@@ -1,18 +1,20 @@
 import { describe, it, expect, beforeAll, beforeEach, vi, afterEach } from "vitest";
+
 import { DummyDriver, MysqlAdapter, PostgresAdapter, SqliteAdapter } from "kysely";
-import {
-  postProcessMigrationFilenames,
-  type GenerationInternalResult,
-  generateSchemaArtifacts,
-} from "./generation-engine";
-import { SqlAdapter } from "../adapters/generic-sql/generic-sql-adapter";
-import { column, idColumn, schema, type AnySchema } from "../schema/create";
-import { FragnoDatabase } from "../mod";
+
 import {
   MySQL2DriverConfig,
   NodePostgresDriverConfig,
   SQLocalDriverConfig,
 } from "../adapters/generic-sql/driver-config";
+import { SqlAdapter } from "../adapters/generic-sql/generic-sql-adapter";
+import { FragnoDatabase } from "../mod";
+import { column, idColumn, schema, type AnySchema } from "../schema/create";
+import {
+  postProcessMigrationFilenames,
+  type GenerationInternalResult,
+  generateSchemaArtifacts,
+} from "./generation-engine";
 
 const buildFile = (
   overrides: Partial<GenerationInternalResult> &
@@ -293,7 +295,7 @@ describe("generateSchemaArtifacts - sql", () => {
     expect(resultsV1[1].schema).toMatchInlineSnapshot(`
       "CREATE SCHEMA IF NOT EXISTS "test-db";
 
-      create table "test-db"."users" ("id" varchar(30) not null unique, "name" text not null, "_internalId" bigserial not null primary key, "_version" integer default 0 not null);
+      create table "test-db"."users" ("id" varchar(128) not null unique, "name" text not null, "_internalId" bigserial not null primary key, "_version" integer default 0 not null);
 
       insert into "fragno_db_settings" ("id", "key", "value") values ('6_U2SCfiaNG9VyYmQ_JwzQ', 'test-db.schema_version', '1');"
     `);
@@ -444,6 +446,61 @@ describe("generateSchemaArtifacts - schema outputs", () => {
     expect(healthSpy).not.toHaveBeenCalled();
   });
 
+  it("should order drizzle schema fragments deterministically by schema name", async () => {
+    const adapter = new SqlAdapter({
+      dialect: {
+        createAdapter: () => new PostgresAdapter(),
+        createDriver: () => new DummyDriver(),
+        createQueryCompiler: () => ({
+          compileQuery: () => ({
+            sql: "",
+            parameters: [],
+          }),
+        }),
+      },
+      driverConfig: new NodePostgresDriverConfig(),
+    });
+
+    const schemaAlpha: AnySchema = schema("alpha", (s) => {
+      return s.addTable("alpha_table", (t) => {
+        return t.addColumn("id", idColumn()).addColumn("name", column("string"));
+      });
+    });
+
+    const schemaBeta: AnySchema = schema("beta", (s) => {
+      return s.addTable("beta_table", (t) => {
+        return t.addColumn("id", idColumn()).addColumn("title", column("string"));
+      });
+    });
+
+    const fragnoDbBeta = new FragnoDatabase({
+      namespace: "alpha",
+      schema: schemaBeta,
+      adapter,
+    });
+
+    const fragnoDbAlpha = new FragnoDatabase({
+      namespace: "zulu",
+      schema: schemaAlpha,
+      adapter,
+    });
+
+    const [result] = await generateSchemaArtifacts([fragnoDbBeta, fragnoDbAlpha], {
+      format: "drizzle",
+    });
+
+    const schemaOutput = result.schema;
+    const internalIndex = schemaOutput.indexOf("Fragment: (none)");
+    const alphaIndex = schemaOutput.indexOf("Fragment: zulu");
+    const betaIndex = schemaOutput.indexOf("Fragment: alpha");
+
+    expect(internalIndex).toBeGreaterThanOrEqual(0);
+    expect(alphaIndex).toBeGreaterThanOrEqual(0);
+    expect(betaIndex).toBeGreaterThanOrEqual(0);
+    expect(internalIndex).toBeLessThan(alphaIndex);
+    expect(alphaIndex).toBeLessThan(betaIndex);
+  });
+
   it("should reject from/to versions for prisma output", async () => {
     const adapter = new SqlAdapter({
       dialect: {

package/src/migration-engine/generation-engine.ts

@@ -1,15 +1,21 @@
-import type { FragnoDatabase } from "../mod";
-import type { AnySchema } from "../schema/create";
+import { instantiate } from "@fragno-dev/core";
+
 import {
   fragnoDatabaseAdapterNameFakeSymbol,
   fragnoDatabaseAdapterVersionFakeSymbol,
 } from "../adapters/adapters";
+import { supportedDatabases, type SupportedDatabase } from "../adapters/generic-sql/driver-config";
+import {
+  internalFragmentDef,
+  internalSchema,
+  SETTINGS_TABLE_NAME,
+  getSchemaVersionFromDatabase,
+} from "../fragments/internal-fragment";
+import { getRegistryForAdapterSync } from "../internal/adapter-registry";
+import type { FragnoDatabase } from "../mod";
 import { generateDrizzleSchema } from "../schema-output/drizzle";
 import { generatePrismaSchema } from "../schema-output/prisma";
-import { internalFragmentDef, getSchemaVersionFromDatabase } from "../fragments/internal-fragment";
-import { internalSchema, SETTINGS_TABLE_NAME } from "../fragments/internal-fragment.schema";
-import { instantiate } from "@fragno-dev/core";
-import { supportedDatabases, type SupportedDatabase } from "../adapters/generic-sql/driver-config";
+import type { AnySchema } from "../schema/create";
 
 export interface GenerationEngineResult {
   schema: string;
@@ -76,7 +82,7 @@ export async function generateSchemaArtifacts<
 
     // Collect all schemas, de-duplicating by namespace.
     // The internal fragment (settings schema) is always included first since all database
-    // fragments automatically link to it via withDatabase().
+    // fragments share it via the adapter registry.
     const fragmentsMap = new Map<string, { schema: AnySchema; namespace: string | null }>();
 
     // Include internal fragment first with empty namespace (settings table has no prefix)
@@ -97,7 +103,22 @@ export async function generateSchemaArtifacts<
       }
     }
 
-    const allFragments = Array.from(fragmentsMap.values());
+    const allFragments = Array.from(fragmentsMap.entries())
+      .map(([namespaceKey, fragment]) => ({
+        ...fragment,
+        namespaceKey,
+        isInternal: fragment.schema === internalSchema,
+      }))
+      .sort((a, b) => {
+        if (a.isInternal) {
+          return -1;
+        }
+        if (b.isInternal) {
+          return 1;
+        }
+        return a.schema.name.localeCompare(b.schema.name);
+      })
+      .map(({ schema, namespace }) => ({ schema, namespace }));
     const defaultPath = format === "drizzle" ? DEFAULT_DRIZZLE_PATH : DEFAULT_PRISMA_PATH;
     const schema =
       format === "drizzle"
@@ -133,7 +154,7 @@ export async function generateSchemaArtifacts<
 
   // Use the internal fragment for settings management
   const internalFragment = instantiate(internalFragmentDef)
-    .withConfig({})
+    .withConfig({ registry: getRegistryForAdapterSync(adapter) })
     .withOptions({ databaseAdapter: adapter, databaseNamespace: null })
     .build();
 
@@ -261,7 +282,7 @@ export async function executeMigrations<const TDatabases extends FragnoDatabase<
   // 1. Prepare settings table migration
   // Use the internal fragment for settings management
   const internalFragment = instantiate(internalFragmentDef)
-    .withConfig({})
+    .withConfig({ registry: getRegistryForAdapterSync(adapter) })
     .withOptions({ databaseAdapter: adapter, databaseNamespace: null })
     .build();
 

package/src/migration-engine/shared.ts

@@ -39,6 +39,19 @@ export interface ColumnInfo {
   default?: { value: unknown } | { dbSpecial: "now" } | { runtime: "cuid" | "now" };
 }
 
+export interface SqliteRecreateTableInfo {
+  columns: ColumnInfo[];
+  copyColumns: SqliteCopyColumn[];
+  indexes: { name: string; columns: string[]; unique: boolean }[];
+  foreignKeys: ForeignKeyInfo[];
+}
+
+export type SqliteCopyColumn = string | { from: string; to: string };
+
+export interface SqliteAlterTableMetadata extends MigrationOperationMetadata {
+  recreateTable?: SqliteRecreateTableInfo;
+}
+
 export type MigrationOperation<
   TMeta extends MigrationOperationMetadata = MigrationOperationMetadata,
 > =