Merge pull request #1 from wilburhimself/add_foreign_keys_and_indexes_to_migrations

Enhanced Migration System with Foreign Keys, Indexes, and Batch Support

Author: wilburhimself

README.md

@@ -1,6 +1,6 @@
 # Theory
 
-A lightweight and intuitive ORM for Go, inspired by the original Java version.
+A lightweight and intuitive ORM for Go, inspired by (the original Java version)[https://github.com/wilburhimself/theory_java].
 
 ## Features
 
@@ -197,6 +197,22 @@ func createUserMigration() *migration.Migration {
                 {Name: "name", Type: "TEXT", IsNull: false},
                 {Name: "email", Type: "TEXT", IsNull: true},
             },
+            ForeignKeys: []migration.ForeignKey{
+                {
+                    Columns:      []string{"team_id"},
+                    RefTable:     "teams",
+                    RefColumns:   []string{"id"},
+                    OnDelete:     "CASCADE",
+                    OnUpdate:     "CASCADE",
+                },
+            },
+            Indexes: []migration.Index{
+                {
+                    Name:    "idx_users_email",
+                    Columns: []string{"email"},
+                    Unique:  true,
+                },
+            },
         },
     }
 
@@ -207,13 +223,69 @@ func createUserMigration() *migration.Migration {
 
     return m
 }
+```
+
+#### Running Migrations
+
+Theory provides several ways to run migrations:
+
+```go
+// Create a new migrator
+migrator := migration.NewMigrator(db)
 
-// Add and run migration
-migrator := db.Migrator()
+// Add migrations
 migrator.Add(createUserMigration())
+migrator.Add(createTeamMigration())
+
+// Run all pending migrations in a transaction
 err := migrator.Up()
