What are Go and generics for repository pattern?

Question

Accepted Answer

Generics allow creating a **universal repository pattern** for different entities.

```go
// Base interface
type Repository[T any, ID comparable] interface {
    FindByID(ctx context.Context, id ID) (*T, error)
    FindAll(ctx context.Context) ([]*T, error)
    Create(ctx context.Context, entity *T) error
    Update(ctx context.Context, entity *T) error
    Delete(ctx context.Context, id ID) error
}

// PostgreSQL implementation
type PostgresRepository[T any, ID comparable] struct {
    db  *sql.DB
    table string
}

func (r *PostgresRepository[T, ID]) FindByID(ctx context.Context, id ID) (*T, error) {
    query := fmt.Sprintf("SELECT * FROM %s WHERE id = $1", r.table)
    var entity T
    err := r.db.QueryRowContext(ctx, query, id).Scan(&entity)
    if err != nil {
        return nil, err
    }
    return &entity, nil
}

func (r *PostgresRepository[T, ID]) Create(ctx context.Context, entity *T) error {
    query := fmt.Sprintf("INSERT INTO %s ...", r.table)
    _, err := r.db.ExecContext(ctx, query, ...)
    return err
}

// Usage
type User struct {
    ID    int
    Name  string
    Email string
}

func main() {
    userRepo := &PostgresRepository[User, int]{
        db:    db,
        table: "users",
    }

user, err := userRepo.FindByID(ctx, 1)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println(user.Name)

// Same code for Product
    productRepo := &PostgresRepository[Product, int]{
        db:    db,
        table: "products",
    }
}
```

**Advantages:** Less code, type safety, consistency.
**Limitations:** Complex serialization, generics constraints.

Go: What are Go and generics for repository pattern?