README

elemental

codecov

README IS A WORK IN PROGRESS AS WE ARE WRITTING MORE DOCUMENTATION ABOUT THIS PACKAGE.

Elemental provides all basic structures and interfaces needed by generated regolithe models.

Expand ▾ Collapse ▴

Documentation

Overview

Package elemental provides a set of interfaces and structures used to manage a model generated from a Regolithe Specifications Set.

If you are not familiar with with Regolithe, please read https://github.com/aporeto-inc/regolithe.

Elemental is the basis of Bahamut (https://github.com/aporeto-inc/bahamut) and Manipulate (https://github.com/aporeto-inc/manipulate).

The main interface it provides is the Identifiable. This interface must be implemented by all object of a model. It allows to identify an object from its Identity (which is a name and category) and by its identifier. It also embeds the Versionable interface that allows to retrieve the current version of the model. The Identifiables interface must be implemented by lists managing a collection of Identifiable entities.

The ModelManager is an interface to perform lookup on Identities, Relationships between them and also allow to instantiate objects based on their Identity.

Elemental also contains some Request/Response structures representing various Operation on Identifiable or Identifiables as well as a bunch of validators to enforce specification constraints on attributes like max length, pattern etc. There is also an Event structure that can be used to notify clients of the the result of an Operation sent through a Request.

Elemental is mainly an abstract package and cannot really be used by itself. You must use the provided command (elegen) to generate an Elemental Model from a Regolithe Specification Set.

Index

Constants

This section is empty.

Variables

var AllIdentity = Identity{
	Name:     "*",
	Category: "*",
}

AllIdentity represents all possible Identities.


var EmptyIdentity = Identity{
	Name:     "",
	Category: "",
}

EmptyIdentity represents an empty Identity.


var RootIdentity = Identity{
	Name:     "root",
	Category: "root",
}

RootIdentity represents an root Identity.


Functions

func AtomicJob

func AtomicJob(job func() error) func(context.Context) error

AtomicJob takes a func() error and returns a func(context.Context) error. The returned function can be called as many time as you like, but only one instance of the given job can be run at the same time.

The returned function will either execute job if it it not already running or wait for the currently running job to finish. In both cases, the returned error from the job will be forwareded and returned to every caller.

You must pass a context.Context to the returned function so you can control how much time you are willing to wait for the job to complete.

If you wish to change some external state from within the job function, it is your responsibility to ensure everything is thread safe.

func BackportUnexposedFields

func BackportUnexposedFields(src, dest AttributeSpecifiable)

BackportUnexposedFields copy the values of unexposed fields from src to dest.

func Convert

func Convert(from EncodingType, to EncodingType, data []byte) ([]byte, error)

Convert converts from one EncodingType to another

func Decode

func Decode(encoding EncodingType, data []byte, dest interface{}) error

Decode decodes the given data using an appropriate decoder chosen from the given contentType.

func Encode

func Encode(encoding EncodingType, obj interface{}) ([]byte, error)

Encode encodes the given object using an appropriate encoder chosen from the given acceptType.

func EncodingFromHeaders

func EncodingFromHeaders(header http.Header) (read EncodingType, write EncodingType, err error)

EncodingFromHeaders returns the read (Content-Type) and write (Accept) encoding from the given http.Header.

func IsErrorWithCode

func IsErrorWithCode(err error, code int) bool

IsErrorWithCode returns true if the given error is an elemental.Error or elemental.Errors with the status set to the given code.

func IsOperationAllowed

func IsOperationAllowed(registry RelationshipsRegistry, i Identity, pid Identity, op Operation) bool

IsOperationAllowed returns true if given operatation on the given identity with the given parent is allowed.

func IsValidationError

func IsValidationError(err error, title string, attribute string) bool

IsValidationError returns true if the given error is a validation error with the given title for the given attribute.

func IsZero

func IsZero(o interface{}) bool

IsZero returns true if the given value is set to its Zero value.

func MatchesFilter

func MatchesFilter(identifiable AttributeSpecifiable, filter *Filter, opts ...MatcherOption) (bool, error)

MatchesFilter determines whether an identity matches a filter

func RegisterSupportedAcceptType

func RegisterSupportedAcceptType(mimetype string)

RegisterSupportedAcceptType registers a new media type that elemental should support for Accept. Note that this needs external intervention to handle decoding.

func RegisterSupportedContentType

func RegisterSupportedContentType(mimetype string)

RegisterSupportedContentType registers a new media type that elemental should support for Content-Type. Note that this needs external intervention to handle encoding.

func RemoveZeroValues

func RemoveZeroValues(obj interface{})

RemoveZeroValues reset all pointer fields that are pointing to a zero value to nil

func ResetDefaultForZeroValues

func ResetDefaultForZeroValues(obj interface{})

ResetDefaultForZeroValues reset the default value from the specification when a field is Zero. If the given object is not an elemental.AttributeSpecifiable this function does nothing.

func ResetMaps

func ResetMaps(v reflect.Value)

ResetMaps recursively empty all kinds of maps in the given reflect.Value.

func ResetSecretAttributesValues

func ResetSecretAttributesValues(obj interface{})

ResetSecretAttributesValues will reset any attributes marked as `secret` in the given obj if it is an elemental.Identifiable or an elemental.Identifiables. The given Identifiables must implement the elemental.AttributeSpecifiable interface or this function will have no effect.

If you pass anything else, this function does nothing.

func ValidateAdvancedSpecification

func ValidateAdvancedSpecification(obj AttributeSpecifiable, pristine AttributeSpecifiable, op Operation) error

ValidateAdvancedSpecification verifies advanced specifications attributes like ReadOnly and CreationOnly.

For instance, it will check if the given Manipulable has field marked as readonly, that it has not changed according to the db.

func ValidateFloatInList

func ValidateFloatInList(attribute string, value float64, enums []float64) error

ValidateFloatInList validates if the string is in the list.

func ValidateFloatInMap

func ValidateFloatInMap(attribute string, value float64, enums map[float64]interface{}) error

ValidateFloatInMap validates if the string is in the list.

func ValidateIntInList

func ValidateIntInList(attribute string, value int, enums []int) error

ValidateIntInList validates if the string is in the list.

func ValidateIntInMap

func ValidateIntInMap(attribute string, value int, enums map[int]interface{}) error

ValidateIntInMap validates if the string is in the list.

func ValidateMaximumFloat

func ValidateMaximumFloat(attribute string, value float64, max float64, exclusive bool) error

ValidateMaximumFloat validates a float against a maximum value.

func ValidateMaximumInt

func ValidateMaximumInt(attribute string, value int, max int, exclusive bool) error

ValidateMaximumInt validates a integer against a maximum value.

func ValidateMaximumLength

func ValidateMaximumLength(attribute string, value string, max int, exclusive bool) error

ValidateMaximumLength validates the maximum length of a string.

func ValidateMinimumFloat

func ValidateMinimumFloat(attribute string, value float64, min float64, exclusive bool) error

ValidateMinimumFloat validates a float against a maximum value.

func ValidateMinimumInt

func ValidateMinimumInt(attribute string, value int, min int, exclusive bool) error

ValidateMinimumInt validates a integer against a maximum value.

func ValidateMinimumLength

func ValidateMinimumLength(attribute string, value string, min int, exclusive bool) error

ValidateMinimumLength validates the minimum length of a string.

func ValidatePattern

func ValidatePattern(attribute string, value string, pattern string, message string, required bool) error

ValidatePattern validates a string against a regular expression.

func ValidateRequiredExternal

func ValidateRequiredExternal(attribute string, value interface{}) error

ValidateRequiredExternal validates if the given value is null or not

func ValidateRequiredFloat

func ValidateRequiredFloat(attribute string, value float64) error

ValidateRequiredFloat validates is the int is set to 0.

func ValidateRequiredInt

func ValidateRequiredInt(attribute string, value int) error

ValidateRequiredInt validates is the int is set to 0.

func ValidateRequiredString

func ValidateRequiredString(attribute string, value string) error

ValidateRequiredString validates if the string is empty.

func ValidateRequiredTime

func ValidateRequiredTime(attribute string, value time.Time) error

ValidateRequiredTime validates if the time is empty.

func ValidateStringInList

func ValidateStringInList(attribute string, value string, enums []string, autogenerated bool) error

ValidateStringInList validates if the string is in the list.

func ValidateStringInMap

func ValidateStringInMap(attribute string, value string, enums map[string]interface{}, autogenerated bool) error

ValidateStringInMap validates if the string is in the list.

Types

type AttributeEncryptable

type AttributeEncryptable interface {
	EncryptAttributes(encrypter AttributeEncrypter) error
	DecryptAttributes(encrypter AttributeEncrypter) error
}

AttributeEncryptable is the interface of on object that has encryptable

type AttributeEncrypter

type AttributeEncrypter interface {

	// EncryptString encrypts the given string and returns the encrypted version.
	EncryptString(string) (string, error)

	// DecryptString decrypts the given string and returns the encrypted version.
	DecryptString(string) (string, error)
}

AttributeEncrypter is the interface that must be implement to manage encrypted attributes.

func NewAESAttributeEncrypter

func NewAESAttributeEncrypter(passphrase string) (AttributeEncrypter, error)

NewAESAttributeEncrypter returns a new elemental.AttributeEncrypter implementing AES encryption.

type AttributeSpecifiable

type AttributeSpecifiable interface {

	// SpecificationForAttribute returns the AttributeSpecification for
	// given attribute name
	SpecificationForAttribute(string) AttributeSpecification

	// AttributeSpecifications returns all the AttributeSpecification mapped by
	// attribute name
	AttributeSpecifications() map[string]AttributeSpecification

	// ValueForAttribute returns the value for the given attribute
	ValueForAttribute(name string) interface{}
}

An AttributeSpecifiable is the interface an object must implement in order to access specification of its attributes.

type AttributeSpecification

type AttributeSpecification struct {

	// AllowedChars is a regexp that will be used to validate
	// what value a string attribute can take.
	//
	// This is enforced by elemental.
	AllowedChars string

	// AllowedChoices is a list of possible values for an attribute.
	//
	// This is enforced by elemental.
	AllowedChoices []string

	// Autogenerated defines if the attribute is autogenerated by the server.
	// It can be used in conjunction with ReadOnly.
	//
	// This is not enforced by elemental. You must write your own business logic to honor this.
	Autogenerated bool

	// Availability is reserved for later use.
	Availability string

	// ConvertedName contains the name after local conversion.
	ConvertedName string

	// Channel is reserved for later use.
	Channel string

	// CreationOnly defines if the attribute can be set only during creation.
	//
	// This is not enforced by elemental. You must write your own business logic to honor this.
	CreationOnly bool

	// DefaultValue holds the default value declared in specification.
	DefaultValue interface{}

	// Deprecated defines if the attribute is deprecated.
	Deprecated bool

	// Description contains the description of the attribute.
	Description string

	// Exposed defines if the attribute is exposed through the north bound API.
	Exposed bool

	// Filterable defines if it is possible to filter based on this attribute.
	//
	// This is not enforced by elemental. You must write your own business logic to honor this.
	Filterable bool

	// ForeignKey defines if the attribute is a foreign key.
	ForeignKey bool

	// Getter defines if the attribute needs to define a getter method.
	// This is useful if you can to define an Interface based on this attribute.
	Getter bool

	// Identifier defines if the attribute is used the access key from the
	// northbound API.
	Identifier bool

	// Index defines if the attribute is indexed or not.
	//
	// This is not enforced by elemental. You must write your own business logic to honor this.
	Index bool

	// MaxLength defines what is the maximun length of the attribute.
	// This only makes sense if the type is a string.
	//
	// This is enforced by elemental.
	MaxLength uint

	// MaxValue defines what is the maximun value of the attribute.
	// This only makes sense if the type has a numeric type.
	//
	// This is enforced by elemental.
	MaxValue float64

	// MinLength defines what is the minimum length of the attribute.
	// This only makes sense if the type is a string.
	//
	// This is enforced by elemental.
	MinLength uint

	// MinValue defines what is the minimum value of the attribute.
	// This only makes sense if the type has a numeric type.
	//
	// This is enforced by elemental.
	MinValue float64

	// Name defines what is the name of the attribute.
	// This will be the raw Monolithe Specification name, without
	// Go translation.
	Name string

	// Orderable defines if it is possible to order based on the value of this attribute.
	//
	// This is not enforced by elemental. You must write your own business logic to honor this.
	Orderable bool

	// PrimaryKey defines if the attribute is used as a primary key.
	PrimaryKey bool

	// ReadOnly defines if the attribute is read only.
	//
	// This is not enforced by elemental. You must write your own business logic to honor this.
	ReadOnly bool

	// Required defines is the attribute must be set or not.
	//
	// This is enforced by elemental.
	Required bool

	// Secret defines if the attribute is secret.
	// This is useful if you can to define perform sanity check on this field to be sure it
	// is not sent for instance.
	Secret bool

	// Setter defines if the attribute needs to define a setter method.
	// This is useful if you can to define an Interface based on this attribute.
	Setter bool

	// Stored defines if the attribute will be stored in the northbound API.
	//
	// If this is true, the backend tags will be generated by Monolithe.
	Stored bool

	// SubType defines the Monolithe Subtype.
	SubType string

	// Transient defines if the attributes is transient or not.
	//
	// This is not enforced by elemental. You must write your own business logic to honor this.
	Transient bool

	// Type defines the raw Monolithe type.
	Type string

	// Encrypted defines if the attribute needs encryption.
	Encrypted bool
}

An AttributeSpecification represents all the metadata of an attribute.

This information is coming from the Monolithe Specifications.

type Decoder

type Decoder interface {
	Decode(dst interface{}) error
	Encodable
}

A Decoder is an Encodable that can be decoded.

type DefaultOrderer

type DefaultOrderer interface {

	// Default order returns the keys that can be used for default ordering.
	DefaultOrder() []string
}

DefaultOrderer is the interface of an object that has default ordering fields.

type Documentable

type Documentable interface {
	Doc() string
}

A Documentable is an object that can be documented.

type Encodable

type Encodable interface {
	GetEncoding() EncodingType
}

An Encodable is the interface of objects that can hold encoding information.

type Encoder

type Encoder interface {
	Encode(obj interface{}) (err error)
	Encodable
}

A Encoder is an Encodable that can be encoded.

type EncodingType

type EncodingType string

An EncodingType represents one type of data encoding

const (
	EncodingTypeJSON    EncodingType = "application/json"
	EncodingTypeMSGPACK EncodingType = "application/msgpack"
)

Various values for EncodingType.

type ErrUnsupportedComparator

type ErrUnsupportedComparator struct {
	Err error
}

ErrUnsupportedComparator is the error type that will be returned in the event that that an unsupported comparator is used in the filter.

func (ErrUnsupportedComparator) Error

func (e ErrUnsupportedComparator) Error() string

func (ErrUnsupportedComparator) Is

func (e ErrUnsupportedComparator) Is(err error) bool

Is reports whether the provided error has the same type as ErrUnsupportedComparator. This was added as part of the new error handling APIs added to Go 1.13

func (ErrUnsupportedComparator) Unwrap

func (e ErrUnsupportedComparator) Unwrap() error

Unwrap returns the embedded error in ErrUnsupportedComparator.

type Error

type Error struct {
	Code        int         `msgpack:"code" json:"code,omitempty"`
	Description string      `msgpack:"description" json:"description"`
	Subject     string      `msgpack:"subject" json:"subject"`
	Title       string      `msgpack:"title" json:"title"`
	Data        interface{} `msgpack:"data" json:"data,omitempty"`
	Trace       string      `msgpack:"trace" json:"trace,omitempty"`
}

An Error represents a computational error.

They can be encoded and sent back to the clients.

func NewError

func NewError(title, description, subject string, code int) Error

NewError returns a new Error.

func NewErrorWithData

func NewErrorWithData(title, description, subject string, code int, data interface{}) Error

NewErrorWithData returns a new Error with the given opaque data.

func (Error) Error

func (e Error) Error() string

type Errors

type Errors []Error

Errors represents a list of Error.

func DecodeErrors

func DecodeErrors(data []byte) (Errors, error)

DecodeErrors decodes the given bytes into a en elemental.Errors.

func NewErrors

func NewErrors(errors ...error) Errors

NewErrors creates a new Errors.

func (Errors) Append

func (e Errors) Append(errs ...error) Errors

Append returns returns a copy of the receiver containing also the given errors.

func (Errors) Code

func (e Errors) Code() int

Code returns the code of the first error code in the Errors.

func (Errors) Error

func (e Errors) Error() string

func (Errors) Trace

func (e Errors) Trace(id string) Errors

Trace returns Errors with all inside Error marked with the given trace ID.

type Event

type Event struct {
	RawData   []byte          `msgpack:"entity" json:"-"`
	JSONData  json.RawMessage `msgpack:"-" json:"entity"`
	Identity  string          `msgpack:"identity" json:"identity"`
	Type      EventType       `msgpack:"type" json:"type"`
	Timestamp time.Time       `msgpack:"timestamp" json:"timestamp"`
	Encoding  EncodingType    `msgpack:"encoding" json:"encoding"`
}

An Event represents a computational event.

func NewErrorEvent

func NewErrorEvent(ee Error, encoding EncodingType) *Event

NewErrorEvent returns a new (error) Event embedded with the provided elemental.Error

func NewEvent

func NewEvent(t EventType, o Identifiable) *Event

NewEvent returns a new Event.

func NewEventWithEncoding

func NewEventWithEncoding(t EventType, o Identifiable, encoding EncodingType) *Event

NewEventWithEncoding returns a new Event using the given encoding

func (*Event) Convert

func (e *Event) Convert(encoding EncodingType) error

Convert converts the internal encoded data to the given encoding.

func (*Event) Decode

func (e *Event) Decode(dst interface{}) error

Decode decodes the data into the given destination.

func (*Event) Duplicate

func (e *Event) Duplicate() *Event

Duplicate creates a copy of the event.

func (*Event) Entity

func (e *Event) Entity() []byte

Entity returns the byte encoded entity.

func (*Event) GetEncoding

func (e *Event) GetEncoding() EncodingType

GetEncoding returns the encoding used to encode the entity.

func (*Event) String

func (e *Event) String() string

type EventType

type EventType string

EventType is the type of an event.

const (
	// EventCreate is the type of creation events.
	EventCreate EventType = "create"

	// EventUpdate is the type of update events.
	EventUpdate EventType = "update"

	// EventDelete is the type of delete events.
	EventDelete EventType = "delete"

	// EventError is the type of error events.
	EventError EventType = "error"
)

type Events

type Events []*Event

An Events represents a list of Event.

func NewEvents

func NewEvents(events ...*Event) Events

NewEvents retutns a new Events.

type Filter

type Filter struct {
	// contains filtered or unexported fields
}

Filter is a filter struct which can be used with Cassandra

func NewFilter

func NewFilter() *Filter

NewFilter returns a new filter.

func NewFilterFromString

func NewFilterFromString(filter string) (*Filter, error)

NewFilterFromString returns a new filter computed from the given string.

func (*Filter) And

func (f *Filter) And(filters ...*Filter) FilterKeyComposer

And adds a new sub filter to FilterComposer.

func (*Filter) AndFilters

func (f *Filter) AndFilters() SubFilters

AndFilters returns the current and sub filters.

func (*Filter) Comparators

func (f *Filter) Comparators() FilterComparators

Comparators returns the current comparators.

func (*Filter) Contains

func (f *Filter) Contains(values ...interface{}) FilterKeyComposer

Contains adds a contains comparator to the FilterComposer.

func (*Filter) Done

func (f *Filter) Done() *Filter

Done terminates the filter composition and returns the *Filter.

func (*Filter) Equals

func (f *Filter) Equals(value interface{}) FilterKeyComposer

Equals adds a an equality comparator to the FilterComposer.

func (*Filter) Exists

func (f *Filter) Exists() FilterKeyComposer

Exists adds an exists comparator to the FilterComposer.

func (*Filter) GreaterOrEqualThan

func (f *Filter) GreaterOrEqualThan(value interface{}) FilterKeyComposer

GreaterOrEqualThan adds a greater than (inclusive) comparator to the FilterComposer.

func (*Filter) GreaterThan

func (f *Filter) GreaterThan(value interface{}) FilterKeyComposer

GreaterThan adds a greater than (exclusive) comparator to the FilterComposer.

func (*Filter) In

func (f *Filter) In(values ...interface{}) FilterKeyComposer

In adds a in comparator to the FilterComposer.

func (*Filter) Keys

func (f *Filter) Keys() FilterKeys

Keys returns the current keys.

func (*Filter) LesserOrEqualThan

func (f *Filter) LesserOrEqualThan(value interface{}) FilterKeyComposer

LesserOrEqualThan adds a lesser than (inclusive) comparator to the FilterComposer.

func (*Filter) LesserThan

func (f *Filter) LesserThan(value interface{}) FilterKeyComposer

LesserThan adds a lesser than (exclusive) comparator to the FilterComposer.

func (*Filter) Matches

func (f *Filter) Matches(values ...interface{}) FilterKeyComposer

Matches adds a match comparator to the FilterComposer.

func (*Filter) NotContains

func (f *Filter) NotContains(values ...interface{}) FilterKeyComposer

NotContains adds a contains comparator to the FilterComposer.

func (*Filter) NotEquals

func (f *Filter) NotEquals(value interface{}) FilterKeyComposer

NotEquals adds a an non equality comparator to the FilterComposer.

func (*Filter) NotExists

func (f *Filter) NotExists() FilterKeyComposer

NotExists adds an not exist comparator to the FilterComposer.

func (*Filter) NotIn

func (f *Filter) NotIn(values ...interface{}) FilterKeyComposer

NotIn adds a not in comparator to the FilterComposer.

func (*Filter) Operators

func (f *Filter) Operators() FilterOperators

Operators returns the current operators.

func (*Filter) Or

func (f *Filter) Or(filters ...*Filter) FilterKeyComposer

Or adds a new sub filter to FilterComposer.

func (*Filter) OrFilters

func (f *Filter) OrFilters() SubFilters

OrFilters returns the current ors sub filters.

func (*Filter) String

func (f *Filter) String() string

func (*Filter) Values

func (f *Filter) Values() FilterValues

Values returns the current values.

func (*Filter) WithKey

func (f *Filter) WithKey(key string) FilterValueComposer

WithKey adds a key to FilterComposer.

type FilterComparator

type FilterComparator int

An FilterComparator is the type of a operator used by a filter.

const (
	EqualComparator FilterComparator = iota
	NotEqualComparator
	GreaterComparator
	GreaterOrEqualComparator
	LesserComparator
	LesserOrEqualComparator
	InComparator
	NotInComparator
	ContainComparator
	NotContainComparator
	MatchComparator
	NotMatchComparator
	ExistsComparator
	NotExistsComparator
)

Comparators represent various comparison operations.

type FilterComparators

type FilterComparators []FilterComparator

FilterComparators are a list of FilterOperator.

type FilterKeyComposer

type FilterKeyComposer interface {
	WithKey(string) FilterValueComposer

	And(...*Filter) FilterKeyComposer
	Or(...*Filter) FilterKeyComposer

	Done() *Filter
}

FilterKeyComposer composes a filter.

func NewFilterComposer

func NewFilterComposer() FilterKeyComposer

NewFilterComposer returns a FilterComposer.

type FilterKeys

type FilterKeys []string

FilterKeys represents a list of FilterKey.

type FilterOperator

type FilterOperator int

An FilterOperator is the type of a operator used by a filter.

const (
	AndOperator FilterOperator = iota
	OrFilterOperator
	AndFilterOperator
)

Operators represent various operators.

type FilterOperators

type FilterOperators []FilterOperator

FilterOperators are a list of FilterOperator.

type FilterParser

type FilterParser struct {
	// contains filtered or unexported fields
}

FilterParser represents a Parser

func NewFilterParser

func NewFilterParser(input string, opts ...FilterParserOption) *FilterParser

NewFilterParser returns an instance of FilterParser for the given input

func (*FilterParser) Parse

func (p *FilterParser) Parse() (*Filter, error)

Parse parses the input string and returns a new Filter.

type FilterParserOption

type FilterParserOption func(*filterParserConfig)

FilterParserOption represents the type for the options that can be passed to `NewFilterParser` which can be used to alter parsing behaviour

func OptUnsupportedComparators

func OptUnsupportedComparators(blacklist []FilterComparator) FilterParserOption

OptUnsupportedComparators accepts a slice of comparators that will limit the set of comparators that the parser will accept. If supplied, the parser will return an error if the filter being parsed contains a comparator provided in the blacklist.

type FilterValue

type FilterValue []interface{}

FilterValue represents a filter value.

type FilterValueComposer

type FilterValueComposer interface {
	Equals(interface{}) FilterKeyComposer
	NotEquals(interface{}) FilterKeyComposer
	GreaterOrEqualThan(interface{}) FilterKeyComposer
	GreaterThan(interface{}) FilterKeyComposer
	LesserOrEqualThan(interface{}) FilterKeyComposer
	LesserThan(interface{}) FilterKeyComposer
	In(...interface{}) FilterKeyComposer
	NotIn(...interface{}) FilterKeyComposer
	Contains(...interface{}) FilterKeyComposer
	NotContains(...interface{}) FilterKeyComposer
	Matches(...interface{}) FilterKeyComposer
	Exists() FilterKeyComposer
	NotExists() FilterKeyComposer
}

FilterValueComposer adds values and operators.

type FilterValues

type FilterValues [][]interface{}

FilterValues represents a list of FilterValue.

type Identifiable

type Identifiable interface {

	// Identity returns the Identity of the of the receiver.
	Identity() Identity

	// Identifier returns the unique identifier of the of the receiver.
	Identifier() string

	// SetIdentifier sets the unique identifier of the of the receiver.
	SetIdentifier(string)

	Versionable
}

An Identifiable is the interface that Elemental objects must implement.

type Identifiables

type Identifiables interface {
	Identity() Identity
	List() IdentifiablesList
	Copy() Identifiables
	Append(...Identifiable) Identifiables
	Versionable
}

Identifiables is the interface of a list of Identifiable that can returns the Identity of the objects it contains.

type IdentifiablesList

type IdentifiablesList []Identifiable

An IdentifiablesList is a list of objects implementing the Identifiable interface.

type Identity

type Identity struct {
	Name     string `msgpack:"name" json:"name"`
	Category string `msgpack:"category" json:"category"`
	Private  bool   `msgpack:"-" json:"-"`
	Package  string `msgpack:"-" json:"-"`
}

An Identity is a structure that contains the necessary information about an Identifiable. The Name is usually the singular form of the Category.

For instance, "cat" and "cats".

func MakeIdentity

func MakeIdentity(name, category string) Identity

MakeIdentity returns a new Identity.

func (Identity) IsEmpty

func (i Identity) IsEmpty() bool

IsEmpty checks if the identity is empty.

func (Identity) IsEqual

func (i Identity) IsEqual(identity Identity) bool

IsEqual checks if the given identity is equal to the receiver.

func (Identity) String

func (i Identity) String() string

String returns the string representation of the identity.

type MatcherError

type MatcherError struct {
	Err error
}

MatcherError is the error type that will be returned by elemental.MatchesFilter in the event that it returns an error

func (*MatcherError) Error

func (me *MatcherError) Error() string

func (*MatcherError) Unwrap

func (me *MatcherError) Unwrap() error

Unwrap returns the the error contained in 'MatcherError'. This is a special method that aids in error handling for clients using Go 1.13 and beyond as they can now utilize the new 'Is' function added to the 'errors' package.

type MatcherOption

type MatcherOption func(*matchConfig)

MatcherOption represents the type for the options that can be passed to the helper `MatchesFilter` which can be used to alter the matching behaviour

type ModelManager

type ModelManager interface {

	// Identifiable returns an Identifiable with the given identity.
	Identifiable(Identity) Identifiable

	// SparseIdentifiable returns a SparseIdentifiable with the given identity.
	SparseIdentifiable(Identity) SparseIdentifiable

	// IdentifiableFromString returns an Identifiable from the given
	// string. The string can be an Identity name, category or alias.
	IdentifiableFromString(string) Identifiable

	// Identifiables returns an Identifiables with the given identity.
	Identifiables(Identity) Identifiables

	// SparseIdentifiables returns an Identifiables with the given identity.
	SparseIdentifiables(Identity) SparseIdentifiables

	// IdentifiablesFrom returns an Identifiables from the given
	// string. The string can be an Identity name, category or alias.
	IdentifiablesFromString(string) Identifiables

	// IdentityFromName returns the Identity from the given name.
	IdentityFromName(string) Identity

	// IdentityFromCategory returns the Identity from the given category.
	IdentityFromCategory(string) Identity

	// IdentityFromAlias returns the Identity from the given alias.
	IdentityFromAlias(string) Identity

	// IdentityFromAny returns the Identity from the given name, category or alias.
	IdentityFromAny(string) Identity

	// IndexesForIdentity returns the indexes of the given Identity.
	Indexes(Identity) [][]string

	// Relationships return the model's elemental.RelationshipsRegistry.
	Relationships() RelationshipsRegistry
}

An ModelManager is the interface that allows to search Identities and create Identifiable and Identifiables from Identities.

type Operation

type Operation string

Operation represents an operation to apply on an Identifiable from a Request.

const (
	OperationRetrieveMany Operation = "retrieve-many"
	OperationRetrieve     Operation = "retrieve"
	OperationCreate       Operation = "create"
	OperationUpdate       Operation = "update"
	OperationDelete       Operation = "delete"
	OperationPatch        Operation = "patch"
	OperationInfo         Operation = "info"

	OperationEmpty Operation = ""
)

Here are the existing Operations.

func ParseOperation

func ParseOperation(op string) (Operation, error)

ParseOperation parses the given string as an Operation.

type Parameter

type Parameter struct {
	// contains filtered or unexported fields
}

A Parameter represent one parameter that can be sent with a query.

func NewParameter

func NewParameter(ptype ParameterType, values ...interface{}) Parameter

NewParameter returns a new Parameter.

func (Parameter) BoolValue

func (p Parameter) BoolValue() bool

BoolValue returns the value as a bool.

func (Parameter) BoolValues

func (p Parameter) BoolValues() []bool

BoolValues returns all the values as a []bool.

func (Parameter) DurationValue

func (p Parameter) DurationValue() time.Duration

DurationValue returns the value as a time.Duration.

func (Parameter) DurationValues

func (p Parameter) DurationValues() []time.Duration

DurationValues returns all the values as a []time.Duration.

func (Parameter) FloatValue

func (p Parameter) FloatValue() float64

FloatValue returns the value as a float.

func (Parameter) FloatValues

func (p Parameter) FloatValues() []float64

FloatValues returns all the values as a []float64.

func (Parameter) IntValue

func (p Parameter) IntValue() int

IntValue returns the value as a int.

func (Parameter) IntValues

func (p Parameter) IntValues() []int

IntValues returns all the values as a []int.

func (Parameter) StringValue

func (p Parameter) StringValue() string

StringValue returns the value as a string.

func (Parameter) StringValues

func (p Parameter) StringValues() []string

StringValues returns all the values as a []string.

func (Parameter) TimeValue

func (p Parameter) TimeValue() time.Time

TimeValue returns the value as a time.Time.

func (Parameter) TimeValues

func (p Parameter) TimeValues() []time.Time

TimeValues returns all the values as a []time.Time.

func (Parameter) Values

func (p Parameter) Values() []interface{}

Values returns all the parsed values

type ParameterDefinition

type ParameterDefinition struct {
	Name           string
	Type           ParameterType
	AllowedChoices []string
	DefaultValue   string
	Multiple       bool
}

A ParameterDefinition represent a parameter definition that can be transformed into a Parameter.

func ParametersForOperation

func ParametersForOperation(registry RelationshipsRegistry, i Identity, pid Identity, op Operation) []ParameterDefinition

ParametersForOperation returns the parameters defined for the retrieve operation on the given identity.

func (*ParameterDefinition) Parse

func (p *ParameterDefinition) Parse(values []string) (*Parameter, error)

Parse parses the given value against the parameter definition

type ParameterType

type ParameterType string

ParameterType represents the various type for a parameter.

const (
	ParameterTypeString   ParameterType = "string"
	ParameterTypeInt      ParameterType = "integer"
	ParameterTypeFloat    ParameterType = "float"
	ParameterTypeBool     ParameterType = "boolean"
	ParameterTypeEnum     ParameterType = "enum"
	ParameterTypeTime     ParameterType = "time"
	ParameterTypeDuration ParameterType = "duration"
)

Various values for ParameterType.

type Parameters

type Parameters map[string]Parameter

Parameters represents a set of Parameters.

func (Parameters) Get

func (p Parameters) Get(name string) Parameter

Get returns the Parameter with the given name

func (Parameters) Validate

func (p Parameters) Validate(r ParametersRequirement) error

Validate validates if the Parameters matches the given requirement.

type ParametersRequirement

type ParametersRequirement struct {
	// contains filtered or unexported fields
}

A ParametersRequirement represents a list of ands of list of ors that must be passed together.

func NewParametersRequirement

func NewParametersRequirement(match [][][]string) ParametersRequirement

NewParametersRequirement returns a new ParametersRequirement.

func (ParametersRequirement) String

func (r ParametersRequirement) String() string

type Patchable

type Patchable interface {

	// Patch patches the receiver using the given SparseIdentifiable.
	Patch(SparseIdentifiable)
}

A Patchable the interface of an object that can be patched.

type PlainIdentifiable

type PlainIdentifiable interface {

	// ToSparse returns a sparsed version of the object.
	ToSparse(...string) SparseIdentifiable

	Identifiable
}

A PlainIdentifiable is the interface of an object that can return a sparse version of itself.

type PlainIdentifiables

type PlainIdentifiables interface {

	// ToSparse returns a sparsed version of the object.
	ToSparse(...string) Identifiables

	Identifiables
}

A PlainIdentifiables is the interface of an object that can return a sparse version of itself.

type PushConfig

type PushConfig struct {
	Identities      map[string][]EventType `msgpack:"identities" json:"identities"`
	IdentityFilters map[string]string      `msgpack:"filters"    json:"filters"`
	Params          url.Values             `msgpack:"parameters" json:"parameters"`
	// contains filtered or unexported fields
}

A PushConfig represents an abstract filter for filtering out push notifications.

The 'IdentityFilters' field is a mapping between a filtered identity and the string representation of an elemental.Filter. A client will supply this attribute if they want fine-grained filtering on the set of identities that they are filtering on. If this attribute has been supplied, the identities passed to 'IdentityFilters' must be a subset of the identities passed to 'Identities'; passing in identities that are not provided in the 'Identities' field will be ignored.

func NewPushConfig

func NewPushConfig() *PushConfig

NewPushConfig returns a new PushConfig.

func (*PushConfig) Duplicate

func (pc *PushConfig) Duplicate() *PushConfig

Duplicate duplicates the PushConfig.

func (*PushConfig) FilterForIdentity

func (pc *PushConfig) FilterForIdentity(identityName string) (*Filter, bool)

FilterForIdentity returns the associated fine-grained filter for the given identity. In the event that no fine-grained filter has been configured for the identity, the second return value (a boolean), will be set to false.

func (*PushConfig) FilterIdentity

func (pc *PushConfig) FilterIdentity(identityName string, eventTypes ...EventType)

FilterIdentity adds the given identity for the given eventTypes in the PushConfig.

func (*PushConfig) IsFilteredOut

func (pc *PushConfig) IsFilteredOut(identityName string, eventType EventType) bool

IsFilteredOut returns true if the given Identity is not part of the PushConfig's Identity mapping

func (*PushConfig) Parameters

func (pc *PushConfig) Parameters() url.Values

Parameters returns a copy of all the parameters.

func (*PushConfig) ParseIdentityFilters

func (pc *PushConfig) ParseIdentityFilters() error

ParseIdentityFilters parses the configured PushConfig's 'IdentityFilters' attribute to elemental filters. The parsed filters will then be stored in the non-exposed 'parsedIdentityFilters' attribute of PushConfig. This is useful for clients that wish the utilize the same filter multiple times without having to incur the overhead of parsing each time.

An error is returned in following situations:

- when a filter is declared on an identity that is not defined in the PushConfig's 'Identities' attribute
- when a filter cannot be parsed into an elemental.Filter

func (*PushConfig) SetParameter

func (pc *PushConfig) SetParameter(key string, values ...string)

SetParameter sets the values of the parameter with the given key.

func (*PushConfig) String

func (pc *PushConfig) String() string

type PushFilter

type PushFilter = PushConfig

A PushFilter represents an abstract filter for filtering out push notifications. This is now aliased to PushConfig as a result of re-naming the type.

Deprecated: use the new name PushConfig instead

func NewPushFilter

func NewPushFilter() *PushFilter

NewPushFilter returns a new PushFilter. NewPushFilter is now aliased to NewPushConfig. This was done for backwards compatibility as a result of the re-naming of PushFilter to PushConfig.

Deprecated: use the constructor with the new name, NewPushConfig, instead

type Relationship

type Relationship struct {
	Type string

	Retrieve     map[string]*RelationshipInfo
	RetrieveMany map[string]*RelationshipInfo
	Info         map[string]*RelationshipInfo
	Create       map[string]*RelationshipInfo
	Update       map[string]*RelationshipInfo
	Delete       map[string]*RelationshipInfo
	Patch        map[string]*RelationshipInfo
}

A Relationship describes the hierarchical relationship of the models.

type RelationshipInfo

type RelationshipInfo struct {
	Deprecated         bool
	Parameters         []ParameterDefinition
	RequiredParameters ParametersRequirement
}

A RelationshipInfo describe the various meta information of a relationship.

func RelationshipInfoForOperation

func RelationshipInfoForOperation(registry RelationshipsRegistry, i Identity, pid Identity, op Operation) *RelationshipInfo

RelationshipInfoForOperation returns the relationship info for the given identity, parent identity and operation.

type RelationshipsRegistry

type RelationshipsRegistry map[Identity]*Relationship

A RelationshipsRegistry maintains the relationship for Identities.

type Request

type Request struct {
	RequestID            string
	Namespace            string
	Recursive            bool
	Operation            Operation
	Identity             Identity
	Order                []string
	ObjectID             string
	ParentIdentity       Identity
	ParentID             string
	Data                 []byte
	Parameters           Parameters
	Headers              http.Header
	Username             string
	Password             string
	Page                 int
	PageSize             int
	After                string
	Limit                int
	OverrideProtection   bool
	Version              int
	ExternalTrackingID   string
	ExternalTrackingType string
	ContentType          EncodingType
	Accept               EncodingType

	Metadata           map[string]interface{}
	ClientIP           string
	TLSConnectionState *tls.ConnectionState
	// contains filtered or unexported fields
}

A Request represents an abstract request on an elemental model.

func NewRequest

func NewRequest() *Request

NewRequest returns a new Request.

func NewRequestFromHTTPRequest

func NewRequestFromHTTPRequest(req *http.Request, manager ModelManager) (*Request, error)

NewRequestFromHTTPRequest returns a new Request from the given http.Request.

func (*Request) Decode

func (r *Request) Decode(dst interface{}) error

Decode decodes the data into the given destination.

func (*Request) Duplicate

func (r *Request) Duplicate() *Request

Duplicate duplicates the Request.

func (*Request) GetEncoding

func (r *Request) GetEncoding() EncodingType

GetEncoding returns the encoding used to encode the body.

func (*Request) HTTPRequest

func (r *Request) HTTPRequest() *http.Request

HTTPRequest returns the native http.Request, if any.

func (*Request) String

func (r *Request) String() string

type Response

type Response struct {
	StatusCode int
	Data       []byte
	Count      int
	Total      int
	Next       string
	Messages   []string
	Redirect   string
	RequestID  string
	Request    *Request
	Cookies    []*http.Cookie
}

A Response contains the response from a Request.

func NewResponse

func NewResponse(req *Request) *Response

NewResponse returns a new Response

func (*Response) Encode

func (r *Response) Encode(obj interface{}) (err error)

Encode encodes the given oject into the response.

func (*Response) GetEncoding

func (r *Response) GetEncoding() EncodingType

GetEncoding returns the encoding used to encode the entity.

type SparseIdentifiable

type SparseIdentifiable interface {

	// ToPlain returns the full version of the object.
	ToPlain() PlainIdentifiable

	Identifiable
}

A SparseIdentifiable is the interface of an object that can return a full version of itself.

type SparseIdentifiables

type SparseIdentifiables interface {

	// ToPlain returns the full version of the object.
	ToPlain() IdentifiablesList

	Identifiables
}

A SparseIdentifiables is the interface of an object that can return a full version of itself.

type SubFilter

type SubFilter []*Filter

SubFilter is the type of subfilter

type SubFilters

type SubFilters []SubFilter

SubFilters is is a list SubFilter,

type Validatable

type Validatable interface {
	Validate() error
}

A Validatable is the interface for objects that can be validated.

type Versionable

type Versionable interface {
	Version() int
}

A Versionable is an object that can be versioned.

Directories

Path Synopsis
cmd/elegen
cmd/elegen/static
cmd/elegen/versions
internal Package internal is a generated GoMock package.
test/model