split builder components out

internal/drops/builder.go

@@ -0,0 +1,88 @@
+package drops
+
+import (
+	"dk/internal/database"
+	"fmt"
+
+	"zombiezen.com/go/sqlite"
+)
+
+// Builder provides a fluent interface for creating drops
+type Builder struct {
+	drop *Drop
+	db   *database.DB
+}
+
+// NewBuilder creates a new drop builder
+func NewBuilder(db *database.DB) *Builder {
+	return &Builder{
+		drop: &Drop{db: db},
+		db:   db,
+	}
+}
+
+// WithName sets the drop name
+func (b *Builder) WithName(name string) *Builder {
+	b.drop.Name = name
+	return b
+}
+
+// WithLevel sets the drop level requirement
+func (b *Builder) WithLevel(level int) *Builder {
+	b.drop.Level = level
+	return b
+}
+
+// WithType sets the drop type
+func (b *Builder) WithType(dropType int) *Builder {
+	b.drop.Type = dropType
+	return b
+}
+
+// WithAtt sets the attributes
+func (b *Builder) WithAtt(att string) *Builder {
+	b.drop.Att = att
+	return b
+}
+
+// Create saves the drop to the database and returns it
+func (b *Builder) Create() (*Drop, error) {
+	// Use a transaction to ensure we can get the ID
+	var drop *Drop
+	err := b.db.Transaction(func(tx *database.Tx) error {
+		query := `INSERT INTO drops (name, level, type, att) 
+		          VALUES (?, ?, ?, ?)`
+
+		if err := tx.Exec(query, b.drop.Name, b.drop.Level, b.drop.Type, b.drop.Att); err != nil {
+			return fmt.Errorf("failed to insert drop: %w", err)
+		}
+
+		// Get the last inserted ID within the same transaction
+		var lastID int
+		err := tx.Query("SELECT last_insert_rowid()", func(stmt *sqlite.Stmt) error {
+			lastID = stmt.ColumnInt(0)
+			return nil
+		})
+		if err != nil {
+			return fmt.Errorf("failed to get last insert ID: %w", err)
+		}
+
+		// Create the drop with the ID
+		drop = &Drop{
+			ID:    lastID,
+			Name:  b.drop.Name,
+			Level: b.drop.Level,
+			Type:  b.drop.Type,
+			Att:   b.drop.Att,
+			db:    b.db,
+		}
+
+		return nil
+	})
+
+	if err != nil {
+		return nil, fmt.Errorf("failed to create drop: %w", err)
+	}
+
+	return drop, nil
+}

internal/drops/drops.go

@@ -124,86 +124,6 @@ func ByType(db *database.DB, dropType int) ([]*Drop, error) {
 	return drops, nil
 }
 
