middlewares

type AllowList ¶

type AllowList struct {
	Store store.Store

	// IgnoreMissingClaims configures the middleware to continue the handler chain
	// in the case where an access token was not present.
	IgnoreMissingClaims bool
}

AllowList verifies that the access token provided is authorized

func (m AllowList) Then(next http.Handler) http.Handler

type AuthStore ¶

type AuthStore interface {
	// AuthenticateUser attempts to authenticate a user with the given username
	// and hashed password. An error is returned if the user does not exist, is
	// disabled or the given password does not match.
	AuthenticateUser(ctx context.Context, user, pass string) (*types.User, error)
}

AuthStore specifies the storage requirements for auth types.

type Authentication ¶

type Authentication struct {
	// IgnoreUnauthorized configures the middleware to continue the handler chain
	// in the case where an access token was not present.
	IgnoreUnauthorized bool
}

Authentication is a HTTP middleware that enforces authentication

func (a Authentication) Then(next http.Handler) http.Handler

type Authorization ¶

type Authorization struct {
	Authorizer authorization.Authorizer
}

Authorization is an HTTP middleware that enforces authorization

func (a Authorization) Then(next http.Handler) http.Handler

type AuthorizationAttributes ¶

type AuthorizationAttributes struct{}

AuthorizationAttributes is an HTTP middleware that populates a context for the request, to be used by other middlewares. You probably want this middleware to be executed early in the middleware stack.

func (a AuthorizationAttributes) Then(next http.Handler) http.Handler

type HTTPMiddleware ¶

type HTTPMiddleware interface {
	// Then returns new handler that wraps given handler
	Then(http.Handler) http.Handler
}

HTTPMiddleware interface serves as the building block for composing http middleware.

type LimitRequest ¶

type LimitRequest struct{}

LimitRequest is an HTTP middleware that enforces request limits

func (l LimitRequest) Then(next http.Handler) http.Handler

type Namespace ¶

type Namespace struct{}

Namespace retrieves the namespace passed as a query parameter and add it into the context of the request

func (n Namespace) Then(next http.Handler) http.Handler

type Pagination ¶

type Pagination struct{}

Pagination retrieves the "limit" and "continue" query parameters and add them to the request's context.

func (p Pagination) Then(next http.Handler) http.Handler

type RefreshToken ¶

type RefreshToken struct{}

RefreshToken middleware retrieves and validates a refresh token, provided in the body of a request, against an access token and the access list. Then, it adds the claims of both access and refresh tokens into the request context for easier consumption later

func (m RefreshToken) Then(next http.Handler) http.Handler

type SimpleLogger ¶

type SimpleLogger struct{}

SimpleLogger log request path and duration

func (m SimpleLogger) Then(next http.Handler) http.Handler

type Stack ¶

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

Stack of middleware; stack itself is middleware and can but composed along with other middleware / stacks.

eg. Apply(router, NewStack(Auth{}, BasicAuth{}, NewStack(Logger{})), ...)

func NewStack(ms []HTTPMiddleware) *Stack

func (m Stack) Then(next http.Handler) http.Handler