repository

Documentation

Index

• Constants
• type AggregateType
• type Asset
• type AssetAction
  • func (f AssetAction) Valid() bool
• type Columns
  • func (c Columns) Validate() error
• type Event
• type EventType
• type Field
• type Filter
  • func NewFilter(field Field, value interface{}, operation Operation) *Filter
  • func (f *Filter) Validate() error
• type Operation
• type Repository
• type SearchQuery
• type UniqueConstraint
• type UniqueConstraintAction
  • func (f UniqueConstraintAction) Valid() bool
• type Version
  • func (v Version) Validate() error

Constants

const (
	//ColumnsEvent represents all fields of an event
	ColumnsEvent = iota + 1
	//ColumnsMaxSequence represents the latest sequence of the filtered events
	ColumnsMaxSequence
	// ColumnsInstanceIDs represents the instance ids of the filtered events
	ColumnsInstanceIDs
)

Types

type AggregateType

type AggregateType string

AggregateType is the object name

type Asset

type Asset struct {
	// ID is to refer to the asset
	ID string
	//Asset is the actual image
	Asset []byte
	//Action defines if asset should be added or removed
	Action AssetAction
}

Asset represents all information about a asset (img)

type AssetAction

type AssetAction int32

const (
	AssetAdded AssetAction = iota
	AssetRemoved
)

func (AssetAction) Valid

func (f AssetAction) Valid() bool

type Columns

type Columns int32

Columns defines which fields of the event are needed for the query

func (Columns) Validate

func (c Columns) Validate() error

type Event

type Event struct {
	//ID is a generated uuid for this event
	ID string

	//Sequence is the sequence of the event
	Sequence uint64

	//PreviousAggregateSequence is the sequence of the previous sequence of the aggregate (e.g. org.250989)
	// if it's 0 then it's the first event of this aggregate
	PreviousAggregateSequence uint64

	//PreviousAggregateTypeSequence is the sequence of the previous sequence of the aggregate root (e.g. org)
	// the first event of the aggregate has previous aggregate root sequence 0
	PreviousAggregateTypeSequence uint64

	//CreationDate is the time the event is created
	// it's used for human readability.
	// Don't use it for event ordering,
	// time drifts in different services could cause integrity problems
	CreationDate time.Time

	//Type describes the cause of the event (e.g. user.added)
	// it should always be in past-form
	Type EventType

	//Data describe the changed fields (e.g. userName = "hodor")
	// data must always a pointer to a struct, a struct or a byte array containing json bytes
	Data []byte

	//EditorService should be a unique identifier for the service which created the event
	// it's meant for maintainability
	EditorService string
	//EditorUser should be a unique identifier for the user which created the event
	// it's meant for maintainability.
	// It's recommend to use the aggregate id of the user
	EditorUser string

	//Version describes the definition of the aggregate at a certain point in time
	// it's used in read models to reduce the events in the correct definition
	Version Version
	//AggregateID id is the unique identifier of the aggregate
	// the client must generate it by it's own
	AggregateID string
	//AggregateType describes the meaning of the aggregate for this event
	// it could an object like user
	AggregateType AggregateType
	//ResourceOwner is the organisation which owns this aggregate
	// an aggregate can only be managed by one organisation
	// use the ID of the org
	ResourceOwner sql.NullString
	//InstanceID is the instance where this event belongs to
	// use the ID of the instance
	InstanceID string
}

Event represents all information about a manipulation of an aggregate

type EventType

type EventType string

EventType is the description of the change

type Field

type Field int32

Field is the representation of a field from the event

const (
	//FieldAggregateType represents the aggregate type field
	FieldAggregateType Field = iota + 1
	//FieldAggregateID represents the aggregate id field
	FieldAggregateID
	//FieldSequence represents the sequence field
	FieldSequence
	//FieldResourceOwner represents the resource owner field
	FieldResourceOwner
	//FieldInstanceID represents the instance id field
	FieldInstanceID
	//FieldEditorService represents the editor service field
	FieldEditorService
	//FieldEditorUser represents the editor user field
	FieldEditorUser
	//FieldEventType represents the event type field
	FieldEventType
	//FieldEventData represents the event data field
	FieldEventData
	//FieldCreationDate represents the creation date field
	FieldCreationDate
)

type Filter

type Filter struct {
	Field     Field
	Value     interface{}
	Operation Operation
}

Filter represents all fields needed to compare a field of an event with a value

func NewFilter

func NewFilter(field Field, value interface{}, operation Operation) *Filter

NewFilter is used in tests. Use searchQuery.*Filter() instead

func (*Filter) Validate

func (f *Filter) Validate() error

Validate checks if the fields of the filter have valid values

type Operation

type Operation int32

Operation defines how fields are compared

const (
	// OperationEquals compares two values for equality
	OperationEquals Operation = iota + 1
	// OperationGreater compares if the given values is greater than the stored one
	OperationGreater
	// OperationLess compares if the given values is less than the stored one
	OperationLess
	//OperationIn checks if a stored value matches one of the passed value list
	OperationIn
	//OperationJSONContains checks if a stored value matches the given json
	OperationJSONContains
	//OperationNotIn checks if a stored value does not match one of the passed value list
	OperationNotIn
)

type Repository

type Repository interface {
	//Health checks if the connection to the storage is available
	Health(ctx context.Context) error
	// Push adds all events of the given aggregates to the event streams of the aggregates.
	// if unique constraints are pushed, they will be added to the unique table for checking unique constraint violations
	// This call is transaction save. The transaction will be rolled back if one event fails
	Push(ctx context.Context, events []*Event, uniqueConstraints ...*UniqueConstraint) error
	// Filter returns all events matching the given search query
	Filter(ctx context.Context, searchQuery *SearchQuery) (events []*Event, err error)
	//LatestSequence returns the latest sequence found by the search query
	LatestSequence(ctx context.Context, queryFactory *SearchQuery) (uint64, error)
	//InstanceIDs returns the instance ids found by the search query
	InstanceIDs(ctx context.Context, queryFactory *SearchQuery) ([]string, error)
	//CreateInstance creates a new sequence for the given instance
	CreateInstance(ctx context.Context, instanceID string) error
}

Repository pushes and filters events

type SearchQuery

type SearchQuery struct {
	Columns Columns
	Limit   uint64
	Desc    bool
	Filters [][]*Filter
	Tx      *sql.Tx
}

SearchQuery defines the which and how data are queried

type UniqueConstraint

type UniqueConstraint struct {
	//UniqueField is the field which should be unique
	UniqueField string

	//UniqueType is the type of the unique field
	UniqueType string

	//InstanceID represents the instance
	InstanceID string

	//Action defines if unique constraint should be added or removed
	Action UniqueConstraintAction

	//ErrorMessage is the message key which should be returned if constraint is violated
	ErrorMessage string
}

UniqueCheck represents all information about a unique attribute

type UniqueConstraintAction

type UniqueConstraintAction int32

const (
	UniqueConstraintAdd UniqueConstraintAction = iota
	UniqueConstraintRemoved
)

func (UniqueConstraintAction) Valid

func (f UniqueConstraintAction) Valid() bool

type Version

type Version string

Version represents the semver of an aggregate

func (Version) Validate

func (v Version) Validate() error

Validate checks if the v is semver