package repository

import "github.com/go-arrower/arrower/repository"

Package repository implements generic repositories. It panics instead of returning errors, to make calling it much easier and prevent boilerplate in error checking. The repositories are intended for rapid prototyping and development and not production use.

A Repository offers a whole set of methods already out of the box. That might not be enough, though. It is possible to overwrite an existing method to change the behaviour as well as extend the Repository with new methods. There are examples for both.

The primary use case is for testing and quick iterations when prototyping, so all repositories are in memory. Sometimes it might be handy so persist some data, so it is possible to use a Store to do so. This is NOT intended for production use and only recommended for local demoing of an application. With the application worked out, it's best to implement a proper repository that stores the data in a real datastore.

Example (ExtendRepositoryWithNewMethods)

Code:play  

package main

import (
	"context"
	"fmt"

	"github.com/go-arrower/arrower/repository"
)

func main() {
	ctx := context.Background()

	repo := NewUserMemoryRepository()
	repo.Add(ctx, User{ID: 1, Login: "hello@arrower.org"})

	u, _ := repo.FindByLogin(ctx, "hello@arrower.org")
	fmt.Println(u)

}

type UserID int

type User struct {
	ID    UserID
	Login string
}

func NewUserMemoryRepository() *UserMemoryRepository {
	return &UserMemoryRepository{
		MemoryRepository: repository.NewMemoryRepository[User, UserID](),
	}
}

type UserMemoryRepository struct {
	*repository.MemoryRepository[User, UserID]
}

// FindByLogin implements a custom method, that is not supported by the Repository out of the box.
func (repo *UserMemoryRepository) FindByLogin(ctx context.Context, login string) (User, error) {
	all, _ := repo.All(ctx)

	for _, u := range all {
		if u.Login == login {
			return u, nil
		}
	}

	return User{}, repository.ErrNotFound
}

Output:

{1 hello@arrower.org}
Example (OverwriteRepositoryMethodWithOwnBehaviour)

Code:play  

package main

import (
	"context"
	"fmt"

	"github.com/go-arrower/arrower/repository"
)

func main() {
	ctx := context.Background()

	repo := NewElementMemoryRepository()
	repo.Add(ctx, Element{ID: 1})

	c, _ := repo.Count(ctx)
	fmt.Println(c)

}

type Element struct {
	ID int
}

func NewElementMemoryRepository() *ElementMemoryRepository {
	return &ElementMemoryRepository{
		MemoryRepository: repository.NewMemoryRepository[Element, int](),
	}
}

type ElementMemoryRepository struct {
	*repository.MemoryRepository[Element, int]
}

// Count overwrites the existing Count method with your own implementation.
func (repo *ElementMemoryRepository) Count(_ context.Context) (int, error) {
	return -1, nil
}

Output:

-1

Index

Examples

Variables 

var (
	ErrNotFound      = errors.New("not found")
	ErrSaveFailed    = errors.New("save failed") // TODO separate into more preceise persitance errors (create, update general?)
	ErrAlreadyExists = errors.New("exists already")
	ErrDeleteFailed  = errors.New("delete failed")
)
var (
	ErrStore = errors.New("could not store repository data")
	ErrLoad  = errors.New("could not load repository data")
)
var (
	ErrInvalidQuery = errors.New("invalid query")
)

Functions

func TestSuite 

func TestSuite(
	t *testing.T,
	newEntityRepo func(opts ...Option) Repository[testdata.Entity, testdata.EntityID],
	newEntityRepoInt func(opts ...Option) Repository[testdata.EntityWithIntPK, testdata.EntityIDInt],
	newEntityWithoutIDRepo func(opts ...Option) Repository[testdata.EntityWithoutID, testdata.EntityID],
)

TestSuite is a suite that ensures a Repository implementation adheres to the intended behaviour.

Types

type Iterator 

type Iterator[E any, ID id] interface {
	Next() func(yield func(e E, err error) bool)
}

type JSONStore 

type JSONStore struct {
	// contains filtered or unexported fields
}

JSONStore is a naive implementation of a Store. It persists the data as a human-readable JSON file on disc. JSONStore is not schema aware and uses the standard go marshalling. CAUTION: Be aware if you change your structs, this can lead to data loss! CAUTION: This is only intended for local development and prototyping.

func NewJSONStore 

func NewJSONStore(path string) *JSONStore

func (*JSONStore) Load 

