fx

package module
v0.1.0 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Sep 11, 2024 License: MIT Imports: 9 Imported by: 0

Documentation

Index

Constants

View Source
const ModuleName = "http"

Variables

View Source
var (
	NoZipExt = []string{".png", ".jpg", ".jpeg", ".gif", ".bmp", ".ico", ".woff", ".woff2", ".ttf", ".otf", ".eot"}
	NoLogExt = append([]string{".map", ".js", ".css", ".yaml", ".yml", ".json"}, NoZipExt...)
)
View Source
var (
	OptionSessionManager = fx.Provide(NewSessionManager)
	OptionNegotiate      = fx.Provide(func() httpx.NegotiateFunc { return httpx.Negotiate })
	OptionRenderer       = fx.Provide(NewRenderer)
	OptionRendererHTML   = fx.Provide(fx.Annotate(httpx.NewRendererHTML, fx.ParamTags("", "", `group:"before-render-html"`)))
	OptionRendererJSON   = fx.Provide(fx.Annotate(httpx.NewRendererJSON, fx.ParamTags(`group:"before-render-json"`)))
	OptionRendererXML    = fx.Provide(fx.Annotate(httpx.NewRendererXML, fx.ParamTags(`group:"before-render-xml"`)))
	OptionRendererYAML   = fx.Provide(fx.Annotate(httpx.NewRendererYAML, fx.ParamTags(`group:"before-render-yaml"`)))
	OptionTemplateFinder = fx.Provide(NewTemplateFinder)
	OptionErrorHandler   = fx.Provide(fx.Annotate(httpx.NewDefaultErrorHandler, fx.As(new(httpx.ErrorHandler))))
	OptionErrorWrapper   = fx.Provide(fx.Annotate(httpx.NewDefaultErrorWrapper, fx.As(new(httpx.ErrorWrapper))))
	OptionHTTPServer     = fx.Provide(NewServer)
	OptionHTTPHandler    = fx.Provide(fx.Annotate(NewMux, fx.As(new(http.Handler))))

	OptionMiddlewareRecover = fx.Provide(AsMiddleware(func(cfg middleware.RecoverConfig, errorWrapper httpx.ErrorWrapper) Middleware {
		cfg.ErrorWrapper = errorWrapper
		return NewMiddleware("recover", middleware.Recover(cfg))
	}))
	OptionMiddlewareBodyLimit = fx.Provide(AsMiddleware(func(cfg middleware.BodyLimitConfig, errorWrapper httpx.ErrorWrapper) Middleware {
		cfg.ErrorWrapper = errorWrapper
		return NewMiddleware("body_limit", middleware.BodyLimit(cfg))
	}))
	OptionMiddlewareCompress = fx.Provide(AsMiddleware(func(cfg middleware.GzipConfig, errorWrapper httpx.ErrorWrapper) Middleware {
		cfg.Skipper = middleware.SuffixPathSkipper(NoZipExt...)
		cfg.ErrorWrapper = errorWrapper
		return NewMiddleware("compress", middleware.Gzip(cfg))
	}))
	OptionMiddlewareDecompress = fx.Provide(AsMiddleware(func(errorWrapper httpx.ErrorWrapper) Middleware {
		return NewMiddleware("decompress", middleware.Decompress(middleware.DecompressConfig{
			ErrorWrapper: errorWrapper,
		}))
	}))
	OptionMiddlewareNoCache = fx.Provide(AsMiddleware(func() Middleware {
		return NewMiddleware("no_cache", middleware.NoCache())
	}))
	OptionMiddlewareRequestID = fx.Provide(AsMiddleware(func() Middleware {
		return NewMiddleware("request_id", middleware.RequestID())
	}))
	OptionMiddlewareLogger = fx.Provide(AsMiddleware(func(logger *zap.Logger) Middleware {
		cfg := middleware.RequestLoggerConfig{
			Skipper: middleware.SuffixPathSkipper(NoLogExt...),
			Logger:  logger,
		}
		return NewMiddleware("logger", middleware.RequestLogger(cfg))
	}))
	OptionMiddlewareSecure = fx.Provide(AsMiddleware(func(cfg middleware.SecureConfig) Middleware {
		return NewMiddleware("secure", middleware.Secure(cfg))
	}))
	OptionMiddlewareMetrics = fx.Provide(AsMiddleware(func(cfg middleware.RequestMetricsConfig) Middleware {
		return NewMiddleware("metrics", middleware.RequestMetrics(cfg))
	}))
	OptionMiddlewareTracer = fx.Provide(AsMiddleware(func(cfg middleware.RequestTracerConfig) Middleware {
		return NewMiddleware("tracer", middleware.RequestTracer(cfg))
	}))
	OptionMiddlewareSession = fx.Provide(AsMiddleware(func(sm *scs.SessionManager) Middleware {
		return NewMiddleware("session", middleware.Session(middleware.SessionConfig{
			SessionManager: sm,
		}))
	}))
	OptionMiddlewareCORS = fx.Provide(AsMiddleware(func(cfg middleware.CORSConfig, errorWrapper httpx.ErrorWrapper) Middleware {
		cfg.ErrorWrapper = errorWrapper
		return NewMiddleware("cors", middleware.CORS(cfg))
	}))
	OptionMiddlewareCSRF = fx.Provide(AsMiddleware(func(cfg middleware.CSRFConfig, errorWrapper httpx.ErrorWrapper) Middleware {
		cfg.ErrorWrapper = errorWrapper
		return NewMiddleware("csrf", middleware.CSRF(cfg))
	}))
	OptionMiddlewareBasicAuth = fx.Provide(AsMiddleware(func(cfg middleware.BasicAuthConfig, validator middleware.BasicAuthValidator, errorWrapper httpx.ErrorWrapper) Middleware {
		cfg.Validator = validator
		cfg.ErrorWrapper = errorWrapper
		return NewMiddleware("basic_auth", middleware.BasicAuth(cfg))
	}))
)

