How to Migrate a Go 1.22 App to Go 1.24 with New Generics Features

package main

import (
    "context"
    "database/sql"
    "errors"
    "fmt"
    "log"
    "time"

    _ "github.com/lib/pq"
)

// ErrNotFound is returned when a record does not exist in the database.
var ErrNotFound = errors.New("record not found")

// Entity is a constraint for types that can be stored in the repository.
// Go 1.22 only supports interface type sets for constraints, no union types.
type Entity interface {
    // GetID returns the unique identifier for the entity.
    GetID() string
    // Validate checks if the entity fields are valid before persistence.
    Validate() error
}

// Repository is a generic repository for CRUD operations on Entity types.
// Go 1.22 requires explicit type parameters for all methods, no inference for multi-arg calls.
type Repository[T Entity] struct {
    db *sql.DB
}

// NewRepository initializes a new generic repository with a database connection.
func NewRepository[T Entity](db *sql.DB) *Repository[T] {
    return &Repository[T]{db: db}
}

// Get retrieves an entity by its ID from the database.
func (r *Repository[T]) Get(ctx context.Context, id string) (T, error) {
    var zero T
    query := `SELECT id, data FROM entities WHERE id = $1`
    row := r.db.QueryRowContext(ctx, query, id)

    var data []byte
    if err := row.Scan(&id, &data); err != nil {
        if errors.Is(err, sql.ErrNoRows) {
            return zero, fmt.Errorf("%w: id %s", ErrNotFound, id)
        }
        return zero, fmt.Errorf("failed to scan entity: %w", err)
    }

    // In Go 1.22, we need explicit type assertion here even for generic types.
    // This is a common pain point fixed in Go 1.24.
    entity, ok := any(zero).(T)
    if !ok {
        return zero, errors.New("failed to type assert generic entity")
    }
    // Mock unmarshal for example purposes.
    _ = data
    return entity, nil
}

// Create inserts a new entity into the database.
func (r *Repository[T]) Create(ctx context.Context, entity T) error {
    if err := entity.Validate(); err != nil {
        return fmt.Errorf("invalid entity: %w", err)
    }
    query := `INSERT INTO entities (id, data) VALUES ($1, $2)`
    // Mock marshal for example purposes.
    data := []byte("mock data")
    _, err := r.db.ExecContext(ctx, query, entity.GetID(), data)
    if err != nil {
        return fmt.Errorf("failed to create entity: %w", err)
    }
    return nil
}

// Update modifies an existing entity in the database.
func (r *Repository[T]) Update(ctx context.Context, entity T) error {
    if err := entity.Validate(); err != nil {
        return fmt.Errorf("invalid entity: %w", err)
    }
    query := `UPDATE entities SET data = $2 WHERE id = $1`
    // Mock marshal for example purposes.
    data := []byte("mock updated data")
    result, err := r.db.ExecContext(ctx, query, entity.GetID(), data)
    if err != nil {
        return fmt.Errorf("failed to update entity: %w", err)
    }
    rowsAffected, err := result.RowsAffected()
    if err != nil {
        return fmt.Errorf("failed to get rows affected: %w", err)
    }
    if rowsAffected == 0 {
        return fmt.Errorf("%w: id %s", ErrNotFound, entity.GetID())
    }
    return nil
}

// Delete removes an entity by ID from the database.
func (r *Repository[T]) Delete(ctx context.Context, id string) error {
    query := `DELETE FROM entities WHERE id = $1`
    result, err := r.db.ExecContext(ctx, query, id)
    if err != nil {
        return fmt.Errorf("failed to delete entity: %w", err)
    }
    rowsAffected, err := result.RowsAffected()
    if err != nil {
        return fmt.Errorf("failed to get rows affected: %w", err)
    }
    if rowsAffected == 0 {
        return fmt.Errorf("%w: id %s", ErrNotFound, id)
    }
    return nil
}