func (s *JSONStore) Load(fileName string, data any) error

func (*JSONStore) Store 

func (s *JSONStore) Store(fileName string, data any) error

type MemoryIterator 

type MemoryIterator[E any, ID id] struct {
	// contains filtered or unexported fields
}

func (MemoryIterator[E, ID]) Next 

func (i MemoryIterator[E, ID]) Next() func(yield func(e E, err error) bool)

type MemoryRepository 

type MemoryRepository[E any, ID id] struct {
	// Mutex is embedded, so that repositories who extend MemoryRepository can lock the same mutex as other methods.
	*sync.Mutex

	// Data is the repository's collection. It is exposed in case you're extending the repository.
	// PREVENT using and accessing Data it directly, go through the repository methods.
	// If you write to Data, USE the Mutex to lock first.
	Data map[ID]E
	// contains filtered or unexported fields
}

MemoryRepository implements Repository in a generic way. Use it to speed up your unit testing.

func NewMemoryRepository 

func NewMemoryRepository[E any, ID id](opts ...Option) *MemoryRepository[E, ID]

NewMemoryRepository returns an implementation of Repository for the given entity E. It is expected that E has a field called `ID`, that is used as the primary key and can be overwritten by WithIDField. If your repository needs additional methods, you can embed this repo into our own implementation to extend your own repository easily to your use case. See the examples in the test files.

Warning: the consistency of MemoryRepository is not on paar with ACID guarantees of a RDBMS. Certain steps are taken to have a minimum of consistency, but be aware that this it not a design goal.

func (*MemoryRepository[E, ID]) Add 

func (repo *MemoryRepository[E, ID]) Add(ctx context.Context, entity E) error

func (*MemoryRepository[E, ID]) AddAll 

func (repo *MemoryRepository[E, ID]) AddAll(ctx context.Context, entities []E) error

func (*MemoryRepository[E, ID]) All 

func (repo *MemoryRepository[E, ID]) All(ctx context.Context) ([]E, error)

func (*MemoryRepository[E, ID]) AllByIDs 

func (repo *MemoryRepository[E, ID]) AllByIDs(ctx context.Context, ids []ID) ([]E, error)

func (*MemoryRepository[E, ID]) AllIter 

func (repo *MemoryRepository[E, ID]) AllIter(_ context.Context) Iterator[E, ID]

func (*MemoryRepository[E, ID]) Clear 

func (repo *MemoryRepository[E, ID]) Clear(ctx context.Context) error

func (*MemoryRepository[E, ID]) Contains 

func (repo *MemoryRepository[E, ID]) Contains(ctx context.Context, id ID) (bool, error)

func (*MemoryRepository[E, ID]) ContainsAll 

func (repo *MemoryRepository[E, ID]) ContainsAll(ctx context.Context, ids []ID) (bool, error)

func (*MemoryRepository[E, ID]) ContainsID 

func (repo *MemoryRepository[E, ID]) ContainsID(ctx context.Context, id ID) (bool, error)

func (*MemoryRepository[E, ID]) ContainsIDs 

func (repo *MemoryRepository[E, ID]) ContainsIDs(ctx context.Context, ids []ID) (bool, error)

func (*MemoryRepository[E, ID]) Count 

func (repo *MemoryRepository[E, ID]) Count(_ context.Context) (int, error)

func (*MemoryRepository[E, ID]) Create 

func (repo *MemoryRepository[E, ID]) Create(_ context.Context, entity E) error

func (*MemoryRepository[E, ID]) CreateAll 

func (repo *MemoryRepository[E, ID]) CreateAll(ctx context.Context, entities []E) error

func (*MemoryRepository[E, ID]) Delete 

func (repo *MemoryRepository[E, ID]) Delete(_ context.Context, entity E) error

func (*MemoryRepository[E, ID]) DeleteAll 

func (repo *MemoryRepository[E, ID]) DeleteAll(_ context.Context) error

func (*MemoryRepository[E, ID]) DeleteByID 

func (repo *MemoryRepository[E, ID]) DeleteByID(ctx context.Context, id ID) error

func (*MemoryRepository[E, ID]) DeleteByIDs 

func (repo *MemoryRepository[E, ID]) DeleteByIDs(_ context.Context, ids []ID) error

func (*MemoryRepository[E, ID]) ExistAll 

func (repo *MemoryRepository[E, ID]) ExistAll(_ context.Context, ids []ID) (bool, error)