Functions

func AsAPI

func AsAPI(f any) any

func AsHandler

func AsHandler(f any, group string) any

func AsMiddleware

func AsMiddleware(middleware any) any

func AsStatic

func AsStatic(f any) any

func AsSysAPI

func AsSysAPI(f any) any

func AsWeb

func AsWeb(f any) any

func Module

func Module(opts ...fx.Option) fx.Option

func NewMux

func NewMux(params MuxParams) *httpx.Mux

func NewRenderer

func NewRenderer(params RendererParams) httpx.Renderer

func NewServer

func NewServer(params ServerParams) (*server.Server, error)

func NewSessionManager

func NewSessionManager(params SessionManagerParams) *scs.SessionManager

func NewTemplateFinder added in v0.0.2

func NewTemplateFinder() httpx.TemplateFinder

Types

type BasePathConfig

type BasePathConfig struct {
	Web    string `json:"web,omitempty" yaml:"web,omitempty"`
	API    string `json:"api,omitempty" yaml:"api,omitempty"`
	SysAPI string `json:"sys_api,omitempty" yaml:"sys_api,omitempty"`
	Static string `json:"static,omitempty" yaml:"static,omitempty"`
}

type Config

type Config struct {
	fx.Out
	Server     server.Config    `json:"server,omitempty" yaml:"server,omitempty"`
	Mux        MuxConfig        `json:"mux,omitempty" yaml:"mux,omitempty"`
	BasePath   BasePathConfig   `json:"base_path,omitempty" yaml:"base_path,omitempty"`
	Session    SessionConfig    `json:"session,omitempty" yaml:"session,omitempty"`
	Middleware MiddlewareConfig `json:"middleware,omitempty" yaml:"middleware,omitempty"`
}

type Handler

type Handler interface {
	Register(*httpx.Mux)
}

type Middleware

type Middleware struct {
	Name       string
	Middleware func(http.Handler) http.Handler
}

func NewMiddleware

func NewMiddleware(name string, middleware func(http.Handler) http.Handler) Middleware

type MiddlewareConfig

