handler

type ErrorHandleConfig struct {
	// NegotiateFormat is the offered http media type format for errors.
	// formats split by comma, such as "application/json,application/xml"
	Accepts         string      `json:"accepts" yaml:"accepts"`
	NegotiateFormat []string    `json:"-" yaml:"-"`
	ErrorParser     ErrorParser `json:"-" yaml:"-"`
	// Message is the string while the error is private
	Message string `json:"message" yaml:"message"`
}

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

type ErrorParser func(c *gin.Context, public error) (int, any)

type JWTConfig struct {
	auth.JWTOptions `json:",inline" yaml:",inline"`
	Skipper         Skipper
	// Exclude is a list of http paths to exclude from JWT auth
	//
	// path format must same as url.URL.Path started with "/" and ended with "/"
	Exclude []string `json:"exclude" yaml:"exclude"`
	// TokenLookupFuncs defines a list of user-defined functions that extract JWT token from the given context.
	// This is one of the two options to provide a token extractor.
	// The order of precedence is user-defined TokenLookupFuncs, and TokenLookup.
	// You can also provide both if you want.
	TokenLookupFuncs []ValuesExtractor
	// LogoutHandler defines a function which is executed for user logout system.It clears something like cache.
	LogoutHandler func(*gin.Context)
	// ErrorHandler defines a function which is executed for an invalid token.
	// It may be used to define a custom JWT error and abort the request.like use:
	//  c.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{"error": "invalid token"})
	ErrorHandler func(c *gin.Context, err error) error
	// TokenStoreKey is the name of the cache driver, default is "redis".
	// When this option is used, requirements: token cache KEY that uses the JWT ID.
	TokenStoreKey string `json:"tokenStoreKey" yaml:"TokenStoreKey"`
	// WithPrincipalContext defines a function which is Principal creator and store principal in context.
	//
	// Use GeneratePrincipal by default. You can use your own function to create principal.
	WithPrincipalContext func(c *gin.Context, token *jwt.Token) error
}

type JWTMiddleware struct {
	Config *JWTConfig
	// contains filtered or unexported fields
}

type KeyAuthConfig struct {
	// Skipper defines a function to skip middleware.
	Skipper Skipper
	// Exclude is a list of http paths to exclude from key auth
	Exclude []string `json:"exclude" yaml:"exclude"`
	// KeyLookupFuncs defines a list of user-defined functions that extract key token from the given context.
	// This is one of the two options to provide a token extractor.
	// The order of precedence is user-defined KeyLookupFuncs, and KeyLookup.
	// You can also provide both if you want.
	KeyLookupFuncs []ValuesExtractor
	// KeyLookup is a string in the form of "<source>:<name>" that is used
	// to extract key from the request.
	// Optional. Default value "header:Authorization".
	// Possible values:
	// - "header:<name>"
	// - "query:<name>"
	// - "cookie:<name>"
	// - "form:<name>"
	KeyLookup string `json:"keyLookup" yaml:"keyLookup"`
	// AuthScheme to be used in the Authorization header.
	AuthScheme string `json:"authScheme" yaml:"authScheme"`
	// Validator is a function to validate key token.You can use it to check the token is valid or not,then set
	// the user info to the context.
	Validator KeyAuthValidator
	// ErrorHandler is a function which is executed when an error occurs during the middleware processing.
	ErrorHandler KeyAuthErrorHandler
}

type KeyAuthErrorHandler func(c *gin.Context, err error) error

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

type KeyAuthValidator func(c *gin.Context, keyAuth string) (bool, error)

type LoggerConfig struct {
	Skipper Skipper
	Exclude []string `json:"exclude" yaml:"exclude"`
	// Tags to construct the logger format.
	//
	// - id (Request ID or trace ID)
	// - remoteIp
	// - uri
	// - host
	// - method
	// - path
	// - protocol
	// - referer
	// - userAgent
	// - status
	// - error
	// - latency (In nanoseconds)
	// - latencyHuman (Human readable)
	// - bytesIn (Bytes received)
	// - bytesOut (Bytes sent)
	// - header:<NAME>
	// - query:<NAME>
	// - form:<NAME>
	// - context:<NAME>
	//
	//
	// Optional. Default value DefaultLoggerConfig.Format.
	Format string        `json:"format" yaml:"format"`
	Level  zapcore.Level `json:"level" yaml:"level"`
	// contains filtered or unexported fields
}

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

type Middleware interface {
	// Name returns the name of the handler.
	Name() string
	// ApplyFunc return a gin's handler function by a configuration
	ApplyFunc(cfg *conf.Configuration) gin.HandlerFunc
}

type MiddlewareApplyFunc func(cfg *conf.Configuration) gin.HandlerFunc

type MiddlewareInitConfigFunc func(config any)

type MiddlewareNewFunc func() Middleware

type MiddlewareOption func(o *MiddlewareOptions)

type MiddlewareOptions struct {
	// set the function that gets the default middleware config, so you can change the default config
	ConfigFunc MiddlewareInitConfigFunc
}

type RecoveryMiddleware struct {
}

type Shutdown interface {
	// Shutdown the handler, usually call in server quit. Some based on file,network may need to release the resource
	Shutdown(ctx context.Context) error
}

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

type Skipper func(c *gin.Context) bool

type ValuesExtractor func(c *gin.Context) ([]string, error)