query

type And []Expression

type ElemMatch struct {
	Field string
	Exps  []Expression
}

type Equal struct {
	Field string
	Value Value
}

type Exist struct {
	Field string
}

type Expression interface {
	Match(payload map[string]interface{}) bool
	Prepare(validator schema.Validator) error
	String() string
}

type GreaterOrEqual struct {
	Field string
	Value Value
	// contains filtered or unexported fields
}

type GreaterThan struct {
	Field string
	Value Value
	// contains filtered or unexported fields
}

type In struct {
	Field  string
	Values []Value
}

type LowerOrEqual struct {
	Field string
	Value Value
	// contains filtered or unexported fields
}

type LowerThan struct {
	Field string
	Value Value
	// contains filtered or unexported fields
}

type NotEqual struct {
	Field string
	Value Value
}

type NotExist struct {
	Field string
}

type NotIn struct {
	Field  string
	Values []Value
}

type Or []Expression

type Predicate []Expression

type Projection []ProjectionField

type ProjectionField struct {
	// Name is the name of the field as define in the resource's schema.
	Name string

	// Alias is the wanted name in the representation.
	Alias string

	// Params defines a list of params to be sent to the field's param handler
	// if any.
	Params map[string]interface{}

	// Children holds references to child projections if any.
	Children Projection
}

type Query struct {
	// Projection is the list of fields from the items of the result that should
	// be included in the query response. A projected field can be aliased or
	// given parameters to be passed to per field transformation filters. A
	// projection is hierarchical allow projection of deep structures.
	//
	// A DSL can be used to build the projection structure.
	Projection Projection

	// Predicate defines the criteria an item must meet in order to be
	// considered for inclusion in the result set.
	//
	// A DLS can be used to build a predicate from a MongoDB like expressions.
	Predicate Predicate

	// Sort is a list of fields or sub-fields to use for sorting the result set.
	Sort Sort

	// Window defines result set windowing using an offset and a limit. When
	// nil, the full result-set should be returned.
	Window *Window
}

type Regex struct {
	Field string
	Value *regexp.Regexp
}

type Resource interface {
	// Find executes the query and returns the matching items.
	Find(ctx context.Context, query *Query) ([]map[string]interface{}, error)

	// MultiGet get some items by their id and return them in the same order. If one
	// or more item(s) is not found, their slot in the response is set to nil.
	MultiGet(ctx context.Context, ids []interface{}) ([]map[string]interface{}, error)

	// SubResource returns the sub-resource at path. If path starts with a
	// dot, the lookup is performed relative to the current resource.
	SubResource(ctx context.Context, path string) (Resource, error)

	// Validator returns the schema.Validator associated with the resource.
	Validator() schema.Validator

	// Path returns the full path of the resource composed of names of each
	// intermediate resources separated by dots (i.e.: res1.res2.res3).
	Path() string
}

type Sort []SortField

type SortField struct {
	// Name is the name of the field to sort on.
	Name string

	// Reversed instruct to reverse the sorting if set to true.
	Reversed bool
}

type Value = interface{}

type Window struct {
	// Offset is the 0 based index of the item in the result set to start the
	// window at.
	Offset int

	// Limit is the maximum number of items to return in the result set. A value
	// lower than 0 means no limit.
	Limit int
}