goengine

type AggregateRepository interface {
	Load(string, StreamName) (*EventStream, error)
	Save(AggregateRoot, StreamName) error
	Reconstitute(string, AggregateRoot, StreamName) error
}

type AggregateRoot interface {
	GetID() string
	GetVersion() int
	SetVersion(int)
	Apply(DomainEvent)
	GetUncommittedEvents() []*DomainMessage
}

type AggregateRootBased struct {
	ID string
	// contains filtered or unexported fields
}

type DomainEvent interface {
	OccurredOn() time.Time
}

type DomainMessage struct {
	ID         string      `json:"aggregate_id,omitempty"`
	Version    int         `json:"version"`
	Payload    DomainEvent `json:"payload"`
	RecordedOn time.Time   `json:"recorded_on"`
}

type EventStore interface {
	Append(events *EventStream) error
	GetEventsFor(streamName StreamName, id string) (*EventStream, error)
	FromVersion(streamName StreamName, id string, version int) (*EventStream, error)
	CountEventsFor(streamName StreamName, id string) (int64, error)
}

type EventStream struct {
	Name   StreamName
	Events []*DomainMessage
}

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

type LogHandler func(msg string, fields map[string]interface{}, err error)

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

type PublisherRepository struct {
	EventStore EventStore
	EventBus   VersionedEventPublisher
}

type StreamName string

type TypeRegistry interface {
	GetTypeByName(string) (reflect.Type, bool)
	RegisterAggregate(AggregateRoot, ...interface{})
	RegisterEvents(...interface{})
	RegisterType(interface{})
	Get(string) (interface{}, error)
}

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

type VersionedEventDispatcher interface {
	DispatchEvent(*DomainMessage) error
	RegisterEventHandler(event interface{}, handler VersionedEventHandler)
	RegisterGlobalHandler(handler VersionedEventHandler)
}

type VersionedEventHandler func(*DomainMessage) error

type VersionedEventPublisher interface {
	PublishEvents([]*DomainMessage) error
}

type VersionedEventReceiver interface {
	ReceiveEvents(VersionedEventReceiverOptions) error
}

type VersionedEventReceiverOptions struct {
	TypeRegistry TypeRegistry
	Close        chan chan error
	Error        chan error
	ReceiveEvent chan VersionedEventTransactedAccept
	Exclusive    bool
}

type VersionedEventTransactedAccept struct {
	Event                 *DomainMessage
	ProcessedSuccessfully chan bool
}