repository

type DeleteCommand struct {
	Id interface{}
}

type DeleteFunc func(leikari.ActorContext, interface{}) (interface{}, error)

type DeleteHandler interface {
	Delete(leikari.ActorContext, DeleteCommand) (*DeletedEvent, error)
}

type DeletedEvent struct {
	Id        interface{} `json:"id"`
	Entity    interface{} `json:"entity"`
	Timestamp time.Time   `json:"timestamp,omitempty"`
	Took      int64       `json:"millis,omitempty"`
}

type InsertCommand struct {
	Entity interface{}
}

type InsertFunc func(leikari.ActorContext, interface{}) (interface{}, error)

type InsertHandler interface {
	Insert(leikari.ActorContext, InsertCommand) (*InsertedEvent, error)
}

type InsertedEvent struct {
	Id        interface{} `json:"id"`
	Entity    interface{} `json:"entity"`
	Timestamp time.Time   `json:"timestamp,omitempty"`
	Took      int64       `json:"millis,omitempty"`
}

type QueryFunc func(leikari.ActorContext, query.Query) (*query.QueryResult, error)

type QueryHandler interface {
	Query(leikari.ActorContext, query.Query) (*query.QueryResult, error)
}

type Repository interface {
	InsertHandler
	SelectHandler
	UpdateHandler
	DeleteHandler
	QueryHandler
}

type RepositoryHandler struct {
	OnQuery   QueryFunc
	OnInsert  InsertFunc
	OnSelect  SelectFunc
	OnUpdate  UpdateFunc
	OnDelete  DeleteFunc
	OnStart   func(leikari.ActorContext) error
	OnStop    func(leikari.ActorContext) error
	OnReceive func(leikari.ActorContext, leikari.Message)
	Sync      bool
}

type RepositoryRef interface {
	leikari.Ref

	Insert(interface{}) (*InsertedEvent, error)
	InsertContext(context.Context, interface{}) (*InsertedEvent, error)

	Select(interface{}) (*SelectedEvent, error)
	SelectContext(context.Context, interface{}) (*SelectedEvent, error)

	Update(interface{}, interface{}) (*UpdatedEvent, error)
	UpdateContext(context.Context, interface{}, interface{}) (*UpdatedEvent, error)

	Delete(interface{}) (*DeletedEvent, error)
	DeleteContext(context.Context, interface{}) (*DeletedEvent, error)

	Query(query.Query) (*query.QueryResult, error)
	QueryContext(context.Context, query.Query) (*query.QueryResult, error)
}

type SelectCommand struct {
	Id interface{}
}

type SelectFunc func(leikari.ActorContext, interface{}) (interface{}, error)

type SelectHandler interface {
	Select(leikari.ActorContext, SelectCommand) (*SelectedEvent, error)
}

type SelectedEvent struct {
	Id        interface{} `json:"id"`
	Entity    interface{} `json:"entity"`
	Timestamp time.Time   `json:"timestamp,omitempty"`
	Took      int64       `json:"millis,omitempty"`
}

type UpdateCommand struct {
	Id     interface{}
	Entity interface{}
}

type UpdateFunc func(leikari.ActorContext, interface{}, interface{}) error

type UpdateHandler interface {
	Update(leikari.ActorContext, UpdateCommand) (*UpdatedEvent, error)
}

type UpdatedEvent struct {
	Id        interface{} `json:"id"`
	Entity    interface{} `json:"entity"`
	Timestamp time.Time   `json:"timestamp,omitempty"`
	Took      int64       `json:"millis,omitempty"`
}