repository-design-pattern

The repository design pattern that has following characteristics

• Easy to register new repositories with minimal repetitive code
• Single database connection (aws session) across all repositories
• Parent struct that contains shared fields
• Each repository must implement standard Restful methods, however can contain any additional functions
• All repositories are stored in a registry and can be passed down the application as a single struct

Example:

main.go

    logger := logrus.New()
    logger.SetLevel(logrus.DebugLevel)
    sess := session.Must(session.NewSessionWithOptions(session.Options{
        SharedConfigState: session.SharedConfigEnable,
    }))
    rr := repository.NewRepositoryRegistry(
        dynamo.New(sess),
        logger,
        &repository.UserRepository{},
    )
    users, err := rr.MustRepository("UserRepository").List()
    if err != nil {
        logger.WithError(err).Fatal("an error has occurred")
    }
    fmt.Println(users)

UserRepository.go

package repository
import (
    "github.com/b-b3rn4rd/repository-design-pattern/model"
    "github.com/pkg/errors"
)
type UserRepository struct {
    DynamoRepository
}
func (r *UserRepository) List() (interface{}, error) {
    r.logger.Debug("listing all users")
    var users []model.User
    err := r.db.Table("User").Scan().All(&users)
    if err != nil {
        return nil, errors.Wrap(err, "error while listing users")
    }
    return users, nil
}
func (r *UserRepository) Get(id interface{}) (interface{}, error) {
    r.logger.WithField("id", id).Debug("retrieving single user")
    var user []model.User
    err := r.db.Table("User").Get("Id", id).One(&user)
    if err != nil {
        return nil, errors.Wrap(err, "error while retrieving single user")
    }
    return user, nil
}
func (r *UserRepository) Create(entity interface{}) (interface{}, error) {
    r.logger.WithField("user", entity).Debug("create user")
    err := r.db.Table("User").Put(entity.(model.User)).Run()
    if err != nil {
        return false, errors.Wrap(err, "error while creating user")
    }
    return true, nil
}
func (r *UserRepository) Update(id interface{}, entity interface{}) (bool, error) {
    r.logger.WithField("user", entity).Debug("update user")
    err := r.db.Table("User").Update("Id", id).Set("Email", entity.(model.User).Email).Run()
    if err != nil {
        return false, errors.Wrap(err, "error while updating user")
    }
    return true, nil
}
func (r *UserRepository) Delete(id interface{}) (bool, error) {
    r.logger.WithField("id", id).Debug("delete user")
    err := r.db.Table("User").Delete("Id", id).Run()
    if err != nil {
        return false, errors.Wrap(err, "error while deleting user")
    }
    return false, nil
}
func (r *UserRepository) GetGroups(id interface{}) (interface{}, error) {
    r.logger.WithField("id", id).Debug("get user groups")
    return nil, errors.New("error retrieving user's groups")
}