type MiddlewareConfig struct {
	fx.Out
	Order     MiddlewareOrderConfig           `json:"order,omitempty" yaml:"order,omitempty"`
	Recover   middleware.RecoverConfig        `json:"recover,omitempty" yaml:"recover,omitempty"`
	BodyLimit middleware.BodyLimitConfig      `json:"body_limit,omitempty" yaml:"body_limit,omitempty"`
	Compress  middleware.GzipConfig           `json:"compress,omitempty" yaml:"compress,omitempty"`
	Secure    middleware.SecureConfig         `json:"secure,omitempty" yaml:"secure,omitempty"`
	Metrics   middleware.RequestMetricsConfig `json:"metrics,omitempty" yaml:"metrics,omitempty"`
	Tracer    middleware.RequestTracerConfig  `json:"tracer,omitempty" yaml:"tracer,omitempty"`
	CORS      middleware.CORSConfig           `json:"cors,omitempty" yaml:"cors,omitempty"`
	CSRF      middleware.CSRFConfig           `json:"csrf,omitempty" yaml:"csrf,omitempty"`
	BasicAuth middleware.BasicAuthConfig      `json:"basic_auth,omitempty" yaml:"basic_auth,omitempty"`
}

type MiddlewareOrderConfig

type MiddlewareOrderConfig struct {
	Global []string `json:"global,omitempty" yaml:"global,omitempty"`
	Web    []string `json:"web,omitempty" yaml:"web,omitempty"`
	API    []string `json:"api,omitempty" yaml:"api,omitempty"`
	SysAPI []string `json:"sys_api,omitempty" yaml:"sys_api,omitempty"`
	Static []string `json:"static,omitempty" yaml:"static,omitempty"`
}

type MuxConfig

type MuxConfig struct {
	DisableRootNotFoundHandler bool `json:"disable_root_not_found_handler,omitempty" yaml:"disable_root_not_found_handler,omitempty"`
}

type MuxParams

type MuxParams struct {
	fx.In
	MuxConfig             MuxConfig
	BasePathConfig        BasePathConfig
	MiddlewareOrderConfig MiddlewareOrderConfig
	Logger                *zap.Logger
	ErrorWrapper          httpx.ErrorWrapper
	Middlewares           []Middleware `group:"middleware"`
	WebHandlers           []Handler    `group:"web"`
	APIHandlers           []Handler    `group:"api"`
	SysAPIHandlers        []Handler    `group:"sys-api"`
	StaticHandlers        []Handler    `group:"static"`
}

type RendererParams added in v0.0.2

type RendererParams struct {
	fx.In
	Negotiate httpx.NegotiateFunc
	HTML      *httpx.RendererHTML
	JSON      *httpx.RendererJSON
	XML       *httpx.RendererXML
	YAML      *httpx.RendererYAML
}

type ServerParams

type ServerParams struct {
	fx.In
	Lifecycle fx.Lifecycle
	Config    server.Config
	Handler   http.Handler
	Logger    *zap.Logger
}

type SessionConfig

type SessionConfig struct {
	CleanupInterval time.Duration `json:"cleanup_interval" yaml:"cleanup_interval"`
	IdleTimeout     time.Duration `json:"idle_timeout" yaml:"idle_timeout"`
	Lifetime        time.Duration `json:"lifetime" yaml:"lifetime"`
	Cookie          struct {
		Name     string                  `json:"name" yaml:"name"`
		Domain   string                  `json:"domain" yaml:"domain"`
		Path     string                  `json:"path" yaml:"path"`
		Persist  bool                    `json:"persist" yaml:"persist"`
		Secure   bool                    `json:"secure" yaml:"secure"`
		HTTPOnly bool                    `json:"http_only" yaml:"http_only"`
		SameSite middleware.SameSiteType `json:"same_site" yaml:"same_site"`
	} `json:"cookie" yaml:"cookie"`
}

type SessionManagerParams

type SessionManagerParams struct {
	fx.In
	Config       SessionConfig
	Store        scs.Store
	ErrorHandler httpx.ErrorHandler
}

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL