@fragno-dev/db 0.0.1 → 0.1.0

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

@@ -20,14 +20,17 @@ describe("generateMigrationFromSchema", () => {
     // Version 0 -> 1: users table created
     // Version 1 -> 2: posts table created
     // We want to generate the migration for version 1 -> 2
-    const operations = generateMigrationFromSchema(mySchema, 1, 2, {
-      provider: "postgresql",
-    });
+    const operations = generateMigrationFromSchema(mySchema, 1, 2);
 
     expect(operations).toHaveLength(1);
     expect(operations[0]).toMatchObject({
       type: "create-table",
-      value: mySchema.tables.posts,
+      name: "posts",
+      columns: expect.arrayContaining([
+        expect.objectContaining({ name: "id" }),
+        expect.objectContaining({ name: "title" }),
+        expect.objectContaining({ name: "content" }),
+      ]),
     });
   });
 
@@ -46,22 +49,32 @@ describe("generateMigrationFromSchema", () => {
     });
 
     // Generate migrations from version 0 to 3 (all three tables)
-    const operations = generateMigrationFromSchema(mySchema, 0, 3, {
-      provider: "postgresql",
-    });
+    const operations = generateMigrationFromSchema(mySchema, 0, 3);
 
     expect(operations).toHaveLength(3);
     expect(operations[0]).toMatchObject({
       type: "create-table",
-      value: mySchema.tables.users,
+      name: "users",
+      columns: expect.arrayContaining([
+        expect.objectContaining({ name: "id" }),
+        expect.objectContaining({ name: "name" }),
+      ]),
     });
     expect(operations[1]).toMatchObject({
       type: "create-table",
-      value: mySchema.tables.posts,
+      name: "posts",
+      columns: expect.arrayContaining([
+        expect.objectContaining({ name: "id" }),
+        expect.objectContaining({ name: "title" }),
+      ]),
     });
     expect(operations[2]).toMatchObject({
       type: "create-table",
-      value: mySchema.tables.comments,
+      name: "comments",
+      columns: expect.arrayContaining([
+        expect.objectContaining({ name: "id" }),
+        expect.objectContaining({ name: "text" }),
+      ]),
     });
   });
 
