vc

type APIError ¶

type APIError struct {
	Code        int               `json:"code,omitempty"`
	Description string            `json:"description,omitempty"`
	Error       string            `json:"error"`
	Fields      map[string]string `json:"fields,omitempty"`
}

APIError represents an API error response. This will be passed to a renderer error method for conversion into an appropriate response.

type ActionHandler ¶

type ActionHandler interface {
	HandleAction(*ctx.Context) (interface{}, int, error)
}

ActionHandler implementers are responsible for returning payload data for a request, along with a status code or error.

type ActionHandlerFunc ¶

type ActionHandlerFunc struct {
	Handler func(*ctx.Context) (interface{}, int, error)
}

ActionHandlerFunc wraps a function with the HandleAction signature to a full ActionHandler interface.

func (fn ActionHandlerFunc) HandleAction(context *ctx.Context) (interface{}, int, error)

type ActionProcessor ¶

type ActionProcessor struct {
	SideloadEnabled bool
	MetricsRegistry metrics.Registry
}

ActionProcessor handles an entire action lifecycle, from data retrieval through to unlocking, and responding.

func NewActionProcessor() *ActionProcessor

func (p *ActionProcessor) HTTPHandler(typ, action string, handler ActionHandler) httprouter.Handle

func (p *ActionProcessor) HandleActionFunc(typ, action string, fn func(*ctx.Context) (interface{}, int, error)) httprouter.Handle

type Actor ¶

type Actor interface {
	// ActorInfo returns both the identifier and type of the actor.
	ActorInfo() (actorID string, actorType string)
}

Actor represents a request actor, and is generally either an oauth client or user.

type AnnotatedError ¶

type AnnotatedError interface {
	ErrorFields() map[string]string
}

AnnotatedError defines an interface for additional metadata for an error. This is where you want to put all of your error data when it's more than just a single error case condition, for example all of the invalid fields in a bad update or create operation.

type Criteria ¶

type Criteria struct {
	// Sideload is a slice of related entities to sideload.
	Sideload []string
	// OrderColumn defines the order that collections should be ordered by.
	OrderColumn    *string
	OrderAscending bool
	// From represents a time that entities should have been updated after.
	From *time.Time
	// Limit is the number of results in a collection
	Limit int
	// State is an array of item states to filter by
	State []string
}

Criteria defines how results should be modified, or filtered.

func ContextCriteria(context *ctx.Context) *Criteria

func RequestCriteria(r *http.Request) *Criteria

func (criteria Criteria) ShouldSideload(name string) bool

type DescriptiveError ¶

type DescriptiveError interface {
	ErrorDescription() string
}

DescriptiveError defines an interface for returning a human readable error description. It’s ok to use humour here, as these descriptions will be read by developers, or at least real people, and can often be read in a time of frustration. Be authentic with your descriptions, and good karma may come your way.

type Renderer ¶

type Renderer interface {
	Render(interface{}) ([]byte, error)
	RenderError(APIError) []byte
}

var (
	// DefaultRenderer is the renderer used by default. This can be changed at
	// runtime to a renderer that suits.
	// DefaultRenderer = render.JSONRenderer{}
	DefaultRenderer Renderer
)

type Response ¶

type Response struct {
	Payload interface{} `json:"payload"`
	// A pointer is used here to allow empty maps to be returned.
	Sideload *map[string]map[string]interface{} `json:"related,omitempty"`
}

Response represents a non error display response.

type StatusError ¶

type StatusError interface {
	StatusCode() int
}

StatusError defines an interface for an error that also includes a custom http status code. Use this liberally to differentiate service errors from things like authentication, authorization or validation errors.

type StructuredLogsError ¶

type StructuredLogsError interface {
	LogFields() map[string]string
}

StructuredLogsError defines an interface for additional metadata for an error. This metadata will be logged, but not output to the public error response.