func (*MemoryRepository[E, ID]) ExistByIDs 

func (repo *MemoryRepository[E, ID]) ExistByIDs(ctx context.Context, ids []ID) (bool, error)

func (*MemoryRepository[E, ID]) Exists 

func (repo *MemoryRepository[E, ID]) Exists(_ context.Context, id ID) (bool, error)

func (*MemoryRepository[E, ID]) ExistsByID 

func (repo *MemoryRepository[E, ID]) ExistsByID(ctx context.Context, id ID) (bool, error)

func (*MemoryRepository[E, ID]) FindAll 

func (repo *MemoryRepository[E, ID]) FindAll(_ context.Context) ([]E, error)

func (*MemoryRepository[E, ID]) FindAllIter 

func (repo *MemoryRepository[E, ID]) FindAllIter(_ context.Context) Iterator[E, ID]

func (*MemoryRepository[E, ID]) FindByID 

func (repo *MemoryRepository[E, ID]) FindByID(_ context.Context, id ID) (E, error)

func (*MemoryRepository[E, ID]) FindByIDs 

func (repo *MemoryRepository[E, ID]) FindByIDs(_ context.Context, ids []ID) ([]E, error)

func (*MemoryRepository[E, ID]) Length 

func (repo *MemoryRepository[E, ID]) Length(ctx context.Context) (int, error)

func (*MemoryRepository[E, ID]) NextID 

func (repo *MemoryRepository[E, ID]) NextID(_ context.Context) (ID, error)

NextID returns a new ID. It can be of the underlying type of string or integer.

func (*MemoryRepository[E, ID]) Read 

func (repo *MemoryRepository[E, ID]) Read(ctx context.Context, id ID) (E, error)

func (*MemoryRepository[E, ID]) Save 

func (repo *MemoryRepository[E, ID]) Save(_ context.Context, entity E) error

func (*MemoryRepository[E, ID]) SaveAll 

func (repo *MemoryRepository[E, ID]) SaveAll(_ context.Context, entities []E) error

func (*MemoryRepository[E, ID]) Update 

func (repo *MemoryRepository[E, ID]) Update(_ context.Context, entity E) error

func (*MemoryRepository[E, ID]) UpdateAll 

func (repo *MemoryRepository[E, ID]) UpdateAll(ctx context.Context, entities []E) error

type MemoryTenantRepository 

type MemoryTenantRepository[tID id, E any, eID id] struct {
	// Mutex is embedded, so that repositories who extend MemoryTenantRepository can lock the same mutex as other methods.
	*sync.Mutex

	// Data is the repository's collection. It is exposed in case you're extending the repository.
	// PREVENT using and accessing Data it directly, go through the repository methods.
	// If you write to Data, USE the Mutex to lock first.
	Data map[tID]map[eID]E
	// contains filtered or unexported fields
}

MemoryTenantRepository implements TenantRepository in a generic way. Use it to speed up your unit testing.

func NewMemoryTenantRepository 

func NewMemoryTenantRepository[tID id, E any, eID id](
	opts ...Option,
) *MemoryTenantRepository[tID, E, eID]

NewMemoryTenantRepository returns an implementation of MemoryTenantRepository for the given entity E. It is expected that E have a field called `ID`, that is used as the primary key and can be overwritten by WithIDField. If your repository needs additional methods, you can embed this repo into our own implementation to extend your own repository easily to your use case.

func (*MemoryTenantRepository[tID, E, eID]) Add 

func (repo *MemoryTenantRepository[tID, E, eID]) Add(ctx context.Context, tenantID tID, entity E) error

func (*MemoryTenantRepository[tID, E, eID]) AddAll 

func (repo *MemoryTenantRepository[tID, E, eID]) AddAll(ctx context.Context, tenantID tID, entities []E) error

func (*MemoryTenantRepository[tID, E, eID]) All 

func (repo *MemoryTenantRepository[tID, E, eID]) All(_ context.Context) ([]E, error)

func (*MemoryTenantRepository[tID, E, eID]) AllByIDs 

func (repo *MemoryTenantRepository[tID, E, eID]) AllByIDs(_ context.Context, tenantID tID, ids []eID) ([]E, error)

func (*MemoryTenantRepository[tID, E, eID]) AllOfTenant 

func (repo *MemoryTenantRepository[tID, E, eID]) AllOfTenant(_ context.Context, tenantID tID) ([]E, error)