@@ -74,19 +87,17 @@ describe("generateMigrationFromSchema", () => {
         .addTable("posts", (t) => {
           return t.addColumn("id", idColumn()).addColumn("authorId", referenceColumn());
         })
-        .addReference("posts", "author", {
-          columns: ["authorId"],
-          targetTable: "users",
-          targetColumns: ["id"],
+        .addReference("author", {
+          type: "one",
+          from: { table: "posts", column: "authorId" },
+          to: { table: "users", column: "id" },
         });
     });
 
     // Version 0 -> 1: users table
     // Version 1 -> 2: posts table
     // Version 2 -> 3: author foreign key
-    const operations = generateMigrationFromSchema(mySchema, 2, 3, {
-      provider: "postgresql",
-    });
+    const operations = generateMigrationFromSchema(mySchema, 2, 3);
 
     expect(operations).toHaveLength(1);
     expect(operations[0]).toMatchObject({
@@ -98,32 +109,29 @@ describe("generateMigrationFromSchema", () => {
     if (fkOp.type === "add-foreign-key") {
       expect(fkOp.value).toMatchObject({
         name: "posts_users_author_fk",
-        table: "posts",
         referencedTable: "users",
         columns: ["authorId"],
-        referencedColumns: ["id"],
+        referencedColumns: ["_internalId"],
       });
     }
   });
 
-  it("should generate add-index operation for indexes defined in createIndex", () => {
+  it("should generate add-index operation for indexes added via alterTable", () => {
     const mySchema = schema((s) => {
-      return s.addTable("users", (t) => {
-        return t
-          .addColumn("id", idColumn())
-          .addColumn("email", column("string"))
-          .createIndex("idx_email", ["email"], { unique: true });
-      });
+      return s
+        .addTable("users", (t) => {
+          return t.addColumn("id", idColumn()).addColumn("email", column("string"));
+        })
+        .alterTable("users", (t) => {
+          return t.createIndex("idx_email", ["email"], { unique: true });
+        });
     });
 
-    // Version 0 -> 1: users table
-    // Version 1 -> 2: email index
-    const operations = generateMigrationFromSchema(mySchema, 1, 2, {
-      provider: "postgresql",
-    });
+    const operations = generateMigrationFromSchema(mySchema, 0, 2);
 
-    expect(operations).toHaveLength(1);
-    expect(operations[0]).toMatchObject({
+    expect(operations).toHaveLength(2);
+    expect(operations[0].type).toBe("create-table");
+    expect(operations[1]).toMatchObject({
       type: "add-index",
       table: "users",
       name: "idx_email",
@@ -141,17 +149,15 @@ describe("generateMigrationFromSchema", () => {
         .addTable("posts", (t) => {
           return t.addColumn("id", idColumn()).addColumn("authorId", referenceColumn());
         })
-        .addReference("posts", "author", {
-          columns: ["authorId"],
-          targetTable: "users",
-          targetColumns: ["id"],
+        .addReference("author", {
+          type: "one",
+          from: { table: "posts", column: "authorId" },
+          to: { table: "users", column: "id" },
         });
     });
 
     // Generate all migrations from scratch
-    const operations = generateMigrationFromSchema(mySchema, 0, 3, {
-      provider: "postgresql",
-    });
+    const operations = generateMigrationFromSchema(mySchema, 0, 3);
 
     expect(operations).toHaveLength(3);
     expect(operations[0].type).toBe("create-table");
@@ -163,25 +169,23 @@ describe("generateMigrationFromSchema", () => {
     const mySchema = schema((s) => {
       return s
         .addTable("users", (t) => {
-          return t
-            .addColumn("id", idColumn())
-            .addColumn("email", column("string"))
-            .createIndex("idx_email", ["email"], { unique: true });
+          return t.addColumn("id", idColumn()).addColumn("email", column("string"));
+        })
+        .alterTable("users", (t) => {
+          return t.createIndex("idx_email", ["email"], { unique: true });
         })
         .addTable("posts", (t) => {
           return t.addColumn("id", idColumn()).addColumn("authorId", referenceColumn());
         })
-        .addReference("posts", "author", {
-          columns: ["authorId"],
-          targetTable: "users",
-          targetColumns: ["id"],
+        .addReference("author", {
+          type: "one",
+          from: { table: "posts", column: "authorId" },
+          to: { table: "users", column: "id" },
         });
     });
 
     // Generate all migrations from scratch
-    const operations = generateMigrationFromSchema(mySchema, 0, 4, {
-      provider: "postgresql",
-    });
+    const operations = generateMigrationFromSchema(mySchema, 0, 4);
 
     expect(operations).toHaveLength(4);
     expect(operations[0].type).toBe("create-table");
@@ -197,9 +201,7 @@ describe("generateMigrationFromSchema", () => {
       });
     });
 
-    const operations = generateMigrationFromSchema(mySchema, 1, 1, {
-      provider: "postgresql",
-    });
+    const operations = generateMigrationFromSchema(mySchema, 1, 1);
 
     expect(operations).toHaveLength(0);
   });
@@ -208,7 +210,7 @@ describe("generateMigrationFromSchema", () => {
     const mySchema = schema((s) => s.addTable("users", (t) => t.addColumn("id", idColumn())));
 
     expect(() => {
-      generateMigrationFromSchema(mySchema, 999, 1000, { provider: "postgresql" });
+      generateMigrationFromSchema(mySchema, 999, 1000);
     }).toThrow("fromVersion (999) exceeds schema version (1)");
   });
 
@@ -216,7 +218,7 @@ describe("generateMigrationFromSchema", () => {
     const mySchema = schema((s) => s.addTable("users", (t) => t.addColumn("id", idColumn())));
 
     expect(() => {
-      generateMigrationFromSchema(mySchema, 0, 999, { provider: "postgresql" });
+      generateMigrationFromSchema(mySchema, 0, 999);
     }).toThrow("toVersion (999) exceeds schema version (1)");
   });
 
@@ -224,7 +226,7 @@ describe("generateMigrationFromSchema", () => {
     const mySchema = schema((s) => s.addTable("users", (t) => t.addColumn("id", idColumn())));
 
     expect(() => {
-      generateMigrationFromSchema(mySchema, 1, 0, { provider: "postgresql" });
+      generateMigrationFromSchema(mySchema, 1, 0);
     }).toThrow("Cannot migrate backwards");
   });
 
@@ -232,7 +234,65 @@ describe("generateMigrationFromSchema", () => {
     const mySchema = schema((s) => s.addTable("users", (t) => t.addColumn("id", idColumn())));
 
     expect(() => {
-      generateMigrationFromSchema(mySchema, -1, 1, { provider: "postgresql" });
+      generateMigrationFromSchema(mySchema, -1, 1);
     }).toThrow("fromVersion cannot be negative");
   });
+
+  it("should only create constraints for references, not for referenceColumns", () => {
+    const mySchema = schema((s) => {
+      return s
+        .addTable("posts", (t) => {
+          return t
+            .addColumn("id", idColumn().defaultTo("auto"))
+            .addColumn("title", column("string"))
+            .addColumn("content", column("string"))
+            .addColumn("userId", referenceColumn());
+        })
+        .addTable("users", (t) => {
+          return t
+            .addColumn("id", idColumn().defaultTo("auto"))
+            .addColumn("name", column("string"));
+        })
+        .addReference("author", {
+          type: "one",
+          from: { table: "posts", column: "userId" },
+          to: { table: "users", column: "id" },
+        })
+        .alterTable("posts", (t) => {
+          return t
+            .addColumn("summary", column("string").nullable())
+            .createIndex("idx_title", ["title"]);
+        });
+    });
+
+    const operations = generateMigrationFromSchema(mySchema, 0, mySchema.version);
+    expect(operations.map((o) => o.type)).toEqual([
+      "create-table",
+      "create-table",
+      "add-foreign-key",
+      "alter-table",
+      "add-index",
+    ]);
+  });
+
+  it("should not create duplicate foreign key constraints", () => {
+    const mySchema = schema((s) => {
+      return s
+        .addTable("users", (t) => t.addColumn("id", idColumn()))
+        .addTable("posts", (t) =>
+          t.addColumn("id", idColumn()).addColumn("userId", referenceColumn()),
+        )
+        .addReference("author", {
+          type: "one",
+          from: { table: "posts", column: "userId" },
+          to: { table: "users", column: "id" },
+        });
+    });
+
+    const operations = generateMigrationFromSchema(mySchema, 0, mySchema.version);
+
+    // Count foreign key operations
+    const fkOps = operations.filter((op) => op.type === "add-foreign-key");
+    expect(fkOps).toHaveLength(1); // Should be exactly one, not two
+  });
 });

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

@@ -1,6 +1,5 @@
-import { compileForeignKey, type AnySchema } from "../schema/create";
-import type { MigrationOperation } from "./shared";
-import type { Provider } from "../shared/providers";
+import { type AnySchema } from "../schema/create";
+import type { MigrationOperation, ColumnInfo } from "./shared";
 
 /**
  * Generate migration operations from a schema's operation history
@@ -23,18 +22,13 @@ import type { Provider } from "../shared/providers";
  * );
  *
  * // Generate operations from version 0 to 1 (only creates users table)
- * const operations = generateMigrationFromSchema(mySchema, 0, 1, {
- *   provider: "postgresql"
- * });
+ * const operations = generateMigrationFromSchema(mySchema, 0, 1);
  * ```
  */
 export function generateMigrationFromSchema(
   targetSchema: AnySchema,
   fromVersion: number,
   toVersion: number,
-  _options: {
-    provider: Provider;
-  },
 ): MigrationOperation[] {
   if (fromVersion < 0) {
     throw new Error(`fromVersion cannot be negative: ${fromVersion}`);
@@ -65,39 +59,116 @@ export function generateMigrationFromSchema(
 
   for (const op of relevantOperations) {
     if (op.type === "add-table") {
+      // Collect columns for create-table operation
+      const columns: ColumnInfo[] = [];
+
+      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: "value" in col.default ? col.default.value : undefined,
+                  runtime:
+                    "runtime" in col.default
+                      ? typeof col.default.runtime === "string"
+                        ? col.default.runtime
+                        : undefined
+                      : undefined,
+                }
+              : undefined,
+          });
+        }
+      }
+
       migrationOperations.push({
         type: "create-table",
-        value: op.table,
+        name: op.tableName,
+        columns,
       });
-    } else if (op.type === "add-reference") {
-      const table = targetSchema.tables[op.tableName];
-      if (!table) {
-        throw new Error(`Table ${op.tableName} not found in schema`);
-      }
 
-      // Find the foreign key that matches this reference
-      const foreignKey = table.foreignKeys.find(
-        (fk) => fk.name === `${op.tableName}_${op.config.targetTable}_${op.referenceName}_fk`,
-      );
+      // Add indexes and foreign keys as separate operations
+      for (const subOp of op.operations) {
+        if (subOp.type === "add-index") {
+          migrationOperations.push({
+            type: "add-index",
+            table: op.tableName,
+            name: subOp.name,
+            columns: subOp.columns,
+            unique: subOp.unique,
+          });
+        } else if (subOp.type === "add-foreign-key") {
+          migrationOperations.push({
+            type: "add-foreign-key",
+            table: op.tableName,
+            value: {
+              name: subOp.name,
+              columns: subOp.columns,
+              referencedTable: subOp.referencedTable,
+              referencedColumns: subOp.referencedColumns,
+            },
+          });
+        }
+      }
+    } else if (op.type === "alter-table") {
+      const columnOps = op.operations.filter((o) => o.type === "add-column");
 
-      if (!foreignKey) {
-        throw new Error(
-          `Foreign key for reference ${op.referenceName} not found in table ${op.tableName}`,
-        );
+      if (columnOps.length > 0) {
+        migrationOperations.push({
+          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: "value" in col.default ? col.default.value : undefined,
+                      runtime:
+                        "runtime" in col.default
+                          ? typeof col.default.runtime === "string"
+                            ? col.default.runtime
+                            : undefined
+                          : undefined,
+                    }
+                  : undefined,
+              },
+            };
+          }),
+        });
       }
 
+      // Add indexes as separate operations
+      for (const subOp of op.operations) {
+        if (subOp.type === "add-index") {
+          migrationOperations.push({
+            type: "add-index",
+            table: op.tableName,
+            name: subOp.name,
+            columns: subOp.columns,
+            unique: subOp.unique,
+          });
+        }
+      }
+    } else if (op.type === "add-reference") {
       migrationOperations.push({
         type: "add-foreign-key",
         table: op.tableName,
-        value: compileForeignKey(foreignKey),
-      });
-    } else if (op.type === "add-index") {
-      migrationOperations.push({
-        type: "add-index",
-        table: op.tableName,
-        name: op.name,
-        columns: op.columns,
-        unique: op.unique,
+        value: {
+          name: `${op.tableName}_${op.config.to.table}_${op.referenceName}_fk`,
+          columns: [op.config.from.column],
+          referencedTable: op.config.to.table,
+          referencedColumns: [op.config.to.column],
+        },
       });
     }
   }