chttp

Documentation

Overview

Package chttp helps setup a http server with routing, middlewares, and more.

Index

• Variables
• func NewHandler(p NewHandlerParams) http.Handler
• type HTMLDir
• type Middleware
• type NewHandlerParams
• type NewServerParams
• type ReaderWriter
  • func NewReaderWriter(htmlDir HTMLDir, logger clogger.Logger) *ReaderWriter
  • func (rw *ReaderWriter) ReadJSON(w http.ResponseWriter, req *http.Request, body interface{}) bool
  • func (rw *ReaderWriter) WriteHTML(w http.ResponseWriter, p WriteHTMLParams)
  • func (rw *ReaderWriter) WriteJSON(w http.ResponseWriter, p WriteJSONParams)
• type RequestLoggerMiddleware
  • func NewRequestLoggerMiddleware(logger clogger.Logger) *RequestLoggerMiddleware
  • func (mw *RequestLoggerMiddleware) Handle(next http.Handler) http.Handler
• type Route
• type Router
• type Server
  • func NewServer(p NewServerParams) *Server
  • func (s *Server) Run() error
• type StaticDir
• type StaticRouter
  • func NewStaticRouter(staticDir StaticDir, appConfig cconfig.Config) (*StaticRouter, error)
  • func (ro *StaticRouter) Routes() []Route
• type WriteHTMLParams
• type WriteJSONParams

Variables

var WireModule = wire.NewSet(
	NewReaderWriter,
	NewRequestLoggerMiddleware,
	wire.Struct(new(NewServerParams), "*"),
	NewServer,
	NewStaticRouter,
)

WireModule can be used as part of google/wire setup.

Functions

func NewHandler

func NewHandler(p NewHandlerParams) http.Handler

NewHandler creates a http.Handler with the given routes and middlewares. The handler can be used with a http.Server or as an argument to StartServer.

Types

type HTMLDir

type HTMLDir fs.FS

HTMLDir is a directory that can be embedded or found on the host system. It should contain sub-directories and files to support the WriteHTML function in ReaderWriter.

type Middleware

type Middleware interface {
	Handle(next http.Handler) http.Handler
}

Middleware is a function that takes in a http.Handler and returns one as well. It allows you to execute code before or after calling the handler.

type NewHandlerParams

type NewHandlerParams struct {
	Routers           []Router
	GlobalMiddlewares []Middleware
}

NewHandlerParams holds the params needed for NewHandler.

type NewServerParams

type NewServerParams struct {
	Handler   http.Handler
	Lifecycle *copper.Lifecycle
	Config    cconfig.Config
	Logger    clogger.Logger
}

NewServerParams holds the params needed to create a server.

type ReaderWriter

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

ReaderWriter provides functions to read data from HTTP requests and write response bodies in various formats

func NewReaderWriter

func NewReaderWriter(htmlDir HTMLDir, logger clogger.Logger) *ReaderWriter

NewReaderWriter instantiates a new ReaderWriter with its dependencies

func (*ReaderWriter) ReadJSON

func (rw *ReaderWriter) ReadJSON(w http.ResponseWriter, req *http.Request, body interface{}) bool

ReadJSON reads JSON from the http.Request into the body var. If the body struct has validate tags on it, the struct is also validated. If the validation fails, a BadRequest response is sent back and the function returns false.

func (*ReaderWriter) WriteHTML

func (rw *ReaderWriter) WriteHTML(w http.ResponseWriter, p WriteHTMLParams)

WriteHTML writes an HTML response to the provided http.ResponseWriter. Using the given WriteHTMLParams, the HTML is generated with a layout, page, and component templates.

func (*ReaderWriter) WriteJSON

func (rw *ReaderWriter) WriteJSON(w http.ResponseWriter, p WriteJSONParams)

WriteJSON writes a JSON response to the http.ResponseWriter. It can be configured with status code and data using WriteJSONParams.

type RequestLoggerMiddleware

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

RequestLoggerMiddleware logs each request's HTTP method, path, and status code along with user uuid (from basic auth) if any.

func NewRequestLoggerMiddleware

func NewRequestLoggerMiddleware(logger clogger.Logger) *RequestLoggerMiddleware

NewRequestLoggerMiddleware creates a new RequestLoggerMiddleware.

func (*RequestLoggerMiddleware) Handle

func (mw *RequestLoggerMiddleware) Handle(next http.Handler) http.Handler

Handle wraps the current request with a request/response recorder. It records the method path and the return status code. It logs this with the given logger.

type Route

type Route struct {
	Middlewares []Middleware
	Path        string
	Methods     []string
	Handler     http.HandlerFunc
}

Route represents a single HTTP route (ex. /api/profile) that can be configured with middlewares, path, HTTP methods, and a handler.

type Router

type Router interface {
	Routes() []Route
}

Router is used to group routes together that are returned by the Routes method.

type Server

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

Server represents a configurable HTTP server that supports graceful shutdown.

func NewServer

func NewServer(p NewServerParams) *Server

NewServer creates a new server.

func (*Server) Run

func (s *Server) Run() error

Run configures an HTTP server using the provided app config and starts it.

type StaticDir

type StaticDir fs.FS

StaticDir represents a directory that holds static resources (JS, CSS, images, etc.)

type StaticRouter

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

StaticRouter provides a route that exposes the StaticDir

func NewStaticRouter

func NewStaticRouter(staticDir StaticDir, appConfig cconfig.Config) (*StaticRouter, error)

NewStaticRouter instantiates a new StaticRouter

func (*StaticRouter) Routes

func (ro *StaticRouter) Routes() []Route

Routes defines the /static/ route that serves the StaticDir

type WriteHTMLParams

type WriteHTMLParams struct {
	StatusCode     int
	Data           interface{}
	PageTemplate   string
	LayoutTemplate string
}

WriteHTMLParams holds the params for the WriteHTML function in ReaderWriter

type WriteJSONParams

type WriteJSONParams struct {
	StatusCode int
	Data       interface{}
}

WriteJSONParams holds the params for the WriteJSON function in ReaderWriter