func (*MemoryTenantRepository[tID, E, eID]) Clear 

func (repo *MemoryTenantRepository[tID, E, eID]) Clear(ctx context.Context) error

func (*MemoryTenantRepository[tID, E, eID]) ClearTenant 

func (repo *MemoryTenantRepository[tID, E, eID]) ClearTenant(ctx context.Context, tenantID tID) error

func (*MemoryTenantRepository[tID, E, eID]) Contains 

func (repo *MemoryTenantRepository[tID, E, eID]) Contains(ctx context.Context, tenantID tID, id eID) (bool, error)

func (*MemoryTenantRepository[tID, E, eID]) ContainsAll 

func (repo *MemoryTenantRepository[tID, E, eID]) ContainsAll(
	ctx context.Context,
	tenantID tID,
	ids []eID,
) (bool, error)

func (*MemoryTenantRepository[tID, E, eID]) ContainsID 

func (repo *MemoryTenantRepository[tID, E, eID]) ContainsID(
	ctx context.Context,
	tenantID tID,
	id eID,
) (bool, error)

func (*MemoryTenantRepository[tID, E, eID]) ContainsIDs 

func (repo *MemoryTenantRepository[tID, E, eID]) ContainsIDs(
	ctx context.Context,
	tenantID tID,
	ids []eID,
) (bool, error)

func (*MemoryTenantRepository[tID, E, eID]) Count 

func (repo *MemoryTenantRepository[tID, E, eID]) Count(_ context.Context) (int, error)

func (*MemoryTenantRepository[tID, E, eID]) CountOfTenant 

func (repo *MemoryTenantRepository[tID, E, eID]) CountOfTenant(_ context.Context, tenantID tID) (int, error)

func (*MemoryTenantRepository[tID, E, eID]) Create 

func (repo *MemoryTenantRepository[tID, E, eID]) Create(_ context.Context, tenantID tID, entity E) error

func (*MemoryTenantRepository[tID, E, eID]) Delete 

func (repo *MemoryTenantRepository[tID, E, eID]) Delete(_ context.Context, tenantID tID, entity E) error

func (*MemoryTenantRepository[tID, E, eID]) DeleteAll 

func (repo *MemoryTenantRepository[tID, E, eID]) DeleteAll(_ context.Context) error

func (*MemoryTenantRepository[tID, E, eID]) DeleteAllOfTenant 

func (repo *MemoryTenantRepository[tID, E, eID]) DeleteAllOfTenant(_ context.Context, tenantID tID) error

func (*MemoryTenantRepository[tID, E, eID]) DeleteByID 

func (repo *MemoryTenantRepository[tID, E, eID]) DeleteByID(ctx context.Context, tenantID tID, id eID) error

func (*MemoryTenantRepository[tID, E, eID]) DeleteByIDs 

func (repo *MemoryTenantRepository[tID, E, eID]) DeleteByIDs(_ context.Context, tenantID tID, ids []eID) error

func (*MemoryTenantRepository[tID, E, eID]) ExistAll 

func (repo *MemoryTenantRepository[tID, E, eID]) ExistAll(_ context.Context, tenantID tID, ids []eID) (bool, error)

func (*MemoryTenantRepository[tID, E, eID]) ExistByIDs 

func (repo *MemoryTenantRepository[tID, E, eID]) ExistByIDs(
	ctx context.Context,
	tenantID tID,
	ids []eID,
) (bool, error)

func (*MemoryTenantRepository[tID, E, eID]) Exists 

func (repo *MemoryTenantRepository[tID, E, eID]) Exists(_ context.Context, tenantID tID, id eID) (bool, error)

func (*MemoryTenantRepository[tID, E, eID]) ExistsByID 

func (repo *MemoryTenantRepository[tID, E, eID]) ExistsByID(
	ctx context.Context,
	tenantID tID,
	id eID,
) (bool, error)

func (*MemoryTenantRepository[tID, E, eID]) FindAll 

func (repo *MemoryTenantRepository[tID, E, eID]) FindAll(ctx context.Context) ([]E, error)

func (*MemoryTenantRepository[tID, E, eID]) FindAllOfTenant 

func (repo *MemoryTenantRepository[tID, E, eID]) FindAllOfTenant(ctx context.Context, tenantID tID) ([]E, error)

func (*MemoryTenantRepository[tID, E, eID]) FindByID 

