vatel

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
	Log(key string, val interface{}) *VatelContext
	LogValues() map[string]interface{}
	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
}

func NewContext(ctx *fasthttp.RequestCtx) Context

type Endpoint ¶

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

	// 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 impementing 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

	LanguageLabel string // #Cannon
	// contains filtered or unexported fields
}

Endpoint describes a REST endpoint attributes and related request Handler.

func NewEnpoint(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 Error ¶

type Error struct {
	errors.CatchedError
}

Error overloading for zerolog.Implementation

func (ce *Error) JSON() interface{}

func (ce *Error) MarshalZerologObject(e *zerolog.Event)

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 Logger ¶

type Logger interface {
	Log()
}

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"`
}

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

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(urlprefix string) *Vatel

func (v *Vatel) Add(cs Endpointer)

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) Set(key, value string)

func (v *Vatel) SetAuthorizer(a Authorizer)

func (v *Vatel) SetPermissionManager(pm PermissionManager)

func (v *Vatel) SetRequestDebugger(rd RequestDebugger)

func (v *Vatel) SetTokenDecoder(tp TokenDecoder)

type VatelContext ¶

type VatelContext struct {
	context.Context
	// 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) Header(name string) []byte

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

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

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

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