service

type Collection []Config

type Config struct {
	Kind          Kind
	IsStream      bool
	IsPrivate     bool
	Key           string
	Path          string
	Method        string
	Input         func() interface{}
	Build         func(meta.RequestId, RawHeaders, RawBody, RawParams) (TPL, error)
	BuildMessages func(meta.RequestId, RawHeaders, RawBody, RawParams) (MessageTPL, error)
	Direct        func(req Req) (interface{}, error)
	Auth          func(Req) error
	Before        []func(Config, Req) error
	After         func(Config, Req)
}

type ContentResponse struct {
	Content interface{} `json:"content"`
	ContentResponseContext
	ContentResponseMeta
}

type ContentResponseContext struct {
	First      bool `json:"first"`
	Last       bool `json:"last"`
	TotalPages int  `json:"total_pages"`
}

type ContentResponseMeta struct {
	Size  int   `json:"size"`
	Total int   `json:"total"`
	Page  int   `json:"current_page"`
	Error error `json:"error,omitempty"`
}

type ContextTPL interface {
	Result(Req) (interface{}, error)
}

type Kind int

type Message struct {
	Key   string
	Value interface{}
}

type MessageTPL interface {
	Result() (Messages, error)
}

type Messages []Message

type ParamHolder interface {
	Get(string) (ParamItem, bool)
}

type ParamItem struct {
	Key    string
	Value  string
	Values []string
}

type PrivateTPL interface {
	Auth(meta.RequestId, RawHeaders, RawBody, RawParams) error
	TPL
}

type RawBody []byte

type RawHeaders []ParamItem

type RawParams []ParamItem

type Reason map[string]interface{}

type Req struct {
	ID      meta.RequestId
	Headers RawHeaders
	Body    RawBody
	Params  RawParams
	Input   interface{}
	Timer   *servertiming.Header
	Context *gin.Context
}

type ResultError struct {
	Status     int                      `json:"-"`
	Field      string                   `json:"-"`
	ErrMessage string                   `json:"-"`
	Message    string                   `json:"message"`
	Reasons    []map[string]interface{} `json:"reasons"`
}

type StreamResult struct {
	Type   string
	Length string
	Writer func(io.Writer) bool
}

type TPL interface {
	Result() (interface{}, error)
}