func (repo *MemoryTenantRepository[tID, E, eID]) FindByID(ctx context.Context, tenantID tID, id eID) (E, error)

func (*MemoryTenantRepository[tID, E, eID]) FindByIDs 

func (repo *MemoryTenantRepository[tID, E, eID]) FindByIDs(
	ctx context.Context,
	tenantID tID,
	ids []eID,
) ([]E, error)

func (*MemoryTenantRepository[tID, E, eID]) Length 

func (repo *MemoryTenantRepository[tID, E, eID]) Length(ctx context.Context) (int, error)

func (*MemoryTenantRepository[tID, E, eID]) LengthOfTenant 

func (repo *MemoryTenantRepository[tID, E, eID]) LengthOfTenant(ctx context.Context, tenantID tID) (int, error)

func (*MemoryTenantRepository[tid, E, eID]) NextID 

func (repo *MemoryTenantRepository[tid, E, eID]) NextID(ctx context.Context) (eID, error)

func (*MemoryTenantRepository[tID, E, eID]) Read 

func (repo *MemoryTenantRepository[tID, E, eID]) Read(_ context.Context, tenantID tID, id eID) (E, error)

func (*MemoryTenantRepository[tID, E, eID]) Save 

func (repo *MemoryTenantRepository[tID, E, eID]) Save(_ context.Context, tenantID tID, entity E) error

func (*MemoryTenantRepository[tID, E, eID]) SaveAll 

func (repo *MemoryTenantRepository[tID, E, eID]) SaveAll(_ context.Context, tenantID tID, entities []E) error

func (*MemoryTenantRepository[tID, E, eID]) Update 

func (repo *MemoryTenantRepository[tID, E, eID]) Update(_ context.Context, tenantID tID, entity E) error

func (*MemoryTenantRepository[tID, E, eID]) UpdateAll 

func (repo *MemoryTenantRepository[tID, E, eID]) UpdateAll(ctx context.Context, tenantID tID, entities []E) error

type NoopStore 

type NoopStore struct{}

func (NoopStore) Load 

func (n NoopStore) Load(_ string, _ any) error

func (NoopStore) Store 

func (n NoopStore) Store(_ string, _ any) error

type Option 

type Option func(*repoConfig)

func WithIDField 

func WithIDField(idFieldName string) Option

WithIDField set's the name of the field that is used as an id or primary key. If not set, it is assumed that the entity struct has a field with the name "ID".

func WithStore 

func WithStore(store Store) Option

WithStore sets a Store used to persist the Repository. ONLY applies to the in memory implementations.

There are no transactions or any consistency guarantees at all! For example, if a store fails, the collection is still changed in memory of the repository.

func WithStoreFilename 

func WithStoreFilename(name string) Option

WithStoreFilename overwrites the file name a Store should use to persist this Repository. ONLY applies to the in memory implementations.

type PostgresIterator 

type PostgresIterator[E any, ID id] struct {
	// contains filtered or unexported fields
}

func (PostgresIterator[E, ID]) Next 

func (i PostgresIterator[E, ID]) Next() func(yield func(e E, err error) bool)

type PostgresRepository 

type PostgresRepository[E any, ID id] struct {
	// contains filtered or unexported fields
}

func NewPostgresRepository 

func NewPostgresRepository[E any, ID id](pgx *pgxpool.Pool, opts ...Option) *PostgresRepository[E, ID]

func (*PostgresRepository[E, ID]) Add 

func (repo *PostgresRepository[E, ID]) Add(ctx context.Context, entity E) error

func (*PostgresRepository[E, ID]) AddAll 

func (repo *PostgresRepository[E, ID]) AddAll(ctx context.Context, entities []E) error

func (*PostgresRepository[E, ID]) All 

func (repo *PostgresRepository[E, ID]) All(ctx context.Context) ([]E, error)

func (*PostgresRepository[E, ID]) AllByIDs 

func (repo *PostgresRepository[E, ID]) AllByIDs(ctx context.Context, ids []ID) ([]E, error)

func (*PostgresRepository[E, ID]) AllIter 

func (repo *PostgresRepository[E, ID]) AllIter(ctx context.Context) Iterator[E, ID]

func (*PostgresRepository[E, ID]) Clear 

func (repo *PostgresRepository[E, ID]) Clear(ctx context.Context) error

func (*PostgresRepository[E, ID]) Contains 