+if err != nil {
+    panic(err)
+}
+
+// Roll back the last batch of migrations
+err = migrator.Down()
+if err != nil {
+    panic(err)
+}
+
+// Check migration status
+status, err := migrator.Status()
+if err != nil {
+    panic(err)
+}
+for _, s := range status {
+    fmt.Printf("Migration: %s, Applied: %v, Batch: %d\n",
+        s.Migration.Name,
+        s.Applied != nil,
+        s.Batch)
+}
 ```
 
+#### Migration Features
+
+Theory's migration system supports:
+
+- **Foreign Keys**: Define relationships between tables with ON DELETE and ON UPDATE actions
+- **Indexes**: Create and drop indexes, including unique constraints
+- **Batch Migrations**: Run multiple migrations as a single transaction
+- **Rollback Support**: Easily roll back migrations by batch
+- **Migration Status**: Track which migrations have been applied and when
+- **Error Handling**: Robust error handling with descriptive messages
+- **Validation**: Type validation for SQLite column types
+
+#### Migration Operations
+
+Available migration operations:
+
+- `CreateTable`: Create a new table with columns, foreign keys, and indexes
+- `DropTable`: Remove an existing table
+- `AddColumn`: Add a new column to an existing table
+- `ModifyColumn`: Modify an existing column's properties
+- `CreateIndex`: Create a new index on specified columns
+- `DropIndex`: Remove an existing index
+- `AddForeignKey`: Add a new foreign key constraint
+
 ## Error Handling
 
 Theory provides clear error types for common scenarios:

migration/migration.go

@@ -26,8 +26,10 @@ type Operation interface {
 
 // CreateTable operation creates a new table
 type CreateTable struct {
-	Name    string
-	Columns []Column
+	Name       string
+	Columns    []Column
+	ForeignKeys []ForeignKey
+	Indexes    []Index
 }
 
 // Column represents a table column
@@ -40,6 +42,22 @@ type Column struct {
 	MaxLength int
 }
 
+// ForeignKey represents a foreign key constraint
+type ForeignKey struct {
+	Columns      []string
+	RefTable     string
+	RefColumns   []string
+	OnDelete     string // CASCADE, SET NULL, RESTRICT, NO ACTION
+	OnUpdate     string // CASCADE, SET NULL, RESTRICT, NO ACTION
+}
+
+// Index represents a table index
+type Index struct {
+	Name      string
+	Columns   []string
+	IsUnique  bool
+}
+
 // DropTable operation drops a table
 type DropTable struct {
 	Name string
@@ -64,6 +82,30 @@ type ModifyColumn struct {
 	NewColumn Column
 }
 
+// CreateIndex operation creates an index
+type CreateIndex struct {
+	Table  string
+	Index  Index
+}
+
+// DropIndex operation drops an index
+type DropIndex struct {
+	Table string
+	Name  string
+}
+
+// AddForeignKey operation adds a foreign key constraint
+type AddForeignKey struct {
+	Table      string
+	ForeignKey ForeignKey
+}
+
+// DropForeignKey operation drops a foreign key constraint
+type DropForeignKey struct {
+	Table string
+	Name  string
+}
+
 // SQL generates SQL for CreateTable operation
 func (op *CreateTable) SQL() string {
 	var cols []string
@@ -81,7 +123,41 @@ func (op *CreateTable) SQL() string {
 		}
 		cols = append(cols, def)
 	}
-	return fmt.Sprintf("CREATE TABLE %s (\n\t%s\n)", op.Name, strings.Join(cols, ",\n\t"))
+
+	// Add foreign key constraints
+	for _, fk := range op.ForeignKeys {
+		def := fmt.Sprintf("FOREIGN KEY (%s) REFERENCES %s (%s)",
+			strings.Join(fk.Columns, ", "),
+			fk.RefTable,
+			strings.Join(fk.RefColumns, ", "))
+		
+		if fk.OnDelete != "" {
+			def += fmt.Sprintf(" ON DELETE %s", fk.OnDelete)
+		}
+		if fk.OnUpdate != "" {
+			def += fmt.Sprintf(" ON UPDATE %s", fk.OnUpdate)
+		}
+		cols = append(cols, def)
+	}
+
+	sql := fmt.Sprintf("CREATE TABLE %s (\n\t%s\n)", op.Name, strings.Join(cols, ",\n\t"))
+
+	// Create indexes
+	var indexes []string
+	for _, idx := range op.Indexes {
+		idxSQL := fmt.Sprintf("CREATE %sINDEX %s ON %s (%s)",
+			map[bool]string{true: "UNIQUE ", false: ""}[idx.IsUnique],
+			idx.Name,
+			op.Name,
+			strings.Join(idx.Columns, ", "))
+		indexes = append(indexes, idxSQL)
+	}
+
+	if len(indexes) > 0 {
+		sql += ";\n" + strings.Join(indexes, ";\n")
+	}
+
+	return sql
 }
 
 func (c *CreateTable) Args() []interface{} {
@@ -128,6 +204,61 @@ func (m *ModifyColumn) Args() []interface{} {
 	return nil
 }
 
+// SQL generates SQL for CreateIndex operation
+func (c *CreateIndex) SQL() string {
+	return fmt.Sprintf("CREATE %sINDEX %s ON %s (%s)",
+		map[bool]string{true: "UNIQUE ", false: ""}[c.Index.IsUnique],
+		c.Index.Name,
+		c.Table,
+		strings.Join(c.Index.Columns, ", "))
+}
+
+func (c *CreateIndex) Args() []interface{} {
+	return nil
+}
+
+// SQL generates SQL for DropIndex operation
+func (d *DropIndex) SQL() string {
+	return fmt.Sprintf("DROP INDEX %s", d.Name)
+}
+
+func (d *DropIndex) Args() []interface{} {
+	return nil
+}
+
+// SQL generates SQL for AddForeignKey operation
+func (a *AddForeignKey) SQL() string {
+	sql := fmt.Sprintf("ALTER TABLE %s ADD CONSTRAINT %s_%s_fk FOREIGN KEY (%s) REFERENCES %s (%s)",
+		a.Table,
+		a.Table,
+		strings.Join(a.ForeignKey.Columns, "_"),
+		strings.Join(a.ForeignKey.Columns, ", "),
+		a.ForeignKey.RefTable,
+		strings.Join(a.ForeignKey.RefColumns, ", "))
+
+	if a.ForeignKey.OnDelete != "" {
+		sql += fmt.Sprintf(" ON DELETE %s", a.ForeignKey.OnDelete)
+	}
+	if a.ForeignKey.OnUpdate != "" {
+		sql += fmt.Sprintf(" ON UPDATE %s", a.ForeignKey.OnUpdate)
+	}
+
+	return sql
+}
+
+func (a *AddForeignKey) Args() []interface{} {
+	return nil
+}
+
+// SQL generates SQL for DropForeignKey operation
+func (d *DropForeignKey) SQL() string {
+	return fmt.Sprintf("ALTER TABLE %s DROP CONSTRAINT %s", d.Table, d.Name)
+}
+
+func (d *DropForeignKey) Args() []interface{} {
+	return nil
+}
+
 // NewMigration creates a new migration with the given name
 func NewMigration(name string) *Migration {
 	return &Migration{