vatel

type AccessTokenUpdateHandler ¶ added in v0.13.5

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

func (c *AccessTokenUpdateHandler) Handle(ctx WebsocketContext) error

func (c *AccessTokenUpdateHandler) Input() interface{}

func (c *AccessTokenUpdateHandler) Result() interface{}

type Alarmer ¶ added in v0.10.0

type Alarmer interface {
	Alarm(err error)
}

Alarmer is the interface that wraps a single method Alarm.

type AuthMessageData ¶ added in v0.13.0

type AuthMessageData struct {
	AccessToken string `json:"accessToken"`
}

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) Context
	SetStatusCode(code int) Context
	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) Context
	RequestCtx() *fasthttp.RequestCtx
	Set(key string, val interface{}) Context
	Get(key string) interface{}
	VisitUserValues(func(key []byte, val interface{}))
}

func NewContext(ctx *fasthttp.RequestCtx) Context

type Dater ¶ added in v0.2.0

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, WS).
	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

	WebsocketController func() WebsocketHandler

	// 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 ¶ added in v0.10.0

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 ¶ added in v0.7.0

type LogOption uint32

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

type Logger ¶

type Logger interface {
	Log()
}

type MetricReporter ¶ added in v0.11.0

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 ¶ added in v0.8.0

type MiddlewarePos int

const (
	BeforeAuthorization MiddlewarePos = iota
	AfterAuthorization
	OnSuccessResponse
	OnErrorResponse
)

type Option ¶ added in v0.7.0

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 successfully.

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

type RevokeTokenChecker ¶ added in v0.3.0

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() int
	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{}) Context

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{}) Context

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

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

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

func (ctx *VatelContext) SetTokenPayload(tp TokenPayloader)

func (ctx *VatelContext) TokenPayload() TokenPayloader

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

type WebsocketContext ¶ added in v0.13.0

type WebsocketContext interface {
	BodyWriter() io.Writer
	TokenPayload() TokenPayloader
	SetTokenPayload(tp TokenPayloader)
	Set(key string, val interface{}) WebsocketContext
	Get(key string) interface{}
	VisitValues(func(key []byte, val interface{}))
	Created() time.Time
	ID() uint64
}

func NewWsContext(c *websocket.Conn) WebsocketContext

type WebsocketHandler ¶ added in v0.13.0

type WebsocketHandler interface {
	Handle(WebsocketContext) error
}

WebsocketHandler is the interface what wraps Handle method.

Handle invocates by websocket message processing func.

type WebsocketRequest ¶ added in v0.13.5

type WebsocketRequest struct {
	Path string          `json:"path"`
	Data json.RawMessage `json:"data,omitempty"`
}

type WebsocketVatel ¶ added in v0.13.5

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

func NewWebsocketVatel(optFunc ...func(*WsOption)) *WebsocketVatel

func (wv *WebsocketVatel) Endpoints() []Endpoint

func (ww *WebsocketVatel) OnClose(f func(*websocket.Conn, error))

func (ww *WebsocketVatel) OnOpen(f func(*websocket.Conn))

func (ww *WebsocketVatel) RegisterEndpoint(v *Vatel, e *Endpoint, l *zerolog.Logger) error

func (wv *WebsocketVatel) UpdateAccessToken(cid uint64, token string) error

func (ww *WebsocketVatel) Upgrade(ctx *fasthttp.RequestCtx)

func (ww *WebsocketVatel) UpgradeWithID(ctx *fasthttp.RequestCtx, id uint64)

type WsContext ¶ added in v0.13.0

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

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

func (ctx *WsContext) Created() time.Time

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

func (ctx *WsContext) ID() uint64

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

func (ctx *WsContext) SetTokenPayload(tp TokenPayloader)

func (ctx *WsContext) TokenPayload() TokenPayloader

func (ctx *WsContext) VisitValues(f func(key []byte, v interface{}))

type WsOption ¶ added in v0.13.2

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