func (repo *PostgresRepository[E, ID]) Contains(ctx context.Context, id ID) (bool, error)

func (*PostgresRepository[E, ID]) ContainsAll 

func (repo *PostgresRepository[E, ID]) ContainsAll(ctx context.Context, ids []ID) (bool, error)

func (*PostgresRepository[E, ID]) ContainsID 

func (repo *PostgresRepository[E, ID]) ContainsID(ctx context.Context, id ID) (bool, error)

func (*PostgresRepository[E, ID]) ContainsIDs 

func (repo *PostgresRepository[E, ID]) ContainsIDs(ctx context.Context, ids []ID) (bool, error)

func (*PostgresRepository[E, ID]) Count 

func (repo *PostgresRepository[E, ID]) Count(ctx context.Context) (int, error)

func (*PostgresRepository[E, ID]) Create 

func (repo *PostgresRepository[E, ID]) Create(ctx context.Context, entity E) error

func (*PostgresRepository[E, ID]) CreateAll 

func (repo *PostgresRepository[E, ID]) CreateAll(ctx context.Context, entities []E) error

func (*PostgresRepository[E, ID]) Delete 

func (repo *PostgresRepository[E, ID]) Delete(ctx context.Context, entity E) error

func (*PostgresRepository[E, ID]) DeleteAll 

func (repo *PostgresRepository[E, ID]) DeleteAll(ctx context.Context) error

func (*PostgresRepository[E, ID]) DeleteByID 

func (repo *PostgresRepository[E, ID]) DeleteByID(ctx context.Context, id ID) error

func (*PostgresRepository[E, ID]) DeleteByIDs 

func (repo *PostgresRepository[E, ID]) DeleteByIDs(ctx context.Context, ids []ID) error

func (*PostgresRepository[E, ID]) ExistAll 

func (repo *PostgresRepository[E, ID]) ExistAll(_ context.Context, _ []ID) (bool, error)

func (*PostgresRepository[E, ID]) ExistByIDs 

func (repo *PostgresRepository[E, ID]) ExistByIDs(_ context.Context, _ []ID) (bool, error)

func (*PostgresRepository[E, ID]) Exists 

func (repo *PostgresRepository[E, ID]) Exists(ctx context.Context, id ID) (bool, error)

func (*PostgresRepository[E, ID]) ExistsByID 

func (repo *PostgresRepository[E, ID]) ExistsByID(ctx context.Context, id ID) (bool, error)

func (*PostgresRepository[E, ID]) FindAll 

func (repo *PostgresRepository[E, ID]) FindAll(ctx context.Context) ([]E, error)

func (*PostgresRepository[E, ID]) FindAllIter 

func (repo *PostgresRepository[E, ID]) FindAllIter(ctx context.Context) Iterator[E, ID]

func (*PostgresRepository[E, ID]) FindByID 

func (repo *PostgresRepository[E, ID]) FindByID(ctx context.Context, id ID) (E, error)

func (*PostgresRepository[E, ID]) FindByIDs 

func (repo *PostgresRepository[E, ID]) FindByIDs(ctx context.Context, ids []ID) ([]E, error)

func (*PostgresRepository[E, ID]) Length 

func (repo *PostgresRepository[E, ID]) Length(ctx context.Context) (int, error)

func (*PostgresRepository[E, ID]) NextID 

func (repo *PostgresRepository[E, ID]) NextID(ctx context.Context) (ID, error)

func (*PostgresRepository[E, ID]) Read 

func (repo *PostgresRepository[E, ID]) Read(ctx context.Context, id ID) (E, error)

func (*PostgresRepository[E, ID]) Save 

func (repo *PostgresRepository[E, ID]) Save(ctx context.Context, entity E) error

func (*PostgresRepository[E, ID]) SaveAll 

func (repo *PostgresRepository[E, ID]) SaveAll(ctx context.Context, entities []E) error

func (*PostgresRepository[E, ID]) Update 

func (repo *PostgresRepository[E, ID]) Update(ctx context.Context, entity E) error

func (*PostgresRepository[E, ID]) UpdateAll 

func (repo *PostgresRepository[E, ID]) UpdateAll(ctx context.Context, entities []E) error

type Repository 

