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 Match
• type MatchRepository
• 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 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 {
	// NewMatch creates a new Match interactor
	NewMatch() Match
}

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 Match

type Match interface {
	Insert(ctx context.Context, person, details, description, typ string, similarities []string) error

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

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

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

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

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

Match ...

type MatchRepository

type MatchRepository interface {

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

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

	// Query returns existing matchs matching the
	// query provided
	Query(c context.Context, query *Query) []*domain.Match

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

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

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

MatchRepository defines the methods that any data storage provider needs to implement to get and store matchs

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 SecurityFactory

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

SecurityFactory ...

type StorageFactory

type StorageFactory interface {
	// NewMatchRepository returns a storage specific
	// MatchRepository implementation
	NewMatchRepository() MatchRepository

	Close()
}

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