// User implements the Entity interface for example purposes.
type User struct {
    ID string
}

func (u User) GetID() string { return u.ID }
func (u User) Validate() error {
    if u.ID == "" {
        return errors.New("user ID cannot be empty")
    }
    return nil
}

func main() {
    // Connect to database (mock for example).
    db, err := sql.Open("postgres", "host=localhost port=5432 user=test dbname=test password=test sslmode=disable")
    if err != nil {
        log.Fatalf("Failed to connect to database: %v", err)
    }
    defer db.Close()

    // Initialize generic repository for User type.
    repo := NewRepository[User](db)
    ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
    defer cancel()

    // Create a new user.
    user := User{ID: "user-123"}
    if err := repo.Create(ctx, user); err != nil {
        log.Printf("Failed to create user: %v", err)
    }

    // Retrieve the user.
    retrieved, err := repo.Get(ctx, "user-123")
    if err != nil {
        log.Printf("Failed to get user: %v", err)
    } else {
        fmt.Printf("Retrieved user: %s\n", retrieved.GetID())
    }
}

package main

import (
    "context"
    "database/sql"
    "errors"
    "fmt"
    "log"
    "time"

    _ "github.com/lib/pq"
)

// ErrNotFound is returned when a record does not exist in the database.
var ErrNotFound = errors.New("record not found")

// Entity is a constraint for types that can be stored in the repository.
// Go 1.24 adds support for union type sets in constraints, so we can combine interfaces and concrete types.
type Entity interface {
    ~struct{ ID string } | ~struct{ ID int } // Union type constraint for structs with ID field
    GetID() string
    Validate() error
}

// UserEntity is a constrained generic type alias for Entity types with string IDs.
// Go 1.24 supports constrained type aliases, reducing boilerplate for common constraints.
type UserEntity[T Entity] = T

// BaseEntity is a generic struct with common entity fields, embeddable in Go 1.24.
// Go 1.24 allows direct generic struct embedding, no wrapper needed.
type BaseEntity[T any] struct {
    ID T
}

// GetID returns the ID of the base entity (implements Entity interface for string IDs).
func (b BaseEntity[string]) GetID() string { return b.ID }

// Validate checks if the base entity ID is non-empty.
func (b BaseEntity[string]) Validate() error {
    if b.ID == "" {
        return errors.New("entity ID cannot be empty")
    }
    return nil
}

// Repository is a generic repository for CRUD operations on Entity types.
// Go 1.24 supports full type inference for multi-arg method calls, no explicit type args needed.
type Repository[T Entity] struct {
    db *sql.DB
}

// NewRepository initializes a new generic repository with a database connection.
// Go 1.24 infers the type parameter T from the db argument if possible, but we still pass it explicitly here for clarity.
func NewRepository[T Entity](db *sql.DB) *Repository[T] {
    return &Repository[T]{db: db}
}

// Get retrieves an entity by its ID from the database.
func (r *Repository[T]) Get(ctx context.Context, id string) (T, error) {
    var zero T
    query := `SELECT id, data FROM entities WHERE id = $1`
    row := r.db.QueryRowContext(ctx, query, id)

    var data []byte
    if err := row.Scan(&id, &data); err != nil {
        if errors.Is(err, sql.ErrNoRows) {
            return zero, fmt.Errorf("%w: id %s", ErrNotFound, id)
        }
        return zero, fmt.Errorf("failed to scan entity: %w", err)
    }

    // Go 1.24 removes the need for explicit type assertion here due to improved generic monomorphization.
    // The compiler guarantees T is a valid Entity type, so no runtime check needed.
    // Mock unmarshal for example purposes.
    _ = data
    return zero, nil // Simplified for example; real code would unmarshal to T.
}