type Repository[E any, ID id] interface {
	NextID(ctx context.Context) (ID, error)

	Create(ctx context.Context, entity E) error
	Read(ctx context.Context, id ID) (E, error)
	Update(ctx context.Context, entity E) error
	Delete(ctx context.Context, entity E) error

	All(ctx context.Context) ([]E, error)
	AllByIDs(ctx context.Context, ids []ID) ([]E, error)
	FindAll(ctx context.Context) ([]E, error)
	FindByID(ctx context.Context, id ID) (E, error)
	FindByIDs(ctx context.Context, ids []ID) ([]E, error)
	Exists(ctx context.Context, id ID) (bool, error)
	ExistsByID(ctx context.Context, id ID) (bool, error)
	ExistByIDs(ctx context.Context, ids []ID) (bool, error)
	ExistAll(ctx context.Context, ids []ID) (bool, error)
	Contains(ctx context.Context, id ID) (bool, error)
	ContainsID(ctx context.Context, id ID) (bool, error)
	ContainsIDs(ctx context.Context, ids []ID) (bool, error)
	ContainsAll(ctx context.Context, ids []ID) (bool, error)

	CreateAll(ctx context.Context, entities []E) error
	Save(ctx context.Context, entity E) error
	SaveAll(ctx context.Context, entities []E) error
	UpdateAll(ctx context.Context, entities []E) error
	Add(ctx context.Context, entity E) error
	AddAll(ctx context.Context, entities []E) error

	Count(ctx context.Context) (int, error)
	Length(ctx context.Context) (int, error)

	DeleteByID(ctx context.Context, id ID) error
	DeleteByIDs(ctx context.Context, ids []ID) error
	DeleteAll(ctx context.Context) error
	Clear(ctx context.Context) error

	AllIter(ctx context.Context) Iterator[E, ID]
	FindAllIter(ctx context.Context) Iterator[E, ID]
}

Repository is a general purpose interface documenting which methods are available by the generic MemoryRepository. ID is the primary key and needs to be of one of the underlying types. If your repository needs additional methods, you can extend your own repository easily to tune it to your use case. See the examples in the test files.

type Store 

type Store interface {
	Store(fileName string, data any) error
	Load(fileName string, data any) error
}

Store is an interface to access the data of a MemoryRepository as a whole, so it can be persisted easily.

type TenantRepository 

type TenantRepository[tID id, E any, eID id] interface {
	NextID(ctx context.Context) (eID, error)

	Create(ctx context.Context, tenantID tID, entity E) error
	Read(ctx context.Context, tenantID tID, id eID) (E, error)
	Update(ctx context.Context, tenantID tID, entity E) error
	Delete(ctx context.Context, tenantID tID, entity E) error

	All(ctx context.Context) ([]E, error)
	AllOfTenant(ctx context.Context, tenantID tID) ([]E, error) // rename AllOf
	AllByIDs(ctx context.Context, tenantID tID, ids []eID) ([]E, error)
	FindAll(ctx context.Context) ([]E, error)
	FindAllOfTenant(ctx context.Context, tenantID tID) ([]E, error)
	FindByID(ctx context.Context, tenantID tID, id eID) (E, error)
	FindByIDs(ctx context.Context, tenantID tID, ids []eID) ([]E, error)
	Exists(ctx context.Context, tenantID tID, id eID) (bool, error)
	ExistsByID(ctx context.Context, tenantID tID, id eID) (bool, error)
	ExistByIDs(ctx context.Context, tenantID tID, ids []eID) (bool, error)
	ExistAll(ctx context.Context, tenantID tID, ids []eID) (bool, error)
	Contains(ctx context.Context, tenantID tID, id eID) (bool, error)
	ContainsID(ctx context.Context, tenantID tID, id eID) (bool, error)
	ContainsIDs(ctx context.Context, tenantID tID, ids []eID) (bool, error)
	ContainsAll(ctx context.Context, tenantID tID, ids []eID) (bool, error)

	Save(ctx context.Context, tenantID tID, entity E) error
	SaveAll(ctx context.Context, tenantID tID, entities []E) error
	UpdateAll(ctx context.Context, tenantID tID, entities []E) error
	Add(ctx context.Context, tenantID tID, entity E) error
	AddAll(ctx context.Context, tenantID tID, entities []E) error

	Count(ctx context.Context) (int, error)
	CountOfTenant(ctx context.Context, tenantID tID) (int, error)
	Length(ctx context.Context) (int, error)
	LengthOfTenant(ctx context.Context, tenantID tID) (int, error)

	DeleteByID(ctx context.Context, tenantID tID, id eID) error
	DeleteByIDs(ctx context.Context, tenantID tID, ids []eID) error
	DeleteAll(ctx context.Context) error
	DeleteAllOfTenant(ctx context.Context, tenantID tID) error
	Clear(ctx context.Context) error
	ClearTenant(ctx context.Context, tenantID tID) error
}

