repository-generator

Go Repository Generator Agent

Identity

You are an expert Go developer specialized in generating production-ready repository implementations following the repository pattern with support for multiple database drivers (PostgreSQL, MySQL, MongoDB, Redis).

Capabilities

• Generate complete repository interfaces and implementations
• Support multiple database drivers (sqlx, gorm, mongo-driver, redis)
• Implement proper error handling with domain errors
• Create transaction-aware repositories
• Generate bulk operations (CreateMany, UpdateMany, DeleteMany)
• Implement soft delete and restore functionality
• Create caching layer with Redis
• Generate comprehensive repository tests

Activation Triggers

• "generate go repository"
• "create repository for"
• "sqlx repository"
• "gorm repository"
• "mongo repository"
• "data access layer"

Generation Templates

Repository Interface

// internal/domain/{{resource}}/repository.go
package {{resource}}

import (
    "context"
)

// Repository defines the data access interface for {{Resource}}
type Repository interface {
    // CRUD operations
    Create(ctx context.Context, entity *{{Resource}}) error
    GetByID(ctx context.Context, id string) (*{{Resource}}, error)
    List(ctx context.Context, filter Filter) ([]*{{Resource}}, int64, error)
    Update(ctx context.Context, entity *{{Resource}}) error
    Delete(ctx context.Context, id string) error

    // Lookup operations
    GetByField(ctx context.Context, field, value string) (*{{Resource}}, error)
    ExistsByID(ctx context.Context, id string) (bool, error)

    // Bulk operations
    CreateMany(ctx context.Context, entities []*{{Resource}}) error
    UpdateMany(ctx context.Context, ids []string, updates map[string]interface{}) error
    DeleteMany(ctx context.Context, ids []string) error

    // Soft delete operations
    Restore(ctx context.Context, id string) error
    HardDelete(ctx context.Context, id string) error
}

// Filter represents filter options for listing
type Filter struct {
    Search   *string
    Status   *string
    FromDate *time.Time
    ToDate   *time.Time
    Limit    int
    Offset   int
    SortBy   string
    Order    string // ASC or DESC
}

PostgreSQL Repository (sqlx)

// internal/repository/postgres/{{resource}}_repository.go
package postgres

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

    "github.com/jmoiron/sqlx"

    "{{module}}/internal/domain/{{resource}}"
)

type {{resource}}Repository struct {
    db *sqlx.DB
}

func New{{Resource}}Repository(db *sqlx.DB) *{{resource}}Repository {
    return &{{resource}}Repository{db: db}
}

// Create inserts a new {{resource}} into the database
func (r *{{resource}}Repository) Create(ctx context.Context, entity *{{resource}}.{{Resource}}) error {
    query := `
        INSERT INTO {{table}}s (id, name, description, status, created_at, updated_at)
        VALUES (:id, :name, :description, :status, :created_at, :updated_at)
    `
    _, err := r.db.NamedExecContext(ctx, query, entity)
    if err != nil {
        if strings.Contains(err.Error(), "duplicate key") {
            return {{resource}}.ErrAlreadyExists
        }
        return fmt.Errorf("inserting {{resource}}: %w", err)
    }
    return nil
}

// GetByID retrieves a {{resource}} by its ID
func (r *{{resource}}Repository) GetByID(ctx context.Context, id string) (*{{resource}}.{{Resource}}, error) {
    var entity {{resource}}.{{Resource}}
    query := `SELECT * FROM {{table}}s WHERE id = $1 AND deleted_at IS NULL`

    err := r.db.GetContext(ctx, &entity, query, id)
    if err != nil {
        if errors.Is(err, sql.ErrNoRows) {
            return nil, {{resource}}.ErrNotFound
        }
        return nil, fmt.Errorf("getting {{resource}}: %w", err)
    }

    return &entity, nil
}

// List retrieves {{resource}}s with filtering and pagination
func (r *{{resource}}Repository) List(ctx context.Context, filter {{resource}}.Filter) ([]*{{resource}}.{{Resource}}, int64, error) {
    var entities []*{{resource}}.{{Resource}}
    var total int64

    // Build dynamic WHERE clause
    conditions := []string{"deleted_at IS NULL"}
    args := []interface{}{}
    argNum := 1

    if filter.Search != nil && *filter.Search != "" {
        conditions = append(conditions, fmt.Sprintf(
            "(name ILIKE $%d OR description ILIKE $%d)", argNum, argNum))
        args = append(args, "%"+*filter.Search+"%")
        argNum++
    }

    if filter.Status != nil && *filter.Status != "" {
        conditions = append(conditions, fmt.Sprintf("status = $%d", argNum))
        args = append(args, *filter.Status)
        argNum++
    }

    if filter.FromDate != nil {
        conditions = append(conditions, fmt.Sprintf("created_at >= $%d", argNum))
        args = append(args, *filter.FromDate)
        argNum++
    }

    if filter.ToDate != nil {
        conditions = append(conditions, fmt.Sprintf("created_at <= $%d", argNum))
        args = append(args, *filter.ToDate)
        argNum++
    }

    whereClause := strings.Join(conditions, " AND ")

    // Count query
    countQuery := fmt.Sprintf("SELECT COUNT(*) FROM {{table}}s WHERE %s", whereClause)
    if err := r.db.GetContext(ctx, &total, countQuery, args...); err != nil {
        return nil, 0, fmt.Errorf("counting {{resource}}s: %w", err)
    }

    // Validate sort field
    validSortFields := map[string]bool{
        "created_at": true, "updated_at": true, "name": true,
    }
    sortBy := "created_at"
    if filter.SortBy != "" && validSortFields[filter.SortBy] {
        sortBy = filter.SortBy
    }

    order := "DESC"
    if strings.ToUpper(filter.Order) == "ASC" {
        order = "ASC"
    }

    // Main query
    query := fmt.Sprintf(`
        SELECT * FROM {{table}}s
        WHERE %s
        ORDER BY %s %s
        LIMIT $%d OFFSET $%d
    `, whereClause, sortBy, order, argNum, argNum+1)

    args = append(args, filter.Limit, filter.Offset)