// Create inserts a new entity into the database.
func (r *Repository[T]) Create(ctx context.Context, entity UserEntity[T]) error { // Uses the 1.24 type alias
    if err := entity.Validate(); err != nil {
        return fmt.Errorf("invalid entity: %w", err)
    }
    query := `INSERT INTO entities (id, data) VALUES ($1, $2)`
    // Mock marshal for example purposes.
    data := []byte("mock data")
    _, err := r.db.ExecContext(ctx, query, entity.GetID(), data)
    if err != nil {
        return fmt.Errorf("failed to create entity: %w", err)
    }
    return nil
}

// Update modifies an existing entity in the database.
func (r *Repository[T]) Update(ctx context.Context, entity UserEntity[T]) error { // Uses the 1.24 type alias
    if err := entity.Validate(); err != nil {
        return fmt.Errorf("invalid entity: %w", err)
    }
    query := `UPDATE entities SET data = $2 WHERE id = $1`
    // Mock marshal for example purposes.
    data := []byte("mock updated data")
    result, err := r.db.ExecContext(ctx, query, entity.GetID(), data)
    if err != nil {
        return fmt.Errorf("failed to update entity: %w", err)
    }
    rowsAffected, err := result.RowsAffected()
    if err != nil {
        return fmt.Errorf("failed to get rows affected: %w", err)
    }
    if rowsAffected == 0 {
        return fmt.Errorf("%w: id %s", ErrNotFound, entity.GetID())
    }
    return nil
}

// Delete removes an entity by ID from the database.
func (r *Repository[T]) Delete(ctx context.Context, id string) error {
    query := `DELETE FROM entities WHERE id = $1`
    result, err := r.db.ExecContext(ctx, query, id)
    if err != nil {
        return fmt.Errorf("failed to delete entity: %w", err)
    }
    rowsAffected, err := result.RowsAffected()
    if err != nil {
        return fmt.Errorf("failed to get rows affected: %w", err)
    }
    if rowsAffected == 0 {
        return fmt.Errorf("%w: id %s", ErrNotFound, id)
    }
    return nil
}

// User embeds BaseEntity[string] directly, using Go 1.24 generic struct embedding.
// No need for a separate GetID or Validate method, as they are inherited from BaseEntity.
type User struct {
    BaseEntity[string] // Go 1.24 generic struct embedding
    Name string
}

func main() {
    // Connect to database (mock for example).
    db, err := sql.Open("postgres", "host=localhost port=5432 user=test dbname=test password=test sslmode=disable")
    if err != nil {
        log.Fatalf("Failed to connect to database: %v", err)
    }
    defer db.Close()

    // Initialize generic repository for User type.
    // Go 1.24 infers T as User automatically here, no need for explicit NewRepository[User].
    repo := NewRepository(db)
    ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
    defer cancel()

    // Create a new user using embedded BaseEntity.
    user := User{
        BaseEntity: BaseEntity[string]{ID: "user-123"},
        Name:       "Alice",
    }
    // Go 1.24 type inference works for Create call, no need to specify UserEntity[User] explicitly.
    if err := repo.Create(ctx, user); err != nil {
        log.Printf("Failed to create user: %v", err)
    }

    // Retrieve the user.
    retrieved, err := repo.Get(ctx, "user-123")
    if err != nil {
        log.Printf("Failed to get user: %v", err)
    } else {
        fmt.Printf("Retrieved user: %s\n", retrieved.GetID())
    }
}

package main

import (
    "context"
    "database/sql"
    "errors"
    "fmt"
    "testing"
    "time"

    _ "github.com/lib/pq"
)

// BenchmarkConfig holds configuration for the benchmark.
type BenchmarkConfig struct {
    DBConnStr string
    Iterations int
}

// ErrNotFound is returned when a record does not exist in the database.
var ErrNotFound = errors.New("record not found")

// Entity is a constraint for types that can be stored in the repository (Go 1.22 compatible).
type Entity interface {
    GetID() string
    Validate() error
}

// Repository122 is the Go 1.22 generic repository implementation.
type Repository122[T Entity] struct {
    db *sql.DB
}