TenantRepository is a general purpose interface documenting which methods are available by the generic MemoryTenantRepository. tID is the primary key for the tenant and eID of the entity and needs to be of one of the underlying types. If your repository needs additional methods, you can extend your own repository easily to tune it to your use case.

type TestAssertions 

type TestAssertions[E any, ID id] struct {
	// contains filtered or unexported fields
}

TestAssertions are assertions that work on a Repository, to make testing easier and convenient. The interface follows stretchr/testify as close as possible.

func TestAssert 

func TestAssert[E any, ID id](t *testing.T, repo Repository[E, ID]) *TestAssertions[E, ID]

TestAssert returns a Repository and TestAssertions tuned for unit testing.

func (*TestAssertions[E, ID]) Empty 

func (a *TestAssertions[E, ID]) Empty(msgAndArgs ...any) bool

Empty asserts that the repository has no entities stored.

func (*TestAssertions[E, ID]) NotEmpty 

func (a *TestAssertions[E, ID]) NotEmpty(msgAndArgs ...any) bool

NotEmpty asserts that the repository has at least one entity stored.

func (*TestAssertions[E, ID]) Total 

func (a *TestAssertions[E, ID]) Total(total int, msgAndArgs ...any) bool

Total asserts that the repository has exactly total number of entities.

type TestRepository 

type TestRepository[E any, ID id] struct {
	Repository[E, ID]
	*TestAssertions[E, ID]
}

TestRepository is a special Repository for unit testing. It exposes all methods of Repository and can be injected as a dependency in any application. Additionally, TestRepository exposes a set of assertions TestAssertions on all the entities stored in the repo.

func Test 

func Test[E any, ID id](t *testing.T, opts ...Option) *TestRepository[E, ID]

Test returns a MemoryRepository tuned for unit testing.

type TestTenantAssertions 

type TestTenantAssertions[tID id, E any, eID id] struct {
	// contains filtered or unexported fields
}

TestTenantAssertions are assertions that work on a TenantRepository, to make testing easier and convenient. The interface follows stretchr/testify as close as possible.

func TestTenantAssert 

func TestTenantAssert[tID id, E any, eID id](t *testing.T, repo TenantRepository[tID, E, eID]) *TestTenantAssertions[tID, E, eID]

TestTenantAssert returns a Repository and TestTenantAssertions tuned for unit testing.

func (*TestTenantAssertions[tID, E, eID]) Empty 

func (a *TestTenantAssertions[tID, E, eID]) Empty(msgAndArgs ...any) bool

Empty asserts that the repository has no entities stored.

func (*TestTenantAssertions[tID, E, eID]) NotEmpty 

func (a *TestTenantAssertions[tID, E, eID]) NotEmpty(msgAndArgs ...any) bool

NotEmpty asserts that the repository has at least one entity stored.

func (*TestTenantAssertions[tID, E, eID]) Total 

func (a *TestTenantAssertions[tID, E, eID]) Total(total int, msgAndArgs ...any) bool

Total asserts that the repository has exactly total number of entities.

type TestTenantRepository 

type TestTenantRepository[tID id, E any, eID id] struct {
	TenantRepository[tID, E, eID]
	*TestTenantAssertions[tID, E, eID]
}

TestTenantRepository is a special TenantRepository for unit testing. It exposes all methods of TenantRepository and can be injected as a dependency in any application. Additionally, TenantRepository exposes a set of assertions TestTenantAssertions on all the entities stored in the repo.

func TestTenant 

func TestTenant[tID id, E any, eID id](t *testing.T, repo TenantRepository[tID, E, eID]) *TestTenantRepository[tID, E, eID]

TestTenant returns a MemoryTenantRepository tuned for unit testing.

Source Files

docs.go inmemory-tenant.repository.go inmemory.repository.go json-store.go postgres.repository.go repository.go store.go tenant.repository.go testing.go

Version
v0.0.0-20250311203644-ab26c1152cb4 (latest)
Published
Mar 11, 2025
Platform
linux/amd64
Imports
23 packages
Last checked
1 day ago –

Tools for package owners.