contract

Documentation

Index

• Constants
• Variables
• func NewInputOutputType[T any, IOT InputOutputInterface[T]](data T, i IOT) (IOT, error)
• type Error
  • func NewError(code ErrorCode, payload interface{}) *Error
• type ErrorCode
• type FilterCondition
  • func (c *FilterCondition) IsNegative() bool
  • func (c *FilterCondition) UnmarshalJSON(data []byte) error
• type FilterConditions
  • func (fc *FilterConditions) IsEmpty() bool
  • func (fc *FilterConditions) UnmarshalJSON(data []byte) error
• type FilterLogic
• type FilterOperator
• type Filters
  • func (f *Filters) IsEmpty() bool
  • func (f *Filters) Validate(validationFunc *ValidationFunc) []ValidationError
• type InputOutputInterface
• type InputOutputType
  • func (i *InputOutputType[T]) GetData() (T, error)
  • func (i *InputOutputType[T]) SetData(data T) error
• type InputTransformerInterface
• type OutputTransformerInterface
• type ValidationError
• type ValidationFunc

Constants

const (
	FilterLogicAnd FilterLogic = "and"
	FilterLogicOr  FilterLogic = "or"

	FilterOperatorEqual                   FilterOperator = "eq"
	FilterOperatorNotEqual                FilterOperator = "neq"
	FilterOperatorGreaterThan             FilterOperator = "gt"
	FilterOperatorGreaterThanOrEqual      FilterOperator = "gte"
	FilterOperatorGreaterThanOrEqualOrNil FilterOperator = "gten"
	FilterOperatorLowerThan               FilterOperator = "lt"
	FilterOperatorLowerThanOrEqual        FilterOperator = "lte"
	FilterOperatorLowerThanOrEqualOrNil   FilterOperator = "lten"
	FilterOperatorBegins                  FilterOperator = "begins"
	FilterOperatorContains                FilterOperator = "contains"
	FilterOperatorNotContains             FilterOperator = "not-contains"
	FilterOperatorEnds                    FilterOperator = "ends"
	FilterOperatorIsNil                   FilterOperator = "nil"
	FilterOperatorIsNotNil                FilterOperator = "not-null"
	FilterOperatorIsEmpty                 FilterOperator = "empty"
	FilterOperatorIsNotEmpty              FilterOperator = "not-empty"
	FilterOperatorIn                      FilterOperator = "in"
	FilterOperatorNotIn                   FilterOperator = "not-in"

	ValidationErrorEmpty           = "empty value"
	ValidationErrorInvalidOperator = "invalid operator"
)

Variables

var ErrorCodes = map[ErrorCode]string{
	Unknown:                   "unknown error",
	UnreadableInputData:       "unreadable input data",
	InvalidInputDataStructure: "invalid input data structure",
	InvalidFiltersStructure:   "invalid filters structure",
	NonWriteableOutputData:    "can't write output data",
}

Functions

func NewInputOutputType

func NewInputOutputType[T any, IOT InputOutputInterface[T]](data T, i IOT) (IOT, error)

Types

type Error

type Error struct {
	Err     error
	Code    ErrorCode
	Payload interface{}
}

func NewError

func NewError(code ErrorCode, payload interface{}) *Error

type ErrorCode

type ErrorCode int

const (
	Unknown ErrorCode = iota
	UnreadableInputData
	InvalidInputDataStructure
	InvalidFiltersStructure
	NonWriteableOutputData
)

type FilterCondition

type FilterCondition struct {
	Field    string
	Operator FilterOperator
	Value    interface{}
}

func (*FilterCondition) IsNegative

func (c *FilterCondition) IsNegative() bool

func (*FilterCondition) UnmarshalJSON

func (c *FilterCondition) UnmarshalJSON(data []byte) error

type FilterConditions

type FilterConditions struct {
	Conditions []FilterCondition
	Filters    []Filters
}

func (*FilterConditions) IsEmpty

func (fc *FilterConditions) IsEmpty() bool

func (*FilterConditions) UnmarshalJSON

func (fc *FilterConditions) UnmarshalJSON(data []byte) error

type FilterLogic

type FilterLogic string

type FilterOperator

type FilterOperator string

type Filters

type Filters struct {
	Logic      FilterLogic
	Conditions FilterConditions
}

func (*Filters) IsEmpty

func (f *Filters) IsEmpty() bool

func (*Filters) Validate

func (f *Filters) Validate(validationFunc *ValidationFunc) []ValidationError

type InputOutputInterface

type InputOutputInterface[T any] interface {
	SetData(data T) error
	GetData() (T, error)
	GetDataString() (string, error)
	GetDataJson() ([]byte, error)
}

type InputOutputType

type InputOutputType[T any] struct {
	// contains filtered or unexported fields
}

func (*InputOutputType[T]) GetData

func (i *InputOutputType[T]) GetData() (T, error)

func (*InputOutputType[T]) SetData

func (i *InputOutputType[T]) SetData(data T) error

type InputTransformerInterface

type InputTransformerInterface[T any, IOT InputOutputInterface[T]] interface {
	Transform(input IOT) (Filters, *Error)
}

type OutputTransformerInterface

type OutputTransformerInterface[T any, IOT InputOutputInterface[T]] interface {
	Transform(input Filters) (IOT, *Error)
}

type ValidationError

type ValidationError struct {
	Path    string
	Error   string
	Field   string
	Payload any
}

type ValidationFunc

type ValidationFunc func(filterCondition FilterCondition, path string, validationErrors *[]ValidationError)