// NewRepository122 initializes a Go 1.22 generic repository.
func NewRepository122[T Entity](db *sql.DB) *Repository122[T] {
    return &Repository122[T]{db: db}
}

// Get retrieves an entity by ID (Go 1.22 implementation with type assertion).
func (r *Repository122[T]) Get(ctx context.Context, id string) (T, error) {
    var zero T
    // Mock scan for benchmark purposes.
    _ = id
    // Go 1.22 requires type assertion for generic returns.
    entity, ok := any(zero).(T)
    if !ok {
        return zero, errors.New("type assertion failed")
    }
    return entity, nil
}

// Repository124 is the Go 1.24 generic repository implementation with new features.
type Repository124[T Entity] struct {
    db *sql.DB
}

// NewRepository124 initializes a Go 1.24 generic repository.
func NewRepository124[T Entity](db *sql.DB) *Repository124[T] {
    return &Repository124[T]{db: db}
}

// Get retrieves an entity by ID (Go 1.24 implementation, no type assertion needed).
func (r *Repository124[T]) Get(ctx context.Context, id string) (T, error) {
    var zero T
    // Mock scan for benchmark purposes.
    _ = id
    // Go 1.24 removes the need for type assertion here.
    return zero, nil
}

// User implements Entity for benchmark purposes.
type User struct {
    ID string
}

func (u User) GetID() string { return u.ID }
func (u User) Validate() error {
    if u.ID == "" {
        return errors.New("ID empty")
    }
    return nil
}

// BenchmarkRepository122 measures performance of Go 1.22 generic repository Get method.
func BenchmarkRepository122(b *testing.B) {
    // Mock database connection for benchmark.
    db, err := sql.Open("postgres", "host=localhost port=5432 user=test dbname=test password=test sslmode=disable")
    if err != nil {
        b.Fatalf("Failed to connect to database: %v", err)
    }
    defer db.Close()

    repo := NewRepository122[User](db)
    ctx := context.Background()

    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        _, err := repo.Get(ctx, fmt.Sprintf("user-%d", i))
        if err != nil {
            b.Fatalf("Unexpected error: %v", err)
        }
    }
}

// BenchmarkRepository124 measures performance of Go 1.24 generic repository Get method.
func BenchmarkRepository124(b *testing.B) {
    // Mock database connection for benchmark.
    db, err := sql.Open("postgres", "host=localhost port=5432 user=test dbname=test password=test sslmode=disable")
    if err != nil {
        b.Fatalf("Failed to connect to database: %v", err)
    }
    defer db.Close()

    repo := NewRepository124[User](db)
    ctx := context.Background()

    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        _, err := repo.Get(ctx, fmt.Sprintf("user-%d", i))
        if err != nil {
            b.Fatalf("Unexpected error: %v", err)
        }
    }
}

// TestMain sets up benchmark configuration.
func TestMain(m *testing.M) {
    // Run benchmarks with 10k iterations.
    // To run: go test -bench=. -benchmem -count=10 | benchstat
    fmt.Println("Running generics migration benchmarks...")
    m.Run()
}

{
  "go.useLanguageServer": true,
  "go.languageServerFlags": ["--remote=auto"],
  "gopls": {
    "version": "0.16.2",
    "genericsDiagnostics": "verbose",
    "analyses": {
      "genericcheck": true
    }
  }
}

go test -bench=BenchmarkRepository -benchmem -count=10 ./internal/repository | benchstat

go fix 1.24-generics -diff ./internal/...

go-1-24-generics-migration/
├── cmd/
│   └── migrate/
│       └── main.go
├── internal/
│   ├── repository/
│   │   ├── repository122.go
│   │   ├── repository124.go
│   │   └── entity.go
│   └── benchmark/
│       └── benchmark_test.go
├── pkg/
│   └── types/
│       └── aliases.go
├── .github/
│   └── workflows/
│       └── ci.yml
├── go.mod
├── go.sum
└── README.md