engine

Documentation

Index

• type Condition
• type Direction
• type Factory
  • func NewEngine(s StorageFactory) Factory
• type Filter
  • func NewFilter(property string, condition Condition, value interface{}) *Filter
• type JWTSignParser
• type Order
  • func NewOrder(property string, direction Direction) *Order
• type Query
  • func NewQuery(name string) *Query
  • func (q *Query) Filter(property string, condition Condition, value interface{}) *Query
  • func (q *Query) Order(property string, direction Direction) *Query
  • func (q *Query) Slice(offset, limit int) *Query
• type QueryBuilder
• type Reaction
• type ReactionRepository
• type SecurityFactory
• type StorageFactory

Types

type Condition

type Condition byte

Condition represents a filter comparison operation between a field and a value

const (
	// Equal if it should be the same
	Equal Condition = 1 << iota

	// LessThan if it should be smaller
	LessThan

	// LessThanOrEqual if it should be smaller or equal
	LessThanOrEqual

	// GreaterThan if it should be larger
	GreaterThan

	// GreaterThanOrEqual if it should be equal or greater than
	GreaterThanOrEqual
)

type Direction

type Direction byte

Direction represents a query sort direction

const (
	// Ascending means going up, A-Z
	Ascending Direction = 1 << iota

	// Descending means reverse order, Z-A
	Descending
)

type Factory

type Factory interface {
	// NewReaction creates a new Reaction interactor
	NewReaction() Reaction
}

Factory interface allows us to provide other parts of the system with a way to make instances of our use-case / interactors when they need to

func NewEngine

func NewEngine(s StorageFactory) Factory

NewEngine creates a new engine factory that will make use of the passed in StorageFactory for any data persistence needs.

type Filter

type Filter struct {
	Property  string
	Condition Condition
	Value     interface{}
}

Filter represents a filter operation on a single field

func NewFilter

func NewFilter(property string, condition Condition, value interface{}) *Filter

NewFilter creates a new property filter

type JWTSignParser

type JWTSignParser interface {
	Sign(claims map[string]interface{}, secret string) (map[string]interface{}, error)
	Parse(tokenStr string, secret string) (map[string]interface{}, error)
}

JWTSignParser ...

type Order

type Order struct {
	Property  string
	Direction Direction
}

Order represents a sort operation on a single field

func NewOrder

func NewOrder(property string, direction Direction) *Order

NewOrder creates a new query order

type Query

type Query struct {
	Name    string
	Offset  int
	Limit   int
	Filters []*Filter
	Orders  []*Order
}

Query represents a query specification for filtering sorting, paging and limiting the data requested

func NewQuery

func NewQuery(name string) *Query

NewQuery creates a new database query spec. The name is what the storage system should use to identify the types, usually a table or collection name.

func (*Query) Filter

func (q *Query) Filter(property string, condition Condition, value interface{}) *Query

Filter adds a filter to the query

func (*Query) Order

func (q *Query) Order(property string, direction Direction) *Query

Order adds a sort order to the query

func (*Query) Slice

func (q *Query) Slice(offset, limit int) *Query

Slice adds a slice operation to the query

type QueryBuilder

type QueryBuilder interface {
	Filter(property string, value interface{}) QueryBuilder
	Order(property string, direction Direction)
}

QueryBuilder helps with query creation

type Reaction

type Reaction interface {
	Insert(ctx context.Context, id, person, details, description, typ string) error

	// Update is the update-a-reaction use-case
	Update(ctx context.Context, id, person, details, description, typ string) error

	// Query is the list-the-reactions use-case
	Query(ctx context.Context, skip uint64, take uint64) ([]domain.Reaction, error)

	// FindOne ...
	FindOne(ctx context.Context, id string) (*domain.Reaction, error)

	// RemoveDelete ...
	Remove(ctx context.Context, id string) (string, error)

	// ListAllReactiones ...
	ListAllReactiones(ctx context.Context, skip, take uint64) (*[]domain.Reaction, error)
}

Reaction ...

type ReactionRepository

type ReactionRepository interface {

	// Reaction adds a new Reaction to the datastore
	Insert(c context.Context, reaction domain.Reaction) error

	// Put adds a new Reaction to the datastore
	Update(c context.Context, reaction domain.Reaction, id string) error

	// Query returns existing reactions reactioning the
	// query provided
	Query(c context.Context, query *Query) []*domain.Reaction

	// FindOne returns ...
	FindOne(c context.Context, id string) (*domain.Reaction, error)

	// Remove ...
	Remove(c context.Context, id string) (string, error)

	// ListAllReactiones ...
	ListAllReactiones(ctx context.Context, skip uint64, take uint64) ([]domain.Reaction, error)
}

ReactionRepository defines the methods that any data storage provider needs to implement to get and store reactions

type SecurityFactory

type SecurityFactory interface {
	// NewSecurityFactory ...
	NewSecurityFactory() JWTSignParser
}

SecurityFactory ...

type StorageFactory

type StorageFactory interface {
	// NewReactionRepository returns a storage specific
	// ReactionRepository implementation
	NewReactionRepository() ReactionRepository

	Close()
}

StorageFactory is the interface that a storage provider needs to implement so that the engine can request repository instances as it needs them