-// Builder provides a fluent interface for creating drops
-type Builder struct {
-	drop *Drop
-	db   *database.DB
-}
-
-// NewBuilder creates a new drop builder
-func NewBuilder(db *database.DB) *Builder {
-	return &Builder{
-		drop: &Drop{db: db},
-		db:   db,
-	}
-}
-
-// WithName sets the drop name
-func (b *Builder) WithName(name string) *Builder {
-	b.drop.Name = name
-	return b
-}
-
-// WithLevel sets the drop level requirement
-func (b *Builder) WithLevel(level int) *Builder {
-	b.drop.Level = level
-	return b
-}
-
-// WithType sets the drop type
-func (b *Builder) WithType(dropType int) *Builder {
-	b.drop.Type = dropType
-	return b
-}
-
-// WithAtt sets the attributes
-func (b *Builder) WithAtt(att string) *Builder {
-	b.drop.Att = att
-	return b
-}
-
-// Create saves the drop to the database and returns it
-func (b *Builder) Create() (*Drop, error) {
-	// Use a transaction to ensure we can get the ID
-	var drop *Drop
-	err := b.db.Transaction(func(tx *database.Tx) error {
-		query := `INSERT INTO drops (name, level, type, att) 
-		          VALUES (?, ?, ?, ?)`
-
-		if err := tx.Exec(query, b.drop.Name, b.drop.Level, b.drop.Type, b.drop.Att); err != nil {
-			return fmt.Errorf("failed to insert drop: %w", err)
-		}
-
-		// Get the last inserted ID within the same transaction
-		var lastID int
-		err := tx.Query("SELECT last_insert_rowid()", func(stmt *sqlite.Stmt) error {
-			lastID = stmt.ColumnInt(0)
-			return nil
-		})
-		if err != nil {
-			return fmt.Errorf("failed to get last insert ID: %w", err)
-		}
-
-		// Create the drop with the ID
-		drop = &Drop{
-			ID:    lastID,
-			Name:  b.drop.Name,
-			Level: b.drop.Level,
-			Type:  b.drop.Type,
-			Att:   b.drop.Att,
-			db:    b.db,
-		}
-
-		return nil
-	})
-
-	if err != nil {
-		return nil, fmt.Errorf("failed to create drop: %w", err)
-	}
-
-	return drop, nil
-}
-
 // Save updates an existing drop in the database
 func (d *Drop) Save() error {
 	if d.ID == 0 {

internal/items/builder.go

@@ -0,0 +1,95 @@
+package items
+
+import (
+	"dk/internal/database"
+	"fmt"
+
+	"zombiezen.com/go/sqlite"
+)
+
+// Builder provides a fluent interface for creating items
+type Builder struct {
+	item *Item
+	db   *database.DB
+}
+
+// NewBuilder creates a new item builder
+func NewBuilder(db *database.DB) *Builder {
+	return &Builder{
+		item: &Item{db: db},
+		db:   db,
+	}
+}
+
+// WithType sets the item type
+func (b *Builder) WithType(itemType int) *Builder {
+	b.item.Type = itemType
+	return b
+}
+
+// WithName sets the item name
+func (b *Builder) WithName(name string) *Builder {
+	b.item.Name = name
+	return b
+}
+
+// WithValue sets the item value
+func (b *Builder) WithValue(value int) *Builder {
+	b.item.Value = value
+	return b
+}
+
+// WithAtt sets the item attack/defense value
+func (b *Builder) WithAtt(att int) *Builder {
+	b.item.Att = att
+	return b
+}
+
+// WithSpecial sets the item special attributes
+func (b *Builder) WithSpecial(special string) *Builder {
+	b.item.Special = special
+	return b
+}
+
+// Create saves the item to the database and returns it
+func (b *Builder) Create() (*Item, error) {
+	// Use a transaction to ensure we can get the ID
+	var item *Item
+	err := b.db.Transaction(func(tx *database.Tx) error {
+		query := `INSERT INTO items (type, name, value, att, special) 
+		          VALUES (?, ?, ?, ?, ?)`
+
+		if err := tx.Exec(query, b.item.Type, b.item.Name, b.item.Value, b.item.Att, b.item.Special); err != nil {
+			return fmt.Errorf("failed to insert item: %w", err)
+		}
+
+		// Get the last inserted ID within the same transaction
+		var lastID int
+		err := tx.Query("SELECT last_insert_rowid()", func(stmt *sqlite.Stmt) error {
+			lastID = stmt.ColumnInt(0)
+			return nil
+		})
+		if err != nil {
+			return fmt.Errorf("failed to get last insert ID: %w", err)
+		}
+
+		// Create the item with the ID
+		item = &Item{
+			ID:      lastID,
+			Type:    b.item.Type,
+			Name:    b.item.Name,
+			Value:   b.item.Value,
+			Att:     b.item.Att,
+			Special: b.item.Special,
+			db:      b.db,
+		}
+
+		return nil
+	})
+
+	if err != nil {
+		return nil, fmt.Errorf("failed to create item: %w", err)
+	}
+
+	return item, nil
+}

internal/items/items.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 
 	"dk/internal/database"
+
 	"zombiezen.com/go/sqlite"
 )
 
@@ -104,93 +105,6 @@ func ByType(db *database.DB, itemType int) ([]*Item, error) {
 	return items, nil
 }
 
-// Builder provides a fluent interface for creating items
-type Builder struct {
-	item *Item
-	db   *database.DB
-}
-
-// NewBuilder creates a new item builder
-func NewBuilder(db *database.DB) *Builder {
-	return &Builder{
-		item: &Item{db: db},
-		db:   db,
-	}
-}
-
-// WithType sets the item type
-func (b *Builder) WithType(itemType int) *Builder {
-	b.item.Type = itemType
-	return b
-}
-
-// WithName sets the item name
-func (b *Builder) WithName(name string) *Builder {
-	b.item.Name = name
-	return b
-}
-
-// WithValue sets the item value
-func (b *Builder) WithValue(value int) *Builder {
-	b.item.Value = value
-	return b
-}
-
-// WithAtt sets the item attack/defense value
-func (b *Builder) WithAtt(att int) *Builder {
-	b.item.Att = att
-	return b
-}
-
-// WithSpecial sets the item special attributes
-func (b *Builder) WithSpecial(special string) *Builder {
-	b.item.Special = special
-	return b
-}
-
-// Create saves the item to the database and returns it
-func (b *Builder) Create() (*Item, error) {
-	// Use a transaction to ensure we can get the ID
-	var item *Item
-	err := b.db.Transaction(func(tx *database.Tx) error {
-		query := `INSERT INTO items (type, name, value, att, special) 
-		          VALUES (?, ?, ?, ?, ?)`
-		
-		if err := tx.Exec(query, b.item.Type, b.item.Name, b.item.Value, b.item.Att, b.item.Special); err != nil {
-			return fmt.Errorf("failed to insert item: %w", err)
-		}
-		
-		// Get the last inserted ID within the same transaction
-		var lastID int
-		err := tx.Query("SELECT last_insert_rowid()", func(stmt *sqlite.Stmt) error {
-			lastID = stmt.ColumnInt(0)
-			return nil
-		})
-		if err != nil {
-			return fmt.Errorf("failed to get last insert ID: %w", err)
-		}
-		
-		// Create the item with the ID
-		item = &Item{
-			ID:      lastID,
-			Type:    b.item.Type,
-			Name:    b.item.Name,
-			Value:   b.item.Value,
-			Att:     b.item.Att,
-			Special: b.item.Special,
-			db:      b.db,
-		}
-		
-		return nil
-	})
-	
-	if err != nil {
-		return nil, fmt.Errorf("failed to create item: %w", err)
-	}
-	
-	return item, nil
-}
-
 // Save updates an existing item in the database
 func (i *Item) Save() error {
 	if i.ID == 0 {

internal/monsters/builder.go

@@ -0,0 +1,117 @@
+package monsters
+
+import (
+	"dk/internal/database"
+	"fmt"
+
+	"zombiezen.com/go/sqlite"
+)
+
+// Builder provides a fluent interface for creating monsters
+type Builder struct {
+	monster *Monster
+	db      *database.DB
+}
+
+// NewBuilder creates a new monster builder
+func NewBuilder(db *database.DB) *Builder {
+	return &Builder{
+		monster: &Monster{db: db},
+		db:      db,
+	}
+}
+
+// WithName sets the monster name
+func (b *Builder) WithName(name string) *Builder {
+	b.monster.Name = name
+	return b
+}
+
+// WithMaxHP sets the monster's maximum hit points
+func (b *Builder) WithMaxHP(maxHP int) *Builder {
+	b.monster.MaxHP = maxHP
+	return b
+}
+
+// WithMaxDmg sets the monster's maximum damage
+func (b *Builder) WithMaxDmg(maxDmg int) *Builder {
+	b.monster.MaxDmg = maxDmg
+	return b
+}
+
+// WithArmor sets the monster's armor value
+func (b *Builder) WithArmor(armor int) *Builder {
+	b.monster.Armor = armor
+	return b
+}
+
+// WithLevel sets the monster's level
+func (b *Builder) WithLevel(level int) *Builder {
+	b.monster.Level = level
+	return b
+}
+
+// WithMaxExp sets the monster's maximum experience reward
+func (b *Builder) WithMaxExp(maxExp int) *Builder {
+	b.monster.MaxExp = maxExp
+	return b
+}
+
+// WithMaxGold sets the monster's maximum gold reward
+func (b *Builder) WithMaxGold(maxGold int) *Builder {
+	b.monster.MaxGold = maxGold
+	return b
+}
+
+// WithImmunity sets the monster's immunity type
+func (b *Builder) WithImmunity(immunity int) *Builder {
+	b.monster.Immune = immunity
+	return b
+}
+
+// Create saves the monster to the database and returns it
+func (b *Builder) Create() (*Monster, error) {
+	// Use a transaction to ensure we can get the ID
+	var monster *Monster
+	err := b.db.Transaction(func(tx *database.Tx) error {
+		query := `INSERT INTO monsters (name, max_hp, max_dmg, armor, level, max_exp, max_gold, immune) 
+		          VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
+
+		if err := tx.Exec(query, b.monster.Name, b.monster.MaxHP, b.monster.MaxDmg, b.monster.Armor,
+			b.monster.Level, b.monster.MaxExp, b.monster.MaxGold, b.monster.Immune); err != nil {
+			return fmt.Errorf("failed to insert monster: %w", err)
+		}
+
+		// Get the last inserted ID within the same transaction
+		var lastID int
+		err := tx.Query("SELECT last_insert_rowid()", func(stmt *sqlite.Stmt) error {
+			lastID = stmt.ColumnInt(0)
+			return nil
+		})
+		if err != nil {
+			return fmt.Errorf("failed to get last insert ID: %w", err)
+		}
+
+		// Create the monster with the ID
+		monster = &Monster{
+			ID:      lastID,
+			Name:    b.monster.Name,
+			MaxHP:   b.monster.MaxHP,
+			MaxDmg:  b.monster.MaxDmg,
+			Armor:   b.monster.Armor,
+			Level:   b.monster.Level,
+			MaxExp:  b.monster.MaxExp,
+			MaxGold: b.monster.MaxGold,
+			Immune:  b.monster.Immune,
+			db:      b.db,
+		}
+
+		return nil
+	})
+
+	if err != nil {
+		return nil, fmt.Errorf("failed to create monster: %w", err)
+	}
+
+	return monster, nil
+}

internal/monsters/monsters.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 
 	"dk/internal/database"
+
 	"zombiezen.com/go/sqlite"
 )
 
@@ -24,9 +25,9 @@ type Monster struct {
 
 // Immunity constants for monster immunity types
 const (
-	ImmuneNone   = 0
+	ImmuneNone  = 0
-	ImmuneHurt   = 1  // Immune to Hurt spells
+	ImmuneHurt  = 1 // Immune to Hurt spells
-	ImmuneSleep  = 2  // Immune to Sleep spells
+	ImmuneSleep = 2 // Immune to Sleep spells
 )
 
 // Find retrieves a monster by ID
@@ -174,115 +175,6 @@ func ByImmunity(db *database.DB, immunityType int) ([]*Monster, error) {
 	return monsters, nil
 }
 
-// Builder provides a fluent interface for creating monsters
-type Builder struct {
-	monster *Monster
-	db      *database.DB
-}
-
-// NewBuilder creates a new monster builder
-func NewBuilder(db *database.DB) *Builder {
-	return &Builder{
-		monster: &Monster{db: db},
-		db:      db,
-	}
-}
-
-// WithName sets the monster name
-func (b *Builder) WithName(name string) *Builder {
-	b.monster.Name = name
-	return b
-}
-
-// WithMaxHP sets the monster's maximum hit points
-func (b *Builder) WithMaxHP(maxHP int) *Builder {
-	b.monster.MaxHP = maxHP
-	return b
-}
-
-// WithMaxDmg sets the monster's maximum damage
-func (b *Builder) WithMaxDmg(maxDmg int) *Builder {
-	b.monster.MaxDmg = maxDmg
-	return b
-}
-
-// WithArmor sets the monster's armor value
-func (b *Builder) WithArmor(armor int) *Builder {
-	b.monster.Armor = armor
-	return b
-}
-
-// WithLevel sets the monster's level
-func (b *Builder) WithLevel(level int) *Builder {
-	b.monster.Level = level
-	return b
-}
-
-// WithMaxExp sets the monster's maximum experience reward
-func (b *Builder) WithMaxExp(maxExp int) *Builder {
-	b.monster.MaxExp = maxExp
-	return b
-}
-
-// WithMaxGold sets the monster's maximum gold reward
-func (b *Builder) WithMaxGold(maxGold int) *Builder {
-	b.monster.MaxGold = maxGold
-	return b
-}
-
-// WithImmunity sets the monster's immunity type
-func (b *Builder) WithImmunity(immunity int) *Builder {
-	b.monster.Immune = immunity
-	return b
-}
-
-// Create saves the monster to the database and returns it
-func (b *Builder) Create() (*Monster, error) {
-	// Use a transaction to ensure we can get the ID
-	var monster *Monster
-	err := b.db.Transaction(func(tx *database.Tx) error {
-		query := `INSERT INTO monsters (name, max_hp, max_dmg, armor, level, max_exp, max_gold, immune) 
-		          VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
-		
-		if err := tx.Exec(query, b.monster.Name, b.monster.MaxHP, b.monster.MaxDmg, b.monster.Armor, 
-			b.monster.Level, b.monster.MaxExp, b.monster.MaxGold, b.monster.Immune); err != nil {
-			return fmt.Errorf("failed to insert monster: %w", err)
-		}
-		
-		// Get the last inserted ID within the same transaction
-		var lastID int
-		err := tx.Query("SELECT last_insert_rowid()", func(stmt *sqlite.Stmt) error {
-			lastID = stmt.ColumnInt(0)
-			return nil
-		})
-		if err != nil {
-			return fmt.Errorf("failed to get last insert ID: %w", err)
-		}
-		
-		// Create the monster with the ID
-		monster = &Monster{
-			ID:      lastID,
-			Name:    b.monster.Name,
-			MaxHP:   b.monster.MaxHP,
-			MaxDmg:  b.monster.MaxDmg,
-			Armor:   b.monster.Armor,
-			Level:   b.monster.Level,
-			MaxExp:  b.monster.MaxExp,
-			MaxGold: b.monster.MaxGold,
-			Immune:  b.monster.Immune,
-			db:      b.db,
-		}
-		
-		return nil
-	})
-	
-	if err != nil {
-		return nil, fmt.Errorf("failed to create monster: %w", err)
-	}
-	
-	return monster, nil
-}
-
 // Save updates an existing monster in the database
 func (m *Monster) Save() error {
 	if m.ID == 0 {