middleware

type BaseMiddleware ¶

type BaseMiddleware struct{}

BaseMiddleware provides a basic implementation of the Middleware interface. It allows chaining of HTTP handlers by passing the request to the next handler in the chain.

Example:

mw := &middleware.BaseMiddleware{}
http.Handle("/", mw.Handle(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    w.Write([]byte("Hello, World!"))
})))

http.ListenAndServe(":8080", nil)

type CORSMiddleware ¶

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

CORSMiddleware is the middleware that handles CORS

func NewCORSMiddleware(options CORSOptions) *CORSMiddleware

func (cm *CORSMiddleware) Handle(next http.Handler) http.Handler

type CORSOptions ¶

type CORSOptions struct {
	AllowedOrigins []string
	AllowedMethods []string
	AllowedHeaders []string
}

CORSOptions defines the configuration for the CORS middleware

func NewCorsOptions(origins []string, methods []string, headers []string) *CORSOptions

type CSRFProtection ¶

type CSRFProtection struct{}

func NewCSRFProtection() *CSRFProtection

func (csrf *CSRFProtection) Handle(next http.Handler) http.Handler

type Caching ¶

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

func NewCaching(client *redis.Client, ttl time.Duration, cacheControl bool) *Caching

func (c *Caching) Handle(next http.Handler) http.Handler

type CookieParser ¶

type CookieParser struct{}

func NewCookieParser() *CookieParser

func (cp *CookieParser) Handle(next http.Handler) http.Handler

type Cookies ¶

type Cookies string

type FileUploadMiddleware ¶

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

func NewFileUploadMiddleware(uploadDir string, maxFileSize int64, allowedExts []string) *FileUploadMiddleware

func (f *FileUploadMiddleware) Handle(next http.Handler) http.Handler

type InMemoryConfig ¶

type InMemoryConfig struct {
	NumShards       int
	Limit           int
	Interval        time.Duration
	CleanupInterval time.Duration
}

InMemoryConfig is the configuration for the in-memory rate limiter.

func NewInMemoryConfig(NumShards int, Limit int, Interval time.Duration, CleanupInterval time.Duration) *InMemoryConfig

type JSONParser ¶

type JSONParser struct {
	Options ParserOptions
}

func NewJsonParser(options ParserOptions) *JSONParser

func (jp *JSONParser) Handle(next http.Handler) http.Handler

type JsonKey ¶

type JsonKey string

type Middleware ¶

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

Middleware defines the interface for HTTP middlewares. Implementers should provide a `Handle` method that takes an `http.Handler` and returns a new `http.Handler`. This allows for wrapping existing handlers with additional functionality.

type MiddlewareWrapper ¶

type MiddlewareWrapper struct {
	HandlerFunc func(next http.Handler) http.Handler
}

MiddlewareWrapper wraps a function to match the Middleware interface

func (mw MiddlewareWrapper) Handle(next http.Handler) http.Handler

type ParserOptions ¶

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

func NewParserOptions(size int64) *ParserOptions

type ProfilingMiddleware ¶

type ProfilingMiddleware struct {
}

ProfilingMiddleware represents a structure for profiling requests

func NewProfilingMiddleware() *ProfilingMiddleware

func (pm *ProfilingMiddleware) Handle(next http.Handler) http.Handler

type RateLimiter ¶

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

RateLimiter is a middleware that limits the number of requests a client can make to your server within a specified interval.

func NewRateLimiter(limiterType RateLimiterType, config interface{}) *RateLimiter

func (rl *RateLimiter) Handle(next http.Handler) http.Handler

type RateLimiterType ¶

type RateLimiterType int

RateLimiterType defines the type of rate limiter (InMemory or RedisBacked).

const (
	InMemory RateLimiterType = iota
	RedisBacked
)

type RedisConfig ¶

type RedisConfig struct {
	Client   redis.Client
	Limit    int
	Interval time.Duration
}

RedisConfig is the configuration for the Redis-backed rate limiter.

func NewRedisConfig(client *redis.Client, limit int, interval time.Duration) *RedisConfig

type ResponseRecorder ¶

type ResponseRecorder struct {
	http.ResponseWriter
	StatusCode int
	Body       *bytes.Buffer
}

func (rec *ResponseRecorder) Flush()

func (rec *ResponseRecorder) Write(p []byte) (int, error)

func (rec *ResponseRecorder) WriteHeader(statusCode int)

type TemplateMiddleware ¶

type TemplateMiddleware struct {
	Tmpl *template.Template
}

func NewTemplateMiddleware(templateDir string) *TemplateMiddleware

func (tm *TemplateMiddleware) Handle(next http.Handler) http.Handler

type TimeoutMiddleware ¶

type TimeoutMiddleware struct {
	Timeout time.Duration
}

func NewTimeoutMiddleware(timeout time.Duration) *TimeoutMiddleware

func (tm *TimeoutMiddleware) Handle(next http.Handler) http.Handler

type XSSProtection ¶

type XSSProtection struct{}

func NewXSSProtection() *XSSProtection

func (xss *XSSProtection) Handle(next http.Handler) http.Handler