aggregate

type Aggregate ¶

type Aggregate interface {
	// Apply applies the specified Event to the Aggregate Root,
	// by causing a state change in the Aggregate Root instance.
	//
	// Since this method cause a state change, implementors should make sure
	// to use pointer semantics on their Aggregate Root method receivers.
	//
	// Please note, this method should not perform any kind of external request
	// and should be, save for the Aggregate Root state mutation, free of side effects.
	// For this reason, this method does not include a context.Context instance
	// in the input parameters.
	Apply(event.Event) error
}

Aggregate is the segregated interface, part of the Aggregate Root interface, that describes the left-folding behavior of Domain Events to update the Aggregate Root state.

type BaseRoot ¶

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

BaseRoot segregates and completes the aggregate.Root interface implementation when embedded to a user-defined Aggregate Root type.

BaseRoot provides some common traits, such as tracking the current Aggregate Root version, and the recorded-but-uncommitted Domain Events, through the aggregate.RecordThat function.

func (br *BaseRoot) FlushRecordedEvents() []event.Envelope

func (br BaseRoot) Version() version.Version

type EventSourcedRepository ¶

type EventSourcedRepository[I ID, T Root[I]] struct {
	// contains filtered or unexported fields
}

EventSourcedRepository provides an aggregate.Repository interface implementation that uses an event.Store to store and load the state of the Aggregate Root.

func NewEventSourcedRepository[I ID, T Root[I]](eventStore event.Store, typ Type[I, T]) EventSourcedRepository[I, T]

func (repo EventSourcedRepository[I, T]) Get(ctx context.Context, id I) (T, error)

func (repo EventSourcedRepository[I, T]) Save(ctx context.Context, root T) error

type Factory ¶

type Factory[I ID, T Root[I]] func() T

Factory is a function that creates new zero-valued instances of an aggregate.Root implementation.

type FusedRepository ¶

type FusedRepository[I ID, T Root[I]] struct {
	Getter[I, T]
	Saver[I, T]
}

FusedRepository is a convenience type that can be used to fuse together different implementations for the Getter and Saver Repository interface components.

type Getter ¶

type Getter[I ID, T Root[I]] interface {
	Get(ctx context.Context, id I) (T, error)
}

Getter is an Aggregate Repository interface component, that can be used for retrieving Aggregate Roots from some storage.

type ID ¶

type ID interface {
	fmt.Stringer
}

ID represents an Aggregate ID type.

Aggregate IDs should be able to be marshaled into a string format, in order to be saved onto a named Event Stream.

type Internal ¶

type Internal interface {
	FlushRecordedEvents() []event.Envelope
}

Internal contains some Aggregate Root methods that are used by internal packages and modules for this library.

Direct usage of these methods are discouraged.

type Repository ¶

type Repository[I ID, T Root[I]] interface {
	Getter[I, T]
	Saver[I, T]
}

Repository is an interface used to get Aggregate Roots from and save them to some kind of storage, depending on the implementation.

type Root ¶

type Root[I ID] interface {
	Aggregate
	Internal

	// AggregateID returns the Aggregate Root identifier.
	AggregateID() I

	// Version returns the current Aggregate Root version.
	// The version gets updated each time a new event is recorded
	// through the aggregate.RecordThat function.
	Version() version.Version
	// contains filtered or unexported methods
}

Root is the interface describing an Aggregate Root instance.

This interface should be implemented by your Aggregate Root types. Make sure your Aggregate Root types embed the aggregate.BaseRoot type to complete the implementation of this interface.

type Saver ¶

type Saver[I ID, T Root[I]] interface {
	Save(ctx context.Context, root T) error
}

Saver is an Aggregate Repository interface component, that can be used for storing Aggregate Roots in some storage.

type ScenarioGiven ¶

type ScenarioGiven[I ID, T Root[I]] struct {
	// contains filtered or unexported fields
}

ScenarioGiven is the state of the scenario once the Aggregate Root preconditions have been set through the Scenario().Given() method.

This state gives access to the When() method to specify the aggregate method to test using the desired Aggregate Root.

func (sc ScenarioGiven[I, T]) When(fn func(T) error) ScenarioWhen[I, T]

type ScenarioInit ¶

type ScenarioInit[I ID, T Root[I]] struct {
	// contains filtered or unexported fields
}

ScenarioInit is the entrypoint of the Aggregate Root scenario API.

An Aggregate Root scenario can either set the current evaluation context by using Given(), or test a "clean-slate" scenario by using When() directly.

func Scenario[I ID, T Root[I]](typ Type[I, T]) ScenarioInit[I, T]

func (sc ScenarioInit[I, T]) Given(events ...event.Persisted) ScenarioGiven[I, T]

func (sc ScenarioInit[I, T]) When(fn func() (T, error)) ScenarioWhen[I, T]

type ScenarioThen ¶

type ScenarioThen[I ID, T Root[I]] struct {
	// contains filtered or unexported fields
}

ScenarioThen is the state of the scenario where all parameters have been set and it's ready to be executed using a testing.T instance.

Use the AssertOn method to run the test scenario.

func (sc ScenarioThen[I, T]) AssertOn(t *testing.T)

type ScenarioWhen ¶

type ScenarioWhen[I ID, T Root[I]] struct {
	// contains filtered or unexported fields
}

ScenarioWhen is the state of the scenario once the aggregate method to test has been provided through either Scenario().When() or Scenario().Given().When() paths.

This state allows to specify the expected outcome on the scenario using either Then(), ThenFails(), ThenError() or ThenErrors() methods.

func (sc ScenarioWhen[I, T]) Then(v version.Version, events ...event.Envelope) ScenarioThen[I, T]

func (sc ScenarioWhen[I, T]) ThenError(err error) ScenarioThen[I, T]

func (sc ScenarioWhen[I, T]) ThenErrors(errs ...error) ScenarioThen[I, T]

func (sc ScenarioWhen[I, T]) ThenFails() ScenarioThen[I, T]

type Type ¶

type Type[I ID, T Root[I]] struct {
	Name    string
	Factory func() T
}

Type represents the type of an Aggregate, which will expose the name of the Aggregate (used as Event Store type).

If your Aggregate implementation uses pointers, use the factory to return a non-nil instance of the type.