vatel

type Alarmer ¶

type Alarmer interface {
	Alarm(err error)
}

Alarmer is the interface that wraps a single method Alarm.

type Authorizer ¶

type Authorizer interface {
	IsAllowed(requestPerms []byte, endpointPerms ...uint) (bool, error)
}

Authorizer is the interface that wraps IsAllowed method.

Authorizer accepts request permissions and permissions required by endpoint. Returns true if all endpointPerms are inside requestPerms.

type Context ¶

type Context interface {
	BodyWriter() io.Writer
	SetContentType([]byte) *VatelContext
	SetStatusCode(code int) *VatelContext
	FormFile(key string) (*multipart.FileHeader, error)
	FormValue(key string) []byte
	SaveMultipartFile(fh *multipart.FileHeader, path string) error
	Header(name string) []byte
	TokenPayload() TokenPayloader
	SetTokenPayload(tp TokenPayloader)
	SetHeader(name, val []byte) *VatelContext
	RequestCtx() *fasthttp.RequestCtx
	Set(key string, val interface{}) *VatelContext
	Get(key string) interface{}
	VisitUserValues(func(key []byte, val interface{}))
}

func NewContext(ctx *fasthttp.RequestCtx) Context

type Dater ¶

type Dater interface {
	Parse(string) (interface{}, error)
	Set(interface{})
}

type Endpoint ¶

type Endpoint struct {
	LogOptions LogOption

	// Method holds HTTP method name (e.g GET, POST, PUT, DELETE).
	Method string

	// Wraps response by gzip compression function.
	Compress bool

	// Path holds url path with fasthttp parameters (e.g. /customers/{id}).
	Path string

	// Perms holds list of permissions. Nil if endpoint is public.
	Perms []string

	// Controller holds reference to the object implementing interface Handler.
	Controller func() Handler

	// ResponseContentType by default has "application/json; charset: utf-8;"
	ResponseContentType string

	// NoInputLog defines debug logging rule for request data. If true, endpoint request body
	// will not be written to the log. (i.e authentication endpoint).
	NoInputLog bool

	// NoResultLog defines debug logging rule for response data. If true, endpoint response body
	// will not be written to the log. (i.e authentication  endpoint)
	NoResultLog bool

	ManualStatusCode bool

	//
	SuccessStatusCode int

	LanguageLabel string
	// contains filtered or unexported fields
}

Endpoint describes a REST endpoint attributes and related request Handler.

func NewEndpoint(method, path string, perms []string, c func() Handler) *Endpoint

type Endpointer ¶

type Endpointer interface {
	Endpoints() []Endpoint
}

Endpointer is the interface that wraps a single Endpoints method.

Endpoints returns []Endpoints to be handled by API gateway.

type Handler ¶

type Handler interface {
	Handle(Context) error
}

Handler is the interface what wraps Handle method.

Handle invocates by API gateway mux.

type Inputer ¶

type Inputer interface {
	Input() interface{}
}

Inputer is the interface what wraps Input method.

Input returns reference to the object what will be promoted with input data by vatel.

If endpoint's handler expects input data, Input method should be implemented.

GET, DELETE methods: input values will be taken from URL query. POST, PUT, PATCH methods: input values will be taken from JSON body.

type JsonMasker ¶

type JsonMasker interface {
	Fields(structure interface{}, tag string) jsonmask.Fields
	Mask(src []byte, fields jsonmask.Fields) ([]byte, error)
}

JsonMasker is the interface that wraps Mask and Fields methods.

Fields returns meta data of the struct which is receiver of coming JSON data. The metadata is used further in the method Mask.

Mask modifies JSON using rules specified for each field structure. Returns JSON with masked sensitive values.

type LogOption ¶

type LogOption uint32

const (
	LogSilent LogOption = 1 << iota
	LogEnter
	LogExit
	LogReqBody
	LogReqInput
	LogRespBody
	LogRespOutput
)

type Logger ¶

type Logger interface {
	Log()
}

type MetricReporter ¶

type MetricReporter interface {
	ReportMetric(method, path string, statusCode int, dur float64, size int)
}

MetricReporter is the interface what wraps a single method ReportMetric.

HTTP requests handler uses MetricReporter to submit processing metrics to prometheus.

type MiddlewarePos ¶

type MiddlewarePos int

const (
	BeforeAuthorization MiddlewarePos = iota
	AfterAuthorization
	OnSuccessResponse
	OnErrorResponse
)

type Option ¶

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

type Paramer ¶

type Paramer interface {
	Param() interface{}
}

Paramer is the interface what wraps a single Param method.

Param returns reference to the struct what will be promoted with values from URL.

Example: if we have /customer/{id}/bill/{billnum} then Param() should return reference to struct

{
		CustomerID int `param:"id"
	 	BillNum string `param:"billnum"`
}

If there is URL params and variables like /customer/{id}?sortBy=name&balanceAbove=100 methods Param and Input can return reference to the same struct.

type PermissionManager ¶

type PermissionManager interface {
	PermissionBitPos(perm string) (uint, bool)
}

PermissionManager ...

type RequestDebugger ¶

type RequestDebugger interface {
	IsDebugRequired(TokenPayloader) (in, out bool)
}

type Resulter ¶

type Resulter interface {
	Result() interface{}
}

Resulter is the interface what wraps a single Result method.

Result returns reference to the object what will be send to the client when endpoint handler completes succesfully.

If endpoint's controller have outgoing data, Result method should be implemented.

type RevokeTokenChecker ¶

type RevokeTokenChecker interface {
	IsTokenRevoked(accessToken string) (bool, error)
}

RevokeTokenChecker is the interface what wraps a single method IsTokenRevoked.

IsTokenRevoked returns true if access token was revoked.

type TokenDecoder ¶

type TokenDecoder interface {
	Decode(encodedToken []byte) (Tokener, error)
}

TokenDecoder is the interface what wraps a single method Decode.

TokenDecoder decodes token and returns object Tokener.

type TokenPayloader ¶

type TokenPayloader interface {
	User() uuid.UUID
	Login() string
	Role() int
	Perms() []byte
	Extra() interface{}
	Debug() bool
}

TokenPayloader is the interface that wraps access methods to JWT payload parts.

User returns value of user attribute from the token.

Perms returns bitset array with user role's permissions.

type Tokener ¶

type Tokener interface {
	SystemPayload() map[string]interface{}
	ApplicationPayload() TokenPayloader
}

Tokener is the interface that wraps methods SystemPayload and UserPayload.

SystemPayload returns JWT part related to JWT itself.

UserPayload returns an object that represents JWT payload specified by user.

type Vatel ¶

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

Vatel holds

func NewVatel(optFunc ...func(*Option)) *Vatel

func (v *Vatel) Add(e ...Endpointer)

func (v *Vatel) AddMiddleware(pos MiddlewarePos, f ...func(Context) error)

func (v *Vatel) BuildHandlers(mux *router.Router, l *zerolog.Logger) error

func (v *Vatel) DisableAuthorizer()

func (v *Vatel) Endpoints() []Endpoint

func (v *Vatel) MustBuildHandlers(mux *router.Router, l *zerolog.Logger)

func (v *Vatel) SetAuthorizer(a Authorizer)

func (v *Vatel) SetPermissionManager(pm PermissionManager)

func (v *Vatel) SetRequestDebugger(rd RequestDebugger)

func (v *Vatel) SetRevokeTokenChecker(rtc RevokeTokenChecker)

func (v *Vatel) SetTokenDecoder(tp TokenDecoder)

type VatelContext ¶

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

func (ctx *VatelContext) BodyWriter() io.Writer

func (ctx *VatelContext) FormFile(key string) (*multipart.FileHeader, error)

func (ctx *VatelContext) FormValue(key string) []byte

func (ctx *VatelContext) Get(key string) interface{}

func (ctx *VatelContext) Header(name string) []byte

func (ctx *VatelContext) Log(key string, val interface{}) *VatelContext

func (ctx *VatelContext) LogValues() map[string]interface{}

func (ctx *VatelContext) RequestCtx() *fasthttp.RequestCtx

func (ctx *VatelContext) SaveMultipartFile(fh *multipart.FileHeader, path string) error

func (ctx *VatelContext) Set(key string, val interface{}) *VatelContext

func (ctx *VatelContext) SetContentType(contentType []byte) *VatelContext

func (ctx *VatelContext) SetHeader(name, val []byte) *VatelContext

func (ctx *VatelContext) SetStatusCode(code int) *VatelContext

func (ctx *VatelContext) SetTokenPayload(tp TokenPayloader)

func (ctx *VatelContext) TokenPayload() TokenPayloader

func (ctx *VatelContext) VisitUserValues(f func(key []byte, v interface{}))