gsk

Documentation

Index

• Constants
• Variables
• func NormalizePort(val string) string
• type Context
  • func (c *Context) DecodeJSONBody(v interface{}) error
  • func (c *Context) GetCookie(name string) (*http.Cookie, error)
  • func (c *Context) GetStatusCode() int
  • func (c *Context) JSONResponse(data interface{})
  • func (c *Context) Logger() *slog.Logger
  • func (c *Context) Origin() string
  • func (c *Context) Param(key string) string
  • func (c *Context) Path() string
  • func (c *Context) QueryParam(key string) string
  • func (c *Context) RawResponse(raw []byte)
  • func (c *Context) Redirect(url string)
  • func (c *Context) SetCookie(cookie *http.Cookie)
  • func (c *Context) SetHeader(key string, value string)
  • func (c *Context) Status(status int) *Context
  • func (c *Context) StringResponse(data string)
  • func (c *Context) TemplateResponse(template *Tpl)
• type HandlerFunc
• type Map
• type Middleware
• type Params
• type RouteGroup
  • func (rg *RouteGroup) Delete(path string, handler HandlerFunc)
  • func (rg *RouteGroup) Get(path string, handler HandlerFunc)
  • func (rg *RouteGroup) Handle(method string, path string, handler HandlerFunc)
  • func (rg *RouteGroup) Patch(path string, handler HandlerFunc)
  • func (rg *RouteGroup) Post(path string, handler HandlerFunc)
  • func (rg *RouteGroup) Put(path string, handler HandlerFunc)
  • func (rg *RouteGroup) RouteGroup(path string) *RouteGroup
  • func (rg *RouteGroup) Use(middleware Middleware)
• type Router
• type Server
  • func New(userconfig ...*ServerConfig) *Server
  • func (s *Server) Delete(path string, handler HandlerFunc)
  • func (s *Server) Get(path string, handler HandlerFunc)
  • func (s *Server) Handle(method string, path string, handler HandlerFunc)
  • func (s *Server) Patch(path string, handler HandlerFunc)
  • func (s *Server) Post(path string, handler HandlerFunc)
  • func (s *Server) Put(path string, handler HandlerFunc)
  • func (s *Server) RouteGroup(path string) *RouteGroup
  • func (s *Server) Shutdown() error
  • func (s *Server) Start()
  • func (s *Server) Test(method string, route string, body io.Reader, testParams ...TestParams) (httptest.ResponseRecorder, error)
  • func (s *Server) Use(mw Middleware)
• type ServerConfig
• type TestParams
• type Tpl
  • func (t *Tpl) Render(configVars map[string]interface{}) ([]byte, error)

Constants

const (
	DEFAULT_PORT        = "8080"
	DEFAULT_STATIC_PATH = "/static"
	DEFAULT_STATIC_DIR  = "public/assets"
)

Variables

var (
	ErrInvalidJSON    = errors.New("invalid_json")
	ErrInternalServer = errors.New("internal_server_error")
	ErrBodyTooLarge   = errors.New("request_body_too_large")
)

var DEFAULT_TEMPLATE_VARIABLES = map[string]interface{}{
	"Static": DEFAULT_STATIC_PATH,
}

Functions

func NormalizePort

func NormalizePort(val string) string

Types

type Context

type Context struct {
	// server
	Request *http.Request
	Writer  http.ResponseWriter
	// contains filtered or unexported fields
}

func (*Context) DecodeJSONBody

func (c *Context) DecodeJSONBody(v interface{}) error

func (*Context) GetCookie

func (c *Context) GetCookie(name string) (*http.Cookie, error)

Get cookie using cookie name

func (*Context) GetStatusCode

func (c *Context) GetStatusCode() int

Get the status code set for the response

func (*Context) JSONResponse

func (c *Context) JSONResponse(data interface{})

JSONResponse marshals the provided interface into JSON and writes it to the response writer If there is an error in marshalling the JSON, an internal server error is returned

func (*Context) Logger

func (c *Context) Logger() *slog.Logger

get the logger

func (*Context) Origin

func (c *Context) Origin() string

func (*Context) Param

func (c *Context) Param(key string) string

Param gets the params within the path mentioned as a wildcard

func (*Context) Path

func (c *Context) Path() string

func (*Context) QueryParam

func (c *Context) QueryParam(key string) string

QueryParam gets the query parameters passed eg: /?name=value

func (*Context) RawResponse

func (c *Context) RawResponse(raw []byte)

sets response body as byte array

func (*Context) Redirect

func (c *Context) Redirect(url string)

Redirect redirects the request to the provided URL

func (*Context) SetCookie

func (c *Context) SetCookie(cookie *http.Cookie)

Set cookie using http.Cookie

func (*Context) SetHeader

func (c *Context) SetHeader(key string, value string)

sets response header key value

func (*Context) Status

func (c *Context) Status(status int) *Context

Status sets the status code of the response

func (*Context) StringResponse

func (c *Context) StringResponse(data string)

StringResponse writes the provided string to the response writer

func (*Context) TemplateResponse

func (c *Context) TemplateResponse(template *Tpl)

TemplateResponse renders the provided template with the provided data and writes it to the response writer with content type text/html

type HandlerFunc

type HandlerFunc func(*Context)

type Map

type Map map[string]interface{}

type Middleware

type Middleware func(HandlerFunc) HandlerFunc

This implementation of middleware will enable middleware chaining

type Params

type Params interface {
	ByName(string) string
}

type RouteGroup

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

func (*RouteGroup) Delete

func (rg *RouteGroup) Delete(path string, handler HandlerFunc)

func (*RouteGroup) Get

func (rg *RouteGroup) Get(path string, handler HandlerFunc)

func (*RouteGroup) Handle

func (rg *RouteGroup) Handle(method string, path string, handler HandlerFunc)

func (*RouteGroup) Patch

func (rg *RouteGroup) Patch(path string, handler HandlerFunc)

func (*RouteGroup) Post

func (rg *RouteGroup) Post(path string, handler HandlerFunc)

func (*RouteGroup) Put

func (rg *RouteGroup) Put(path string, handler HandlerFunc)

func (*RouteGroup) RouteGroup

func (rg *RouteGroup) RouteGroup(path string) *RouteGroup

func (*RouteGroup) Use

func (rg *RouteGroup) Use(middleware Middleware)

type Router

type Router interface {
	ServeFiles(string, http.FileSystem)
	ServeHTTP(http.ResponseWriter, *http.Request)
	HandlerFunc(method string, path string, handler http.HandlerFunc)
	ParamsFromContext(context.Context) Params

	Router() *httprouter.Router
}

type Server

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

func New

func New(userconfig ...*ServerConfig) *Server

New creates a new server instance Configurations can be passed as a parameter and It's optional If no configurations are passed, default values are used Returning server struct pointer because its more performant interface{} is slower than concrete types, because it slows down garbage collector

func (*Server) Delete

func (s *Server) Delete(path string, handler HandlerFunc)

func (*Server) Get

func (s *Server) Get(path string, handler HandlerFunc)

Register handlers for the HTTP methods usage example: server.Get("/test", func(c stk.Context) { gc.Status(http.StatusOK).JSONResponse("OK") })

func (*Server) Handle

func (s *Server) Handle(method string, path string, handler HandlerFunc)

func (*Server) Patch

func (s *Server) Patch(path string, handler HandlerFunc)

func (*Server) Post

func (s *Server) Post(path string, handler HandlerFunc)

func (*Server) Put

func (s *Server) Put(path string, handler HandlerFunc)

func (*Server) RouteGroup

func (s *Server) RouteGroup(path string) *RouteGroup

RouteGroup returns a new RouteGroup instance RouteGroup is used to register routes with the same path prefix It will also ensure that the middlewares are applied to the routes exclusively usage example: rg := server.RouteGroup("/api") rg.Get("/users", func(c stk.Context) { gc.Status(http.StatusOK).JSONResponse("OK") })

func (*Server) Shutdown

func (s *Server) Shutdown() error

Shuts down the server, use for graceful shutdown Eg Usage:

// indicate that the server is shutting down done := make(chan bool)

// A go routine that listens for os signals // it will block until it receives a signal // once it receives a signal, it will shutdown close the done channel

go func() {
	sigint := make(chan os.Signal, 1)
	signal.Notify(sigint, os.Interrupt, syscall.SIGTERM)
	<-sigint

	if err := server.Shutdown(); err != nil {
		logger.Error(err)
	}

	close(done)
}()

return server, done

func (*Server) Start

func (s *Server) Start()

Start starts the server on the configured port

func (*Server) Test

func (s *Server) Test(method string, route string, body io.Reader, testParams ...TestParams) (httptest.ResponseRecorder, error)

Helper function to test the server Usage example: w, err := server.Test("GET", "/test", nil)

func (*Server) Use

func (s *Server) Use(mw Middleware)

Use adds a middleware to the server usage example: server.Use(stk.RequestLogger()) NOTE: Middlewares will be applied when the route is registered SO Make sure to register the routes after adding the middlewares

type ServerConfig

type ServerConfig struct {
	Port   string
	Logger *slog.Logger
	// Input
	BodySizeLimit int64

	// Static
	StaticPath string
	StaticDir  string
}

type TestParams

type TestParams struct {
	Cookies []*http.Cookie
	Headers map[string]string
}

type Tpl

type Tpl struct {
	TemplatePath string
	Variables    interface{}
}

func (*Tpl) Render

func (t *Tpl) Render(configVars map[string]interface{}) ([]byte, error)