ghost

type Extender ¶

type Extender interface {
	// Extend the context by calling ctx.WithValue()
	Extend(ctx context.Context) context.Context
}

A context extender is an interface that adds values to a context that passes through it. For example, if you want database access inside a context you might build a context extender to pass along database connections.

type GhostError ¶

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

An implementation of HttpError for simple things.

func (e *GhostError) Error() string

func (e *GhostError) StatusCode() int

type HttpError ¶

type HttpError interface {
	error
	StatusCode() int
}

A type for HTTP errors that extend the base error type. Provides a method for status codes to return to the HTTP client.

func NewHttpError(err error, code int) HttpError

type NullModel ¶

type NullModel struct {
}

A null model doesn't do anything

func (m *NullModel) FromRequest(r *http.Request) HttpError

type NullProcessor ¶

type NullProcessor struct {
}

A null processor doesn't do anything

func (p *NullProcessor) Process(interface{}) (interface{}, HttpError)

type NullValidator ¶

type NullValidator struct {
}

A null validator doesn't do anything

func (v *NullValidator) Validate(interface{}) HttpError

type NullWriter ¶

type NullWriter struct {
}

A null writer doesn't do anything

func (w *NullWriter) Serialize(interface{}) ([]byte, HttpError)

type Processor ¶

type Processor interface {
	// Process the information or return an HTTP error if something is wrong,
	// or nil otherwise.
	Process(source interface{}) (interface{}, HttpError)
}

type RequestModel ¶

type RequestModel interface {
	// Fill the model with the information from the request. One way to do this
	// is to just use json.Unmarshal(), but you might also want some other
	// information extracted.
	FromRequest(r *http.Request) HttpError
}

A request model is a type that wraps user input from a request body. Typically this will be a struct representation of some JSON object.

type RouteBuilder ¶

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

func (b *RouteBuilder) Extender(e Extender) *RouteBuilder

func (b *RouteBuilder) Methods(methods ...string) *RouteBuilder

func (b *RouteBuilder) Model(m RequestModel) *RouteBuilder

func (b *RouteBuilder) Processor(p Processor) *RouteBuilder

func (b *RouteBuilder) ServeHTTP(w http.ResponseWriter, r *http.Request)

func (b *RouteBuilder) Validator(v Validator) *RouteBuilder

func (b *RouteBuilder) Writer(w Writer) *RouteBuilder

type Router ¶

type Router struct {
	Mux *mux.Router
}

A ghost router is actually backed by a gorilla mux, but we add some helpers to make building the API a little easier.

func NewRouter() *Router

func (r *Router) AddRoute(path string) *RouteBuilder

type Validator ¶

type Validator interface {
	// Validate the input and return an HTTP error if something is wrong, or
	// nil otherwise.
	Validate(interface{}) HttpError
}

This is a type that validates an InputModel after the model has been parsed from the request body.

type Writer ¶

type Writer interface {
	Serialize(interface{}) ([]byte, HttpError)
}

Write the information to the response writer to return the result to the HTTP client. Probably this will involve a call to json.Marshal(), unless you are using a different serialization method.