fiber

package module
v0.0.1 Latest Latest
Warning

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

 Go to latest Published: Jul 24, 2024 License: MIT Imports: 44 Imported by: 0

Documentation

Overview

Package fiber is an Express inspired web framework built on top of Fasthttp, the fastest HTTP engine for Go. Designed to ease things up for fast development with zero memory allocation and performance in mind.

Index

Constants

View Source 
const (
	DefaultBodyLimit       = 4 * 1024 * 1024
	DefaultConcurrency     = 256 * 1024
	DefaultReadBufferSize  = 4096
	DefaultWriteBufferSize = 4096
)

Default Config values

View Source 
const (
	MethodGet     = "GET"     // RFC 7231, 4.3.1
	MethodHead    = "HEAD"    // RFC 7231, 4.3.2
	MethodPost    = "POST"    // RFC 7231, 4.3.3
	MethodPut     = "PUT"     // RFC 7231, 4.3.4
	MethodPatch   = "PATCH"   // RFC 5789
	MethodDelete  = "DELETE"  // RFC 7231, 4.3.5
	MethodConnect = "CONNECT" // RFC 7231, 4.3.6
	MethodOptions = "OPTIONS" // RFC 7231, 4.3.7
	MethodTrace   = "TRACE"   // RFC 7231, 4.3.8

)

HTTP methods were copied from net/http.

View Source 
const (
	MIMETextXML         = "text/xml"
	MIMETextHTML        = "text/html"
	MIMETextPlain       = "text/plain"
	MIMETextJavaScript  = "text/javascript"
	MIMETextCSS         = "text/css"
	MIMEApplicationXML  = "application/xml"
	MIMEApplicationJSON = "application/json"
	// Deprecated: use MIMETextJavaScript instead
	MIMEApplicationJavaScript = "application/javascript"
	MIMEApplicationForm       = "application/x-www-form-urlencoded"
	MIMEOctetStream           = "application/octet-stream"
	MIMEMultipartForm         = "multipart/form-data"

	MIMETextXMLCharsetUTF8         = "text/xml; charset=utf-8"
	MIMETextHTMLCharsetUTF8        = "text/html; charset=utf-8"
	MIMETextPlainCharsetUTF8       = "text/plain; charset=utf-8"
	MIMETextJavaScriptCharsetUTF8  = "text/javascript; charset=utf-8"
	MIMETextCSSCharsetUTF8         = "text/css; charset=utf-8"
	MIMEApplicationXMLCharsetUTF8  = "application/xml; charset=utf-8"
	MIMEApplicationJSONCharsetUTF8 = "application/json; charset=utf-8"
	// Deprecated: use MIMETextJavaScriptCharsetUTF8 instead
	MIMEApplicationJavaScriptCharsetUTF8 = "application/javascript; charset=utf-8"
)

MIME types that are commonly used

View Source 
const (
	StatusContinue           = 100 // RFC 9110, 15.2.1
	StatusSwitchingProtocols = 101 // RFC 9110, 15.2.2
	StatusProcessing         = 102 // RFC 2518, 10.1
	StatusEarlyHints         = 103 // RFC 8297

	StatusOK                          = 200 // RFC 9110, 15.3.1
	StatusCreated                     = 201 // RFC 9110, 15.3.2
	StatusAccepted                    = 202 // RFC 9110, 15.3.3
	StatusNonAuthoritativeInformation = 203 // RFC 9110, 15.3.4
	StatusNoContent                   = 204 // RFC 9110, 15.3.5
	StatusResetContent                = 205 // RFC 9110, 15.3.6
	StatusPartialContent              = 206 // RFC 9110, 15.3.7
	StatusMultiStatus                 = 207 // RFC 4918, 11.1
	StatusAlreadyReported             = 208 // RFC 5842, 7.1
	StatusIMUsed                      = 226 // RFC 3229, 10.4.1

	StatusMultipleChoices   = 300 // RFC 9110, 15.4.1
	StatusMovedPermanently  = 301 // RFC 9110, 15.4.2
	StatusFound             = 302 // RFC 9110, 15.4.3
	StatusSeeOther          = 303 // RFC 9110, 15.4.4
	StatusNotModified       = 304 // RFC 9110, 15.4.5
	StatusUseProxy          = 305 // RFC 9110, 15.4.6
	StatusSwitchProxy       = 306 // RFC 9110, 15.4.7 (Unused)
	StatusTemporaryRedirect = 307 // RFC 9110, 15.4.8
	StatusPermanentRedirect = 308 // RFC 9110, 15.4.9

	StatusBadRequest                   = 400 // RFC 9110, 15.5.1
	StatusUnauthorized                 = 401 // RFC 9110, 15.5.2
	StatusPaymentRequired              = 402 // RFC 9110, 15.5.3
	StatusForbidden                    = 403 // RFC 9110, 15.5.4
	StatusNotFound                     = 404 // RFC 9110, 15.5.5
	StatusMethodNotAllowed             = 405 // RFC 9110, 15.5.6
	StatusNotAcceptable                = 406 // RFC 9110, 15.5.7
	StatusProxyAuthRequired            = 407 // RFC 9110, 15.5.8
	StatusRequestTimeout               = 408 // RFC 9110, 15.5.9
	StatusConflict                     = 409 // RFC 9110, 15.5.10
	StatusGone                         = 410 // RFC 9110, 15.5.11
	StatusLengthRequired               = 411 // RFC 9110, 15.5.12
	StatusPreconditionFailed           = 412 // RFC 9110, 15.5.13
	StatusRequestEntityTooLarge        = 413 // RFC 9110, 15.5.14
	StatusRequestURITooLong            = 414 // RFC 9110, 15.5.15
	StatusUnsupportedMediaType         = 415 // RFC 9110, 15.5.16
	StatusRequestedRangeNotSatisfiable = 416 // RFC 9110, 15.5.17
	StatusExpectationFailed            = 417 // RFC 9110, 15.5.18
	StatusTeapot                       = 418 // RFC 9110, 15.5.19 (Unused)
	StatusMisdirectedRequest           = 421 // RFC 9110, 15.5.20
	StatusUnprocessableEntity          = 422 // RFC 9110, 15.5.21
	StatusLocked                       = 423 // RFC 4918, 11.3
	StatusFailedDependency             = 424 // RFC 4918, 11.4
	StatusTooEarly                     = 425 // RFC 8470, 5.2.
	StatusUpgradeRequired              = 426 // RFC 9110, 15.5.22
	StatusPreconditionRequired         = 428 // RFC 6585, 3
	StatusTooManyRequests              = 429 // RFC 6585, 4
	StatusRequestHeaderFieldsTooLarge  = 431 // RFC 6585, 5
	StatusUnavailableForLegalReasons   = 451 // RFC 7725, 3

	StatusInternalServerError           = 500 // RFC 9110, 15.6.1
	StatusNotImplemented                = 501 // RFC 9110, 15.6.2
	StatusBadGateway                    = 502 // RFC 9110, 15.6.3
	StatusServiceUnavailable            = 503 // RFC 9110, 15.6.4
	StatusGatewayTimeout                = 504 // RFC 9110, 15.6.5
	StatusHTTPVersionNotSupported       = 505 // RFC 9110, 15.6.6
	StatusVariantAlsoNegotiates         = 506 // RFC 2295, 8.1
	StatusInsufficientStorage           = 507 // RFC 4918, 11.5
	StatusLoopDetected                  = 508 // RFC 5842, 7.2
	StatusNotExtended                   = 510 // RFC 2774, 7
	StatusNetworkAuthenticationRequired = 511 // RFC 6585, 6
)

HTTP status codes were copied from net/http with the following updates: - Rename StatusNonAuthoritativeInfo to StatusNonAuthoritativeInformation - Add StatusSwitchProxy (306) NOTE: Keep this list in sync with statusMessage

View Source 
const (
	HeaderAuthorization                      = "Authorization"
	HeaderProxyAuthenticate                  = "Proxy-Authenticate"
	HeaderProxyAuthorization                 = "Proxy-Authorization"
	HeaderWWWAuthenticate                    = "WWW-Authenticate"
	HeaderAge                                = "Age"
	HeaderCacheControl                       = "Cache-Control"
	HeaderClearSiteData                      = "Clear-Site-Data"
	HeaderExpires                            = "Expires"
	HeaderPragma                             = "Pragma"
	HeaderWarning                            = "Warning"
	HeaderAcceptCH                           = "Accept-CH"
	HeaderAcceptCHLifetime                   = "Accept-CH-Lifetime"
	HeaderContentDPR                         = "Content-DPR"
	HeaderDPR                                = "DPR"
	HeaderEarlyData                          = "Early-Data"
	HeaderSaveData                           = "Save-Data"
	HeaderViewportWidth                      = "Viewport-Width"
	HeaderWidth                              = "Width"
	HeaderETag                               = "ETag"
	HeaderIfMatch                            = "If-Match"
	HeaderIfModifiedSince                    = "If-Modified-Since"
	HeaderIfNoneMatch                        = "If-None-Match"
	HeaderIfUnmodifiedSince                  = "If-Unmodified-Since"
	HeaderLastModified                       = "Last-Modified"
	HeaderVary                               = "Vary"
	HeaderConnection                         = "Connection"
	HeaderKeepAlive                          = "Keep-Alive"
	HeaderAccept                             = "Accept"
	HeaderAcceptCharset                      = "Accept-Charset"
	HeaderAcceptEncoding                     = "Accept-Encoding"
	HeaderAcceptLanguage                     = "Accept-Language"
	HeaderCookie                             = "Cookie"
	HeaderExpect                             = "Expect"
	HeaderMaxForwards                        = "Max-Forwards"
	HeaderSetCookie                          = "Set-Cookie"
	HeaderAccessControlAllowCredentials      = "Access-Control-Allow-Credentials"
	HeaderAccessControlAllowHeaders          = "Access-Control-Allow-Headers"
	HeaderAccessControlAllowMethods          = "Access-Control-Allow-Methods"
	HeaderAccessControlAllowOrigin           = "Access-Control-Allow-Origin"
	HeaderAccessControlExposeHeaders         = "Access-Control-Expose-Headers"
	HeaderAccessControlMaxAge                = "Access-Control-Max-Age"
	HeaderAccessControlRequestHeaders        = "Access-Control-Request-Headers"
	HeaderAccessControlRequestMethod         = "Access-Control-Request-Method"
	HeaderOrigin                             = "Origin"
	HeaderTimingAllowOrigin                  = "Timing-Allow-Origin"
	HeaderXPermittedCrossDomainPolicies      = "X-Permitted-Cross-Domain-Policies"
	HeaderDNT                                = "DNT"
	HeaderTk                                 = "Tk"
	HeaderContentDisposition                 = "Content-Disposition"
	HeaderContentEncoding                    = "Content-Encoding"
	HeaderContentLanguage                    = "Content-Language"
	HeaderContentLength                      = "Content-Length"
	HeaderContentLocation                    = "Content-Location"
	HeaderContentType                        = "Content-Type"
	HeaderForwarded                          = "Forwarded"
	HeaderVia                                = "Via"
	HeaderXForwardedFor                      = "X-Forwarded-For"
	HeaderXForwardedHost                     = "X-Forwarded-Host"
	HeaderXForwardedProto                    = "X-Forwarded-Proto"
	HeaderXForwardedProtocol                 = "X-Forwarded-Protocol"
	HeaderXForwardedSsl                      = "X-Forwarded-Ssl"
	HeaderXUrlScheme                         = "X-Url-Scheme"
	HeaderLocation                           = "Location"
	HeaderFrom                               = "From"
	HeaderHost                               = "Host"
	HeaderReferer                            = "Referer"
	HeaderReferrerPolicy                     = "Referrer-Policy"
	HeaderUserAgent                          = "User-Agent"
	HeaderAllow                              = "Allow"
	HeaderServer                             = "Server"
	HeaderAcceptRanges                       = "Accept-Ranges"
	HeaderContentRange                       = "Content-Range"
	HeaderIfRange                            = "If-Range"
	HeaderRange                              = "Range"
	HeaderContentSecurityPolicy              = "Content-Security-Policy"
	HeaderContentSecurityPolicyReportOnly    = "Content-Security-Policy-Report-Only"
	HeaderCrossOriginResourcePolicy          = "Cross-Origin-Resource-Policy"
	HeaderExpectCT                           = "Expect-CT"
	HeaderPermissionsPolicy                  = "Permissions-Policy"
	HeaderPublicKeyPins                      = "Public-Key-Pins"
	HeaderPublicKeyPinsReportOnly            = "Public-Key-Pins-Report-Only"
	HeaderStrictTransportSecurity            = "Strict-Transport-Security"
	HeaderUpgradeInsecureRequests            = "Upgrade-Insecure-Requests"
	HeaderXContentTypeOptions                = "X-Content-Type-Options"
	HeaderXDownloadOptions                   = "X-Download-Options"
	HeaderXFrameOptions                      = "X-Frame-Options"
	HeaderXPoweredBy                         = "X-Powered-By"
	HeaderXXSSProtection                     = "X-XSS-Protection"
	HeaderLastEventID                        = "Last-Event-ID"
	HeaderNEL                                = "NEL"
	HeaderPingFrom                           = "Ping-From"
	HeaderPingTo                             = "Ping-To"
	HeaderReportTo                           = "Report-To"
	HeaderTE                                 = "TE"
	HeaderTrailer                            = "Trailer"
	HeaderTransferEncoding                   = "Transfer-Encoding"
	HeaderSecWebSocketAccept                 = "Sec-WebSocket-Accept"
	HeaderSecWebSocketExtensions             = "Sec-WebSocket-Extensions"
	HeaderSecWebSocketKey                    = "Sec-WebSocket-Key"
	HeaderSecWebSocketProtocol               = "Sec-WebSocket-Protocol"
	HeaderSecWebSocketVersion                = "Sec-WebSocket-Version"
	HeaderAcceptPatch                        = "Accept-Patch"
	HeaderAcceptPushPolicy                   = "Accept-Push-Policy"
	HeaderAcceptSignature                    = "Accept-Signature"
	HeaderAltSvc                             = "Alt-Svc"
	HeaderDate                               = "Date"
	HeaderIndex                              = "Index"
	HeaderLargeAllocation                    = "Large-Allocation"
	HeaderLink                               = "Link"
	HeaderPushPolicy                         = "Push-Policy"
	HeaderRetryAfter                         = "Retry-After"
	HeaderServerTiming                       = "Server-Timing"
	HeaderSignature                          = "Signature"
	HeaderSignedHeaders                      = "Signed-Headers"
	HeaderSourceMap                          = "SourceMap"
	HeaderUpgrade                            = "Upgrade"
	HeaderXDNSPrefetchControl                = "X-DNS-Prefetch-Control"
	HeaderXPingback                          = "X-Pingback"
	HeaderXRequestID                         = "X-Request-ID"
	HeaderXRequestedWith                     = "X-Requested-With"
	HeaderXRobotsTag                         = "X-Robots-Tag"
	HeaderXUACompatible                      = "X-UA-Compatible"
	HeaderAccessControlAllowPrivateNetwork   = "Access-Control-Allow-Private-Network"
	HeaderAccessControlRequestPrivateNetwork = "Access-Control-Request-Private-Network"
)

HTTP Headers were copied from net/http.

View Source 
const (
	NetworkTCP  = "tcp"
	NetworkTCP4 = "tcp4"
	NetworkTCP6 = "tcp6"
)

Network types that are commonly used

View Source 
const (
	StrGzip    = "gzip"
	StrBr      = "br"
	StrDeflate = "deflate"
	StrBrotli  = "brotli"
	StrZstd    = "zstd"
)

Compression types

View Source 
const (
	CookieSameSiteDisabled   = "disabled" // not in RFC, just control "SameSite" attribute will not be set.
	CookieSameSiteLaxMode    = "lax"
	CookieSameSiteStrictMode = "strict"
	CookieSameSiteNoneMode   = "none"
)

Cookie SameSite https://datatracker.ietf.org/doc/html/draft-ietf-httpbis-rfc6265bis-03#section-4.1.2.7

View Source 
const (
	ConstraintInt             = "int"
	ConstraintBool            = "bool"
	ConstraintFloat           = "float"
	ConstraintAlpha           = "alpha"
	ConstraintGUID            = "guid"
	ConstraintMinLen          = "minLen"
	ConstraintMaxLen          = "maxLen"
	ConstraintLen             = "len"
	ConstraintBetweenLen      = "betweenLen"
	ConstraintMinLenLower     = "minlen"
	ConstraintMaxLenLower     = "maxlen"
	ConstraintBetweenLenLower = "betweenlen"
	ConstraintMin             = "min"
	ConstraintMax             = "max"
	ConstraintRange           = "range"
	ConstraintDatetime        = "datetime"
	ConstraintRegex           = "regex"
)

Route Constraints

View Source 
const (
	FlashCookieName     = "fiber_flash"
	OldInputDataPrefix  = "old_input_data_"
	CookieDataSeparator = ","
	CookieDataAssigner  = ":"
)

Cookie name to send flash messages when to use redirection.

View Source 
const Version = "3.0.0-beta.3"

Version of current fiber package

Variables

View Source 
var (
	ErrBadRequest                   = NewError(StatusBadRequest)                   // 400
	ErrUnauthorized                 = NewError(StatusUnauthorized)                 // 401
	ErrPaymentRequired              = NewError(StatusPaymentRequired)              // 402
	ErrForbidden                    = NewError(StatusForbidden)                    // 403
	ErrNotFound                     = NewError(StatusNotFound)                     // 404
	ErrMethodNotAllowed             = NewError(StatusMethodNotAllowed)             // 405
	ErrNotAcceptable                = NewError(StatusNotAcceptable)                // 406
	ErrProxyAuthRequired            = NewError(StatusProxyAuthRequired)            // 407
	ErrRequestTimeout               = NewError(StatusRequestTimeout)               // 408
	ErrConflict                     = NewError(StatusConflict)                     // 409
	ErrGone                         = NewError(StatusGone)                         // 410
	ErrLengthRequired               = NewError(StatusLengthRequired)               // 411
	ErrPreconditionFailed           = NewError(StatusPreconditionFailed)           // 412
	ErrRequestEntityTooLarge        = NewError(StatusRequestEntityTooLarge)        // 413
	ErrRequestURITooLong            = NewError(StatusRequestURITooLong)            // 414
	ErrUnsupportedMediaType         = NewError(StatusUnsupportedMediaType)         // 415
	ErrRequestedRangeNotSatisfiable = NewError(StatusRequestedRangeNotSatisfiable) // 416
	ErrExpectationFailed            = NewError(StatusExpectationFailed)            // 417
	ErrTeapot                       = NewError(StatusTeapot)                       // 418
	ErrMisdirectedRequest           = NewError(StatusMisdirectedRequest)           // 421
	ErrUnprocessableEntity          = NewError(StatusUnprocessableEntity)          // 422
	ErrLocked                       = NewError(StatusLocked)                       // 423
	ErrFailedDependency             = NewError(StatusFailedDependency)             // 424
	ErrTooEarly                     = NewError(StatusTooEarly)                     // 425
	ErrUpgradeRequired              = NewError(StatusUpgradeRequired)              // 426
	ErrPreconditionRequired         = NewError(StatusPreconditionRequired)         // 428
	ErrTooManyRequests              = NewError(StatusTooManyRequests)              // 429
	ErrRequestHeaderFieldsTooLarge  = NewError(StatusRequestHeaderFieldsTooLarge)  // 431
	ErrUnavailableForLegalReasons   = NewError(StatusUnavailableForLegalReasons)   // 451

	ErrInternalServerError           = NewError(StatusInternalServerError)           // 500
	ErrNotImplemented                = NewError(StatusNotImplemented)                // 501
	ErrBadGateway                    = NewError(StatusBadGateway)                    // 502
	ErrServiceUnavailable            = NewError(StatusServiceUnavailable)            // 503
	ErrGatewayTimeout                = NewError(StatusGatewayTimeout)                // 504
	ErrHTTPVersionNotSupported       = NewError(StatusHTTPVersionNotSupported)       // 505
	ErrVariantAlsoNegotiates         = NewError(StatusVariantAlsoNegotiates)         // 506
	ErrInsufficientStorage           = NewError(StatusInsufficientStorage)           // 507
	ErrLoopDetected                  = NewError(StatusLoopDetected)                  // 508
	ErrNotExtended                   = NewError(StatusNotExtended)                   // 510
	ErrNetworkAuthenticationRequired = NewError(StatusNetworkAuthenticationRequired) // 511
)

Errors

View Source 
var (
	ErrGracefulTimeout = errors.New("shutdown: graceful timeout has been reached, exiting")
	// ErrNotRunning indicates that a Shutdown method was called when the server was not running.
	ErrNotRunning = errors.New("shutdown: server is not running")
	// ErrHandlerExited is returned by App.Test if a handler panics or calls runtime.Goexit().
	ErrHandlerExited = errors.New("runtime.Goexit() called in handler or server panic")
)

General errors

View Source 
var (
	ErrRangeMalformed     = errors.New("range: malformed range header string")
	ErrRangeUnsatisfiable = errors.New("range: unsatisfiable range")
)

Range errors

View Source 
var DefaultColors = Colors{
	Black:   "\u001b[90m",
	Red:     "\u001b[91m",
	Green:   "\u001b[92m",
	Yellow:  "\u001b[93m",
	Blue:    "\u001b[94m",
	Magenta: "\u001b[95m",
	Cyan:    "\u001b[96m",
	White:   "\u001b[97m",
	Reset:   "\u001b[0m",
}

DefaultColors Default color codes

View Source 
var DefaultMethods = []string{
	MethodGet,
	MethodHead,
	MethodPost,
	MethodPut,
	MethodDelete,
	MethodConnect,
	MethodOptions,
	MethodTrace,
	MethodPatch,
}

HTTP methods enabled by default

View Source 
var ErrCustomBinderNotFound = errors.New("binder: custom binder not found, please be sure to enter the right name")

Binder errors

View Source 
var (
	// ErrNoHandlers is returned when c.Format is called with no arguments.
	ErrNoHandlers = errors.New("format: at least one handler is required, but none were set")
)

Format errors

View Source 
var (
	ErrRedirectBackNoFallback = NewError(StatusInternalServerError, "Referer not found, you have to enter fallback URL for redirection.")
)

Fiber redirection errors

Functions

func Convert 

func Convert[T any](value string, convertor func(string) (T, error), defaultValue ...T) (T, error)

Convert a string value to a specified type, handling errors and optional default values.

func DefaultErrorHandler 

func DefaultErrorHandler(c Ctx, err error) error

DefaultErrorHandler that process return errors from handlers

func GetReqHeader 

func GetReqHeader[V GenericType](c Ctx, key string, defaultValue ...V) V

GetReqHeader returns the HTTP request header specified by filed. This function is generic and can handle differnet headers type values.

func GetTrimmedParam 

func GetTrimmedParam(param string) string

GetTrimmedParam trims the ':' & '?' from a string

func IndexRune 

func IndexRune(str string, needle int32) bool

func IsChild 

func IsChild() bool

IsChild determines if the current process is a child of Prefork

func IsMethodIdempotent 

func IsMethodIdempotent(m string) bool

IsMethodIdempotent reports whether the HTTP method is considered idempotent. See https://datatracker.ietf.org/doc/html/rfc9110#section-9.2.2

func IsMethodSafe 

func IsMethodSafe(m string) bool

IsMethodSafe reports whether the HTTP method is considered safe. See https://datatracker.ietf.org/doc/html/rfc9110#section-9.2.1

func Locals 

func Locals[V any](c Ctx, key any, value ...V) V

Locals function utilizing Go's generics feature. This function allows for manipulating and retrieving local values within a request context with a more specific data type.

All the values are removed from ctx after returning from the top RequestHandler. Additionally, Close method is called on each value implementing io.Closer before removing the value from ctx.

func Params 

func Params[V GenericType](c Ctx, key string, defaultValue ...V) V

Params is used to get the route parameters. This function is generic and can handle differnet route parameters type values.

Example:

http://example.com/user/:user -> http://example.com/user/john Params[string](c, "user") -> returns john

http://example.com/id/:id -> http://example.com/user/114 Params[int](c, "id") -> returns 114 as integer.

http://example.com/id/:number -> http://example.com/id/john Params[int](c, "number", 0) -> returns 0 because can't parse 'john' as integer.

func Query 

func Query[V GenericType](c Ctx, key string, defaultValue ...V) V

Query Retrieves the value of a query parameter from the request's URI. The function is generic and can handle query parameter values of different types. It takes the following parameters: - c: The context object representing the current request. - key: The name of the query parameter. - defaultValue: (Optional) The default value to return in case the query parameter is not found or cannot be parsed. The function performs the following steps:

  1. Type-asserts the context object to *DefaultCtx.
  2. Retrieves the raw query parameter value from the request's URI.
  3. Parses the raw value into the appropriate type based on the generic type parameter V. If parsing fails, the function checks if a default value is provided. If so, it returns the default value.
  4. Returns the parsed value.

If the generic type cannot be matched to a supported type, the function returns the default value (if provided) or the zero value of type V.

Example usage: 

GET /?search=john&age=8
name := Query[string](c, "search") // Returns "john"
age := Query[int](c, "age") // Returns 8
unknown := Query[string](c, "unknown", "default") // Returns "default" since the query parameter "unknown" is not found

func ReleaseRedirect 

func ReleaseRedirect(r *Redirect)

ReleaseRedirect returns c acquired via Redirect to redirect pool.

It is forbidden accessing req and/or its' members after returning it to redirect pool.

func RemoveEscapeChar 

func RemoveEscapeChar(word string) string

RemoveEscapeChar remove escape characters

func RoutePatternMatch 

func RoutePatternMatch(path, pattern string, cfg ...Config) bool

RoutePatternMatch checks if a given path matches a Fiber route pattern.

Types

type App 

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

App denotes the Fiber application.

func New 

func New(config ...Config) *App

New creates a new Fiber named instance. 

app := fiber.New()

You can pass optional configuration options by passing a Config struct: 

app := fiber.New(fiber.Config{
    Prefork: true,
    ServerHeader: "Fiber",
})

func (*App) AcquireCtx 

func (app *App) AcquireCtx(fctx *fasthttp.RequestCtx) Ctx

AcquireCtx retrieves a new Ctx from the pool.

func (*App) Add 

func (app *App) Add(methods []string, path string, handler Handler, middleware ...Handler) Router

Add allows you to specify multiple HTTP methods to register a route.

func (*App) All 

func (app *App) All(path string, handler Handler, middleware ...Handler) Router

All will register the handler on all HTTP methods

func (*App) Config 

func (app *App) Config() Config

Config returns the app config as value ( read-only ).

func (*App) Connect 

func (app *App) Connect(path string, handler Handler, middleware ...Handler) Router

Connect registers a route for CONNECT methods that establishes a tunnel to the server identified by the target resource.

func (*App) Delete 

func (app *App) Delete(path string, handler Handler, middleware ...Handler) Router

Delete registers a route for DELETE methods that deletes the specified resource.

func (*App) ErrorHandler 

func (app *App) ErrorHandler(ctx Ctx, err error) error

ErrorHandler is the application's method in charge of finding the appropriate handler for the given request. It searches any mounted sub fibers by their prefixes and if it finds a match, it uses that error handler. Otherwise it uses the configured error handler for the app, which if not set is the DefaultErrorHandler.

func (*App) Get 

func (app *App) Get(path string, handler Handler, middleware ...Handler) Router

Get registers a route for GET methods that requests a representation of the specified resource. Requests using GET should only retrieve data.

func (*App) GetRoute 

func (app *App) GetRoute(name string) Route

GetRoute Get route by name

func (*App) GetRoutes 

func (app *App) GetRoutes(filterUseOption ...bool) []Route

GetRoutes Get all routes. When filterUseOption equal to true, it will filter the routes registered by the middleware.

func (*App) Group 

func (app *App) Group(prefix string, handlers ...Handler) Router

Group is used for Routes with common prefix to define a new sub-router with optional middleware. 

api := app.Group("/api")
api.Get("/users", handler)

func (*App) Handler 

func (app *App) Handler() fasthttp.RequestHandler

Handler returns the server handler.

func (*App) HandlersCount 

func (app *App) HandlersCount() uint32

HandlersCount returns the amount of registered handlers.

func (*App) Head 

func (app *App) Head(path string, handler Handler, middleware ...Handler) Router

Head registers a route for HEAD methods that asks for a response identical to that of a GET request, but without the response body.

func (*App) Hooks 

func (app *App) Hooks() *Hooks

Hooks returns the hook struct to register hooks.

func (*App) Listen 

func (app *App) Listen(addr string, config ...ListenConfig) error

Listen serves HTTP requests from the given addr. You should enter custom ListenConfig to customize startup. (TLS, mTLS, prefork...) 

app.Listen(":8080")
app.Listen("127.0.0.1:8080")
app.Listen(":8080", ListenConfig{EnablePrefork: true})

func (*App) Listener 

func (app *App) Listener(ln net.Listener, config ...ListenConfig) error

Listener serves HTTP requests from the given listener. You should enter custom ListenConfig to customize startup. (prefork, startup message, graceful shutdown...)

func (*App) MountPath 

func (app *App) MountPath() string

The MountPath property contains one or more path patterns on which a sub-app was mounted.

func (*App) Name 

func (app *App) Name(name string) Router

Name Assign name to specific route.

func (*App) NewCtxFunc 

func (app *App) NewCtxFunc(function func(app *App) CustomCtx)

NewCtxFunc allows to customize ctx methods as we want. Note: It doesn't allow adding new methods, only customizing exist methods.

func (*App) Options 

func (app *App) Options(path string, handler Handler, middleware ...Handler) Router

Options registers a route for OPTIONS methods that is used to describe the communication options for the target resource.

func (*App) Patch 

func (app *App) Patch(path string, handler Handler, middleware ...Handler) Router

Patch registers a route for PATCH methods that is used to apply partial modifications to a resource.

func (*App) Post 

func (app *App) Post(path string, handler Handler, middleware ...Handler) Router

Post registers a route for POST methods that is used to submit an entity to the specified resource, often causing a change in state or side effects on the server.

func (*App) Put 

func (app *App) Put(path string, handler Handler, middleware ...Handler) Router

Put registers a route for PUT methods that replaces all current representations of the target resource with the request payload.

func (*App) RebuildTree 

func (app *App) RebuildTree() *App

BuildTree rebuilds the prefix tree from the previously registered routes. This method is useful when you want to register routes dynamically after the app has started. It is not recommended to use this method on production environments because rebuilding the tree is performance-intensive and not thread-safe in runtime. Since building the tree is only done in the startupProcess of the app, this method does not makes sure that the routeTree is being safely changed, as it would add a great deal of overhead in the request. Latest benchmark results showed a degradation from 82.79 ns/op to 94.48 ns/op and can be found in: https://github.com/gofiber/fiber/issues/2769#issuecomment-2227385283

func (*App) RegisterCustomBinder 

func (app *App) RegisterCustomBinder(binder CustomBinder)

RegisterCustomBinder Allows to register custom binders to use as Bind().Custom("name"). They should be compatible with CustomBinder interface.

func (*App) RegisterCustomConstraint 

func (app *App) RegisterCustomConstraint(constraint CustomConstraint)

RegisterCustomConstraint allows to register custom constraint.

func (*App) ReleaseCtx 

func (app *App) ReleaseCtx(c Ctx)

ReleaseCtx releases the ctx back into the pool.

func (*App) Route 

func (app *App) Route(path string) Register

Route is used to define routes with a common prefix inside the common function. Uses Group method to define new sub-router.

func (*App) Server 

func (app *App) Server() *fasthttp.Server

Server returns the underlying fasthttp server

func (*App) SetTLSHandler 

func (app *App) SetTLSHandler(tlsHandler *TLSHandler)

SetTLSHandler Can be used to set ClientHelloInfo when using TLS with Listener.

func (*App) Shutdown 

func (app *App) Shutdown() error

Shutdown gracefully shuts down the server without interrupting any active connections. Shutdown works by first closing all open listeners and then waiting indefinitely for all connections to return to idle before shutting down.

Make sure the program doesn't exit and waits instead for Shutdown to return.

Shutdown does not close keepalive connections so its recommended to set ReadTimeout to something else than 0.

func (*App) ShutdownWithContext 

func (app *App) ShutdownWithContext(ctx context.Context) error

ShutdownWithContext shuts down the server including by force if the context's deadline is exceeded.

Make sure the program doesn't exit and waits instead for ShutdownWithTimeout to return.

ShutdownWithContext does not close keepalive connections so its recommended to set ReadTimeout to something else than 0.

func (*App) ShutdownWithTimeout 

func (app *App) ShutdownWithTimeout(timeout time.Duration) error

ShutdownWithTimeout gracefully shuts down the server without interrupting any active connections. However, if the timeout is exceeded, ShutdownWithTimeout will forcefully close any active connections. ShutdownWithTimeout works by first closing all open listeners and then waiting for all connections to return to idle before shutting down.

Make sure the program doesn't exit and waits instead for ShutdownWithTimeout to return.

ShutdownWithTimeout does not close keepalive connections so its recommended to set ReadTimeout to something else than 0.

func (*App) Stack 

func (app *App) Stack() [][]*Route

Stack returns the raw router stack.

func (*App) Test 

func (app *App) Test(req *http.Request, timeout ...time.Duration) (*http.Response, error)

Test is used for internal debugging by passing a *http.Request. Timeout is optional and defaults to 1s, -1 will disable it completely.

func (*App) Trace 

func (app *App) Trace(path string, handler Handler, middleware ...Handler) Router

Trace registers a route for TRACE methods that performs a message loop-back test along the path to the target resource.

func (*App) Use 

func (app *App) Use(args ...any) Router

Use registers a middleware route that will match requests with the provided prefix (which is optional and defaults to "/"). Also, you can pass another app instance as a sub-router along a routing path. It's very useful to split up a large API as many independent routers and compose them as a single service using Use. The fiber's error handler and any of the fiber's sub apps are added to the application's error handlers to be invoked on errors that happen within the prefix route. 

	app.Use(func(c fiber.Ctx) error {
	     return c.Next()
	})
	app.Use("/api", func(c fiber.Ctx) error {
	     return c.Next()
	})
	app.Use("/api", handler, func(c fiber.Ctx) error {
	     return c.Next()
	})
 	subApp := fiber.New()
	app.Use("/mounted-path", subApp)

This method will match all HTTP verbs: GET, POST, PUT, HEAD etc...

type Bind 

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

Bind struct

func (*Bind) Body 

func (b *Bind) Body(out any) error

Body binds the request body into the struct, map[string]string and map[string][]string. It supports decoding the following content types based on the Content-Type header: application/json, application/xml, application/x-www-form-urlencoded, multipart/form-data If none of the content types above are matched, it'll take a look custom binders by checking the MIMETypes() method of custom binder. If there're no custom binder for mşme type of body, it will return a ErrUnprocessableEntity error.

func (*Bind) Cookie 

func (b *Bind) Cookie(out any) error

Cookie binds the requesr cookie strings into the struct, map[string]string and map[string][]string. NOTE: If your cookie is like key=val1,val2; they'll be binded as an slice if your map is map[string][]string. Else, it'll use last element of cookie.

func (*Bind) Custom 

func (b *Bind) Custom(name string, dest any) error

Custom To use custom binders, you have to use this method. You can register them from RegisterCustomBinder method of Fiber instance. They're checked by name, if it's not found, it will return an error. NOTE: Should/Must is still valid for Custom binders.

func (*Bind) Form 

func (b *Bind) Form(out any) error

Form binds the form into the struct, map[string]string and map[string][]string.

func (*Bind) Header 

func (b *Bind) Header(out any) error

Header binds the request header strings into the struct, map[string]string and map[string][]string.

func (*Bind) JSON 

func (b *Bind) JSON(out any) error

JSON binds the body string into the struct.

func (*Bind) MultipartForm 

func (b *Bind) MultipartForm(out any) error

MultipartForm binds the multipart form into the struct, map[string]string and map[string][]string.

func (*Bind) Must 

func (b *Bind) Must() *Bind

Must If you want to handle binder errors automatically, you can use Must. If there's an error it'll return error and 400 as HTTP status.

func (*Bind) Query 

func (b *Bind) Query(out any) error

Query binds the query string into the struct, map[string]string and map[string][]string.

func (*Bind) RespHeader 

func (b *Bind) RespHeader(out any) error

RespHeader binds the response header strings into the struct, map[string]string and map[string][]string.

func (*Bind) Should 

func (b *Bind) Should() *Bind

Should To handle binder errors manually, you can prefer Should method. It's default behavior of binder.

func (*Bind) URI 

func (b *Bind) URI(out any) error

URI binds the route parameters into the struct, map[string]string and map[string][]string.

func (*Bind) XML 

func (b *Bind) XML(out any) error

XML binds the body string into the struct.

type Colors 

type Colors struct {
	// Black color.
	//
	// Optional. Default: "\u001b[90m"
	Black string

	// Red color.
	//
	// Optional. Default: "\u001b[91m"
	Red string

	// Green color.
	//
	// Optional. Default: "\u001b[92m"
	Green string

	// Yellow color.
	//
	// Optional. Default: "\u001b[93m"
	Yellow string

	// Blue color.
	//
	// Optional. Default: "\u001b[94m"
	Blue string

	// Magenta color.
	//
	// Optional. Default: "\u001b[95m"
	Magenta string

	// Cyan color.
	//
	// Optional. Default: "\u001b[96m"
	Cyan string

	// White color.
	//
	// Optional. Default: "\u001b[97m"
	White string

	// Reset color.
	//
	// Optional. Default: "\u001b[0m"
	Reset string
}

Colors is a struct to define custom colors for Fiber app and middlewares.

type Config 

type Config struct {
	// Enables the "Server: value" HTTP header.
	//
	// Default: ""
	ServerHeader string `json:"server_header"`

	// When set to true, the router treats "/foo" and "/foo/" as different.
	// By default this is disabled and both "/foo" and "/foo/" will execute the same handler.
	//
	// Default: false
	StrictRouting bool `json:"strict_routing"`

	// When set to true, enables case sensitive routing.
	// E.g. "/FoO" and "/foo" are treated as different routes.
	// By default this is disabled and both "/FoO" and "/foo" will execute the same handler.
	//
	// Default: false
	CaseSensitive bool `json:"case_sensitive"`

	// When set to true, this relinquishes the 0-allocation promise in certain
	// cases in order to access the handler values (e.g. request bodies) in an
	// immutable fashion so that these values are available even if you return
	// from handler.
	//
	// Default: false
	Immutable bool `json:"immutable"`

	// When set to true, converts all encoded characters in the route back
	// before setting the path for the context, so that the routing,
	// the returning of the current url from the context `ctx.Path()`
	// and the parameters `ctx.Params(%key%)` with decoded characters will work
	//
	// Default: false
	UnescapePath bool `json:"unescape_path"`

	// Max body size that the server accepts.
	// -1 will decline any body size
	//
	// Default: 4 * 1024 * 1024
	BodyLimit int `json:"body_limit"`

	// Maximum number of concurrent connections.
	//
	// Default: 256 * 1024
	Concurrency int `json:"concurrency"`

	// Views is the interface that wraps the Render function.
	//
	// Default: nil
	Views Views `json:"-"`

	// Views Layout is the global layout for all template render until override on Render function.
	//
	// Default: ""
	ViewsLayout string `json:"views_layout"`

	// PassLocalsToViews Enables passing of the locals set on a fiber.Ctx to the template engine
	//
	// Default: false
	PassLocalsToViews bool `json:"pass_locals_to_views"`

	// The amount of time allowed to read the full request including body.
	// It is reset after the request handler has returned.
	// The connection's read deadline is reset when the connection opens.
	//
	// Default: unlimited
	ReadTimeout time.Duration `json:"read_timeout"`

	// The maximum duration before timing out writes of the response.
	// It is reset after the request handler has returned.
	//
	// Default: unlimited
	WriteTimeout time.Duration `json:"write_timeout"`

	// The maximum amount of time to wait for the next request when keep-alive is enabled.
	// If IdleTimeout is zero, the value of ReadTimeout is used.
	//
	// Default: unlimited
	IdleTimeout time.Duration `json:"idle_timeout"`

	// Per-connection buffer size for requests' reading.
	// This also limits the maximum header size.
	// Increase this buffer if your clients send multi-KB RequestURIs
	// and/or multi-KB headers (for example, BIG cookies).
	//
	// Default: 4096
	ReadBufferSize int `json:"read_buffer_size"`

	// Per-connection buffer size for responses' writing.
	//
	// Default: 4096
	WriteBufferSize int `json:"write_buffer_size"`

	// CompressedFileSuffixes adds suffix to the original file name and
	// tries saving the resulting compressed file under the new file name.
	//
	// Default: map[string]string{"gzip": ".fiber.gz", "br": ".fiber.br", "zstd": ".fiber.zst"}
	CompressedFileSuffixes map[string]string `json:"compressed_file_suffixes"`

	// ProxyHeader will enable c.IP() to return the value of the given header key
	// By default c.IP() will return the Remote IP from the TCP connection
	// This property can be useful if you are behind a load balancer: X-Forwarded-*
	// NOTE: headers are easily spoofed and the detected IP addresses are unreliable.
	//
	// Default: ""
	ProxyHeader string `json:"proxy_header"`

	// GETOnly rejects all non-GET requests if set to true.
	// This option is useful as anti-DoS protection for servers
	// accepting only GET requests. The request size is limited
	// by ReadBufferSize if GETOnly is set.
	//
	// Default: false
	GETOnly bool `json:"get_only"`

	// ErrorHandler is executed when an error is returned from fiber.Handler.
	//
	// Default: DefaultErrorHandler
	ErrorHandler ErrorHandler `json:"-"`

	// When set to true, disables keep-alive connections.
	// The server will close incoming connections after sending the first response to client.
	//
	// Default: false
	DisableKeepalive bool `json:"disable_keepalive"`

	// When set to true, causes the default date header to be excluded from the response.
	//
	// Default: false
	DisableDefaultDate bool `json:"disable_default_date"`

	// When set to true, causes the default Content-Type header to be excluded from the response.
	//
	// Default: false
	DisableDefaultContentType bool `json:"disable_default_content_type"`

	// When set to true, disables header normalization.
	// By default all header names are normalized: conteNT-tYPE -> Content-Type.
	//
	// Default: false
	DisableHeaderNormalizing bool `json:"disable_header_normalizing"`

	// This function allows to setup app name for the app
	//
	// Default: nil
	AppName string `json:"app_name"`

	// StreamRequestBody enables request body streaming,
	// and calls the handler sooner when given body is
	// larger than the current limit.
	//
	// Default: false
	StreamRequestBody bool

	// Will not pre parse Multipart Form data if set to true.
	//
	// This option is useful for servers that desire to treat
	// multipart form data as a binary blob, or choose when to parse the data.
	//
	// Server pre parses multipart form data by default.
	//
	// Default: false
	DisablePreParseMultipartForm bool

	// Aggressively reduces memory usage at the cost of higher CPU usage
	// if set to true.
	//
	// Try enabling this option only if the server consumes too much memory
	// serving mostly idle keep-alive connections. This may reduce memory
	// usage by more than 50%.
	//
	// Default: false
	ReduceMemoryUsage bool `json:"reduce_memory_usage"`

	// When set by an external client of Fiber it will use the provided implementation of a
	// JSONMarshal
	//
	// Allowing for flexibility in using another json library for encoding
	// Default: json.Marshal
	JSONEncoder utils.JSONMarshal `json:"-"`

	// When set by an external client of Fiber it will use the provided implementation of a
	// JSONUnmarshal
	//
	// Allowing for flexibility in using another json library for decoding
	// Default: json.Unmarshal
	JSONDecoder utils.JSONUnmarshal `json:"-"`

	// XMLEncoder set by an external client of Fiber it will use the provided implementation of a
	// XMLMarshal
	//
	// Allowing for flexibility in using another XML library for encoding
	// Default: xml.Marshal
	XMLEncoder utils.XMLMarshal `json:"-"`

	// If you find yourself behind some sort of proxy, like a load balancer,
	// then certain header information may be sent to you using special X-Forwarded-* headers or the Forwarded header.
	// For example, the Host HTTP header is usually used to return the requested host.
	// But when you’re behind a proxy, the actual host may be stored in an X-Forwarded-Host header.
	//
	// If you are behind a proxy, you should enable TrustedProxyCheck to prevent header spoofing.
	// If you enable EnableTrustedProxyCheck and leave TrustedProxies empty Fiber will skip
	// all headers that could be spoofed.
	// If request ip in TrustedProxies whitelist then:
	//   1. c.Scheme() get value from X-Forwarded-Proto, X-Forwarded-Protocol, X-Forwarded-Ssl or X-Url-Scheme header
	//   2. c.IP() get value from ProxyHeader header.
	//   3. c.Host() and c.Hostname() get value from X-Forwarded-Host header
	// But if request ip NOT in Trusted Proxies whitelist then:
	//   1. c.Scheme() WON't get value from X-Forwarded-Proto, X-Forwarded-Protocol, X-Forwarded-Ssl or X-Url-Scheme header,
	//    will return https in case when tls connection is handled by the app, of http otherwise
	//   2. c.IP() WON'T get value from ProxyHeader header, will return RemoteIP() from fasthttp context
	//   3. c.Host() and c.Hostname() WON'T get value from X-Forwarded-Host header, fasthttp.Request.URI().Host()
	//    will be used to get the hostname.
	//
	// Default: false
	EnableTrustedProxyCheck bool `json:"enable_trusted_proxy_check"`

	// Read EnableTrustedProxyCheck doc.
	//
	// Default: []string
	TrustedProxies []string `json:"trusted_proxies"`

	// If set to true, c.IP() and c.IPs() will validate IP addresses before returning them.
	// Also, c.IP() will return only the first valid IP rather than just the raw header
	// WARNING: this has a performance cost associated with it.
	//
	// Default: false
	EnableIPValidation bool `json:"enable_ip_validation"`

	// You can define custom color scheme. They'll be used for startup message, route list and some middlewares.
	//
	// Optional. Default: DefaultColors
	ColorScheme Colors `json:"color_scheme"`

	// If you want to validate header/form/query... automatically when to bind, you can define struct validator.
	// Fiber doesn't have default validator, so it'll skip validator step if you don't use any validator.
	//
	// Default: nil
	StructValidator StructValidator

	// RequestMethods provides customizibility for HTTP methods. You can add/remove methods as you wish.
	//
	// Optional. Default: DefaultMethods
	RequestMethods []string

	// EnableSplittingOnParsers splits the query/body/header parameters by comma when it's true.
	// For example, you can use it to parse multiple values from a query parameter like this:
	//   /api?foo=bar,baz == foo[]=bar&foo[]=baz
	//
	// Optional. Default: false
	EnableSplittingOnParsers bool `json:"enable_splitting_on_parsers"`
	// contains filtered or unexported fields
}

Config is a struct holding the server settings.

type Constraint 

type Constraint struct {
	RegexCompiler *regexp.Regexp
	Name          string
	Data          []string

	ID TypeConstraint
	// contains filtered or unexported fields
}

func (*Constraint) CheckConstraint 

func (c *Constraint) CheckConstraint(param string) bool

type ConversionError 

type ConversionError = schema.ConversionError

ConversionError Conversion error exposes the internal schema.ConversionError for public use. 

type Cookie struct {
	Expires     time.Time `json:"expires"`      // The expiration date of the cookie
	Name        string    `json:"name"`         // The name of the cookie
	Value       string    `json:"value"`        // The value of the cookie
	Path        string    `json:"path"`         // Specifies a URL path which is allowed to receive the cookie
	Domain      string    `json:"domain"`       // Specifies the domain which is allowed to receive the cookie
	SameSite    string    `json:"same_site"`    // Controls whether or not a cookie is sent with cross-site requests
	MaxAge      int       `json:"max_age"`      // The maximum age (in seconds) of the cookie
	Secure      bool      `json:"secure"`       // Indicates that the cookie should only be transmitted over a secure HTTPS connection
	HTTPOnly    bool      `json:"http_only"`    // Indicates that the cookie is accessible only through the HTTP protocol
	Partitioned bool      `json:"partitioned"`  // Indicates if the cookie is stored in a partitioned cookie jar
	SessionOnly bool      `json:"session_only"` // Indicates if the cookie is a session-only cookie
}

Cookie data for c.Cookie

type Ctx 

type Ctx interface {
	// Accepts checks if the specified extensions or content types are acceptable.
	Accepts(offers ...string) string
	// AcceptsCharsets checks if the specified charset is acceptable.
	AcceptsCharsets(offers ...string) string
	// AcceptsEncodings checks if the specified encoding is acceptable.
	AcceptsEncodings(offers ...string) string
	// AcceptsLanguages checks if the specified language is acceptable.
	AcceptsLanguages(offers ...string) string
	// App returns the *App reference to the instance of the Fiber application
	App() *App
	// Append the specified value to the HTTP response header field.
	// If the header is not already set, it creates the header with the specified value.
	Append(field string, values ...string)
	// Attachment sets the HTTP response Content-Disposition header field to attachment.
	Attachment(filename ...string)
	// BaseURL returns (protocol + host + base path).
	BaseURL() string
	// BodyRaw contains the raw body submitted in a POST request.
	// Returned value is only valid within the handler. Do not store any references.
	// Make copies or use the Immutable setting instead.
	BodyRaw() []byte

	// Body contains the raw body submitted in a POST request.
	// This method will decompress the body if the 'Content-Encoding' header is provided.
	// It returns the original (or decompressed) body data which is valid only within the handler.
	// Don't store direct references to the returned data.
	// If you need to keep the body's data later, make a copy or use the Immutable option.
	Body() []byte
	// ClearCookie expires a specific cookie by key on the client side.
	// If no key is provided it expires all cookies that came with the request.
	ClearCookie(key ...string)
	// Context returns *fasthttp.RequestCtx that carries a deadline
	// a cancellation signal, and other values across API boundaries.
	Context() *fasthttp.RequestCtx
	// UserContext returns a context implementation that was set by
	// user earlier or returns a non-nil, empty context,if it was not set earlier.
	UserContext() context.Context
	// SetUserContext sets a context implementation by user.
	SetUserContext(ctx context.Context)
	// Cookie sets a cookie by passing a cookie struct.
	Cookie(cookie *Cookie)
	// Cookies are used for getting a cookie value by key.
	// Defaults to the empty string "" if the cookie doesn't exist.
	// If a default value is given, it will return that value if the cookie doesn't exist.
	// The returned value is only valid within the handler. Do not store any references.
	// Make copies or use the Immutable setting to use the value outside the Handler.
	Cookies(key string, defaultValue ...string) string
	// Download transfers the file from path as an attachment.
	// Typically, browsers will prompt the user for download.
	// By default, the Content-Disposition header filename= parameter is the filepath (this typically appears in the browser dialog).
	// Override this default with the filename parameter.
	Download(file string, filename ...string) error
	// Request return the *fasthttp.Request object
	// This allows you to use all fasthttp request methods
	// https://godoc.org/github.com/valyala/fasthttp#Request
	Request() *fasthttp.Request
	// Response return the *fasthttp.Response object
	// This allows you to use all fasthttp response methods
	// https://godoc.org/github.com/valyala/fasthttp#Response
	Response() *fasthttp.Response
	// Format performs content-negotiation on the Accept HTTP header.
	// It uses Accepts to select a proper format and calls the matching
	// user-provided handler function.
	// If no accepted format is found, and a format with MediaType "default" is given,
	// that default handler is called. If no format is found and no default is given,
	// StatusNotAcceptable is sent.
	Format(handlers ...ResFmt) error
	// AutoFormat performs content-negotiation on the Accept HTTP header.
	// It uses Accepts to select a proper format.
	// The supported content types are text/html, text/plain, application/json, and application/xml.
	// For more flexible content negotiation, use Format.
	// If the header is not specified or there is no proper format, text/plain is used.
	AutoFormat(body any) error
	// FormFile returns the first file by key from a MultipartForm.
	FormFile(key string) (*multipart.FileHeader, error)
	// FormValue returns the first value by key from a MultipartForm.
	// Search is performed in QueryArgs, PostArgs, MultipartForm and FormFile in this particular order.
	// Defaults to the empty string "" if the form value doesn't exist.
	// If a default value is given, it will return that value if the form value does not exist.
	// Returned value is only valid within the handler. Do not store any references.
	// Make copies or use the Immutable setting instead.
	FormValue(key string, defaultValue ...string) string
	// Fresh returns true when the response is still “fresh” in the client's cache,
	// otherwise false is returned to indicate that the client cache is now stale
	// and the full response should be sent.
	// When a client sends the Cache-Control: no-cache request header to indicate an end-to-end
	// reload request, this module will return false to make handling these requests transparent.
	// https://github.com/jshttp/fresh/blob/10e0471669dbbfbfd8de65bc6efac2ddd0bfa057/index.js#L33
	Fresh() bool
	// Get returns the HTTP request header specified by field.
	// Field names are case-insensitive
	// Returned value is only valid within the handler. Do not store any references.
	// Make copies or use the Immutable setting instead.
	Get(key string, defaultValue ...string) string
	// GetRespHeader returns the HTTP response header specified by field.
	// Field names are case-insensitive
	// Returned value is only valid within the handler. Do not store any references.
	// Make copies or use the Immutable setting instead.
	GetRespHeader(key string, defaultValue ...string) string
	// GetRespHeaders returns the HTTP response headers.
	// Returned value is only valid within the handler. Do not store any references.
	// Make copies or use the Immutable setting instead.
	GetRespHeaders() map[string][]string
	// GetReqHeaders returns the HTTP request headers.
	// Returned value is only valid within the handler. Do not store any references.
	// Make copies or use the Immutable setting instead.
	GetReqHeaders() map[string][]string
	// Host contains the host derived from the X-Forwarded-Host or Host HTTP header.
	// Returned value is only valid within the handler. Do not store any references.
	// In a network context, `Host` refers to the combination of a hostname and potentially a port number used for connecting,
	// while `Hostname` refers specifically to the name assigned to a device on a network, excluding any port information.
	// Example: URL: https://example.com:8080 -> Host: example.com:8080
	// Make copies or use the Immutable setting instead.
	// Please use Config.EnableTrustedProxyCheck to prevent header spoofing, in case when your app is behind the proxy.
	Host() string
	// Hostname contains the hostname derived from the X-Forwarded-Host or Host HTTP header using the c.Host() method.
	// Returned value is only valid within the handler. Do not store any references.
	// Example: URL: https://example.com:8080 -> Hostname: example.com
	// Make copies or use the Immutable setting instead.
	// Please use Config.EnableTrustedProxyCheck to prevent header spoofing, in case when your app is behind the proxy.
	Hostname() string
	// Port returns the remote port of the request.
	Port() string
	// IP returns the remote IP address of the request.
	// If ProxyHeader and IP Validation is configured, it will parse that header and return the first valid IP address.
	// Please use Config.EnableTrustedProxyCheck to prevent header spoofing, in case when your app is behind the proxy.
	IP() string

	// IPs returns a string slice of IP addresses specified in the X-Forwarded-For request header.
	// When IP validation is enabled, only valid IPs are returned.
	IPs() []string
	// Is returns the matching content type,
	// if the incoming request's Content-Type HTTP header field matches the MIME type specified by the type parameter
	Is(extension string) bool
	// JSON converts any interface or string to JSON.
	// Array and slice values encode as JSON arrays,
	// except that []byte encodes as a base64-encoded string,
	// and a nil slice encodes as the null JSON value.
	// If the ctype parameter is given, this method will set the
	// Content-Type header equal to ctype. If ctype is not given,
	// The Content-Type header will be set to application/json.
	JSON(data any, ctype ...string) error
	// JSONP sends a JSON response with JSONP support.
	// This method is identical to JSON, except that it opts-in to JSONP callback support.
	// By default, the callback name is simply callback.
	JSONP(data any, callback ...string) error
	// XML converts any interface or string to XML.
	// This method also sets the content header to application/xml.
	XML(data any) error
	// Links joins the links followed by the property to populate the response's Link HTTP header field.
	Links(link ...string)
	// Locals makes it possible to pass any values under keys scoped to the request
	// and therefore available to all following routes that match the request.
	//
	// All the values are removed from ctx after returning from the top
	// RequestHandler. Additionally, Close method is called on each value
	// implementing io.Closer before removing the value from ctx.
	Locals(key any, value ...any) any
	// Location sets the response Location HTTP header to the specified path parameter.
	Location(path string)
	// Method returns the HTTP request method for the context, optionally overridden by the provided argument.
	// If no override is given or if the provided override is not a valid HTTP method, it returns the current method from the context.
	// Otherwise, it updates the context's method and returns the overridden method as a string.
	Method(override ...string) string
	// MultipartForm parse form entries from binary.
	// This returns a map[string][]string, so given a key the value will be a string slice.
	MultipartForm() (*multipart.Form, error)
	// ClientHelloInfo return CHI from context
	ClientHelloInfo() *tls.ClientHelloInfo
	// Next executes the next method in the stack that matches the current route.
	Next() error
	// RestartRouting instead of going to the next handler. This may be useful after
	// changing the request path. Note that handlers might be executed again.
	RestartRouting() error
	// OriginalURL contains the original request URL.
	// Returned value is only valid within the handler. Do not store any references.
	// Make copies or use the Immutable setting to use the value outside the Handler.
	OriginalURL() string
	// Params is used to get the route parameters.
	// Defaults to empty string "" if the param doesn't exist.
	// If a default value is given, it will return that value if the param doesn't exist.
	// Returned value is only valid within the handler. Do not store any references.
	// Make copies or use the Immutable setting to use the value outside the Handler.
	Params(key string, defaultValue ...string) string
	// Path returns the path part of the request URL.
	// Optionally, you could override the path.
	Path(override ...string) string
	// Scheme contains the request protocol string: http or https for TLS requests.
	// Please use Config.EnableTrustedProxyCheck to prevent header spoofing, in case when your app is behind the proxy.
	Scheme() string
	// Protocol returns the HTTP protocol of request: HTTP/1.1 and HTTP/2.
	Protocol() string
	// Query returns the query string parameter in the url.
	// Defaults to empty string "" if the query doesn't exist.
	// If a default value is given, it will return that value if the query doesn't exist.
	// Returned value is only valid within the handler. Do not store any references.
	// Make copies or use the Immutable setting to use the value outside the Handler.
	Query(key string, defaultValue ...string) string
	// Queries returns a map of query parameters and their values.
	//
	// GET /?name=alex&wanna_cake=2&id=
	// Queries()["name"] == "alex"
	// Queries()["wanna_cake"] == "2"
	// Queries()["id"] == ""
	//
	// GET /?field1=value1&field1=value2&field2=value3
	// Queries()["field1"] == "value2"
	// Queries()["field2"] == "value3"
	//
	// GET /?list_a=1&list_a=2&list_a=3&list_b[]=1&list_b[]=2&list_b[]=3&list_c=1,2,3
	// Queries()["list_a"] == "3"
	// Queries()["list_b[]"] == "3"
	// Queries()["list_c"] == "1,2,3"
	//
	// GET /api/search?filters.author.name=John&filters.category.name=Technology&filters[customer][name]=Alice&filters[status]=pending
	// Queries()["filters.author.name"] == "John"
	// Queries()["filters.category.name"] == "Technology"
	// Queries()["filters[customer][name]"] == "Alice"
	// Queries()["filters[status]"] == "pending"
	Queries() map[string]string
	// Range returns a struct containing the type and a slice of ranges.
	Range(size int) (Range, error)
	// Redirect returns the Redirect reference.
	// Use Redirect().Status() to set custom redirection status code.
	// If status is not specified, status defaults to 302 Found.
	// You can use Redirect().To(), Redirect().Route() and Redirect().Back() for redirection.
	Redirect() *Redirect
	// ViewBind Add vars to default view var map binding to template engine.
	// Variables are read by the Render method and may be overwritten.
	ViewBind(vars Map) error

	// GetRouteURL generates URLs to named routes, with parameters. URLs are relative, for example: "/user/1831"
	GetRouteURL(routeName string, params Map) (string, error)
	// Render a template with data and sends a text/html response.
	// We support the following engines: https://github.com/gofiber/template
	Render(name string, bind Map, layouts ...string) error

	// Route returns the matched Route struct.
	Route() *Route
	// SaveFile saves any multipart file to disk.
	SaveFile(fileheader *multipart.FileHeader, path string) error
	// SaveFileToStorage saves any multipart file to an external storage system.
	SaveFileToStorage(fileheader *multipart.FileHeader, path string, storage Storage) error
	// Secure returns whether a secure connection was established.
	Secure() bool
	// Send sets the HTTP response body without copying it.
	// From this point onward the body argument must not be changed.
	Send(body []byte) error
	// SendFile transfers the file from the given path.
	// The file is not compressed by default, enable this by passing a 'true' argument
	// Sets the Content-Type response HTTP header field based on the filenames extension.
	SendFile(file string, config ...SendFile) error
	// SendStatus sets the HTTP status code and if the response body is empty,
	// it sets the correct status message in the body.
	SendStatus(status int) error
	// SendString sets the HTTP response body for string types.
	// This means no type assertion, recommended for faster performance
	SendString(body string) error
	// SendStream sets response body stream and optional body size.
	SendStream(stream io.Reader, size ...int) error
	// Set sets the response's HTTP header field to the specified key, value.
	Set(key, val string)

	// Subdomains returns a string slice of subdomains in the domain name of the request.
	// The subdomain offset, which defaults to 2, is used for determining the beginning of the subdomain segments.
	Subdomains(offset ...int) []string
	// Stale is not implemented yet, pull requests are welcome!
	Stale() bool
	// Status sets the HTTP status for the response.
	// This method is chainable.
	Status(status int) Ctx
	// String returns unique string representation of the ctx.
	//
	// The returned value may be useful for logging.
	String() string
	// Type sets the Content-Type HTTP header to the MIME type specified by the file extension.
	Type(extension string, charset ...string) Ctx
	// Vary adds the given header field to the Vary response header.
	// This will append the header, if not already listed, otherwise leaves it listed in the current location.
	Vary(fields ...string)
	// Write appends p into response body.
	Write(p []byte) (int, error)
	// Writef appends f & a into response body writer.
	Writef(f string, a ...any) (int, error)
	// WriteString appends s to response body.
	WriteString(s string) (int, error)
	// XHR returns a Boolean property, that is true, if the request's X-Requested-With header field is XMLHttpRequest,
	// indicating that the request was issued by a client library (such as jQuery).
	XHR() bool

	// IsProxyTrusted checks trustworthiness of remote ip.
	// If EnableTrustedProxyCheck false, it returns true
	// IsProxyTrusted can check remote ip by proxy ranges and ip map.
	IsProxyTrusted() bool

	// IsFromLocal will return true if request came from local.
	IsFromLocal() bool
	// Bind You can bind body, cookie, headers etc. into the map, map slice, struct easily by using Binding method.
	// It gives custom binding support, detailed binding options and more.
	// Replacement of: BodyParser, ParamsParser, GetReqHeaders, GetRespHeaders, AllParams, QueryParser, ReqHeaderParser
	Bind() *Bind
	// Reset is a method to reset context fields by given request when to use server handlers.
	Reset(fctx *fasthttp.RequestCtx)
	// contains filtered or unexported methods
}

Ctx represents the Context which hold the HTTP request and response. It has methods for the request query string, parameters, body, HTTP headers and so on.

type CustomBinder 

type CustomBinder interface {
	Name() string
	MIMETypes() []string
	Parse(c Ctx, out any) error
}

CustomBinder An interface to register custom binders.

type CustomConstraint 

type CustomConstraint interface {
	// Name returns the name of the constraint.
	// This name is used in the constraint matching.
	Name() string

	// Execute executes the constraint.
	// It returns true if the constraint is matched and right.
	// param is the parameter value to check.
	// args are the constraint arguments.
	Execute(param string, args ...string) bool
}

CustomConstraint is an interface for custom constraints

type CustomCtx 

type CustomCtx interface {
	Ctx

	// Reset is a method to reset context fields by given request when to use server handlers.
	Reset(fctx *fasthttp.RequestCtx)
	// contains filtered or unexported methods
}

type DefaultCtx 

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

DefaultCtx is the default implementation of the Ctx interface generation tool `go install github.com/vburenin/ifacemaker@975a95966976eeb2d4365a7fb236e274c54da64c` https://github.com/vburenin/ifacemaker/blob/975a95966976eeb2d4365a7fb236e274c54da64c/ifacemaker.go#L14-L30

func NewDefaultCtx 

func NewDefaultCtx(app *App) *DefaultCtx

func (*DefaultCtx) Accepts 

func (c *DefaultCtx) Accepts(offers ...string) string

Accepts checks if the specified extensions or content types are acceptable.

func (*DefaultCtx) AcceptsCharsets 

func (c *DefaultCtx) AcceptsCharsets(offers ...string) string

AcceptsCharsets checks if the specified charset is acceptable.

func (*DefaultCtx) AcceptsEncodings 

func (c *DefaultCtx) AcceptsEncodings(offers ...string) string

AcceptsEncodings checks if the specified encoding is acceptable.

func (*DefaultCtx) AcceptsLanguages 

func (c *DefaultCtx) AcceptsLanguages(offers ...string) string

AcceptsLanguages checks if the specified language is acceptable.

func (*DefaultCtx) App 

func (c *DefaultCtx) App() *App

App returns the *App reference to the instance of the Fiber application

func (*DefaultCtx) Append 

func (c *DefaultCtx) Append(field string, values ...string)

Append the specified value to the HTTP response header field. If the header is not already set, it creates the header with the specified value.

func (*DefaultCtx) Attachment 

func (c *DefaultCtx) Attachment(filename ...string)

Attachment sets the HTTP response Content-Disposition header field to attachment.

func (*DefaultCtx) AutoFormat 

func (c *DefaultCtx) AutoFormat(body any) error

AutoFormat performs content-negotiation on the Accept HTTP header. It uses Accepts to select a proper format. The supported content types are text/html, text/plain, application/json, and application/xml. For more flexible content negotiation, use Format. If the header is not specified or there is no proper format, text/plain is used.

func (*DefaultCtx) BaseURL 

func (c *DefaultCtx) BaseURL() string

BaseURL returns (protocol + host + base path).

func (*DefaultCtx) Bind 

func (c *DefaultCtx) Bind() *Bind

Bind You can bind body, cookie, headers etc. into the map, map slice, struct easily by using Binding method. It gives custom binding support, detailed binding options and more. Replacement of: BodyParser, ParamsParser, GetReqHeaders, GetRespHeaders, AllParams, QueryParser, ReqHeaderParser

func (*DefaultCtx) Body 

func (c *DefaultCtx) Body() []byte

Body contains the raw body submitted in a POST request. This method will decompress the body if the 'Content-Encoding' header is provided. It returns the original (or decompressed) body data which is valid only within the handler. Don't store direct references to the returned data. If you need to keep the body's data later, make a copy or use the Immutable option.

func (*DefaultCtx) BodyRaw 

func (c *DefaultCtx) BodyRaw() []byte

BodyRaw contains the raw body submitted in a POST request. Returned value is only valid within the handler. Do not store any references. Make copies or use the Immutable setting instead.

func (*DefaultCtx) ClearCookie 

func (c *DefaultCtx) ClearCookie(key ...string)

ClearCookie expires a specific cookie by key on the client side. If no key is provided it expires all cookies that came with the request.

func (*DefaultCtx) ClientHelloInfo 

func (c *DefaultCtx) ClientHelloInfo() *tls.ClientHelloInfo

ClientHelloInfo return CHI from context

func (*DefaultCtx) Context 

func (c *DefaultCtx) Context() *fasthttp.RequestCtx

Context returns *fasthttp.RequestCtx that carries a deadline a cancellation signal, and other values across API boundaries.

func (*DefaultCtx) Cookie 

func (c *DefaultCtx) Cookie(cookie *Cookie)

Cookie sets a cookie by passing a cookie struct.

func (*DefaultCtx) Cookies 

func (c *DefaultCtx) Cookies(key string, defaultValue ...string) string

Cookies are used for getting a cookie value by key. Defaults to the empty string "" if the cookie doesn't exist. If a default value is given, it will return that value if the cookie doesn't exist. The returned value is only valid within the handler. Do not store any references. Make copies or use the Immutable setting to use the value outside the Handler.

func (*DefaultCtx) Download 

func (c *DefaultCtx) Download(file string, filename ...string) error

Download transfers the file from path as an attachment. Typically, browsers will prompt the user for download. By default, the Content-Disposition header filename= parameter is the filepath (this typically appears in the browser dialog). Override this default with the filename parameter.

func (*DefaultCtx) FormFile 

func (c *DefaultCtx) FormFile(key string) (*multipart.FileHeader, error)

FormFile returns the first file by key from a MultipartForm.

func (*DefaultCtx) FormValue 

func (c *DefaultCtx) FormValue(key string, defaultValue ...string) string

FormValue returns the first value by key from a MultipartForm. Search is performed in QueryArgs, PostArgs, MultipartForm and FormFile in this particular order. Defaults to the empty string "" if the form value doesn't exist. If a default value is given, it will return that value if the form value does not exist. Returned value is only valid within the handler. Do not store any references. Make copies or use the Immutable setting instead.

func (*DefaultCtx) Format 

func (c *DefaultCtx) Format(handlers ...ResFmt) error

Format performs content-negotiation on the Accept HTTP header. It uses Accepts to select a proper format and calls the matching user-provided handler function. If no accepted format is found, and a format with MediaType "default" is given, that default handler is called. If no format is found and no default is given, StatusNotAcceptable is sent.

func (*DefaultCtx) Fresh 

func (c *DefaultCtx) Fresh() bool

Fresh returns true when the response is still “fresh” in the client's cache, otherwise false is returned to indicate that the client cache is now stale and the full response should be sent. When a client sends the Cache-Control: no-cache request header to indicate an end-to-end reload request, this module will return false to make handling these requests transparent. https://github.com/jshttp/fresh/blob/10e0471669dbbfbfd8de65bc6efac2ddd0bfa057/index.js#L33

func (*DefaultCtx) Get 

func (c *DefaultCtx) Get(key string, defaultValue ...string) string

Get returns the HTTP request header specified by field. Field names are case-insensitive Returned value is only valid within the handler. Do not store any references. Make copies or use the Immutable setting instead.

func (*DefaultCtx) GetReqHeaders 

func (c *DefaultCtx) GetReqHeaders() map[string][]string

GetReqHeaders returns the HTTP request headers. Returned value is only valid within the handler. Do not store any references. Make copies or use the Immutable setting instead.

func (*DefaultCtx) GetRespHeader 

func (c *DefaultCtx) GetRespHeader(key string, defaultValue ...string) string

GetRespHeader returns the HTTP response header specified by field. Field names are case-insensitive Returned value is only valid within the handler. Do not store any references. Make copies or use the Immutable setting instead.

func (*DefaultCtx) GetRespHeaders 

func (c *DefaultCtx) GetRespHeaders() map[string][]string

GetRespHeaders returns the HTTP response headers. Returned value is only valid within the handler. Do not store any references. Make copies or use the Immutable setting instead.

func (*DefaultCtx) GetRouteURL 

func (c *DefaultCtx) GetRouteURL(routeName string, params Map) (string, error)

GetRouteURL generates URLs to named routes, with parameters. URLs are relative, for example: "/user/1831"

func (*DefaultCtx) Host 

func (c *DefaultCtx) Host() string

Host contains the host derived from the X-Forwarded-Host or Host HTTP header. Returned value is only valid within the handler. Do not store any references. In a network context, `Host` refers to the combination of a hostname and potentially a port number used for connecting, while `Hostname` refers specifically to the name assigned to a device on a network, excluding any port information. Example: URL: https://example.com:8080 -> Host: example.com:8080 Make copies or use the Immutable setting instead. Please use Config.EnableTrustedProxyCheck to prevent header spoofing, in case when your app is behind the proxy.

func (*DefaultCtx) Hostname 

func (c *DefaultCtx) Hostname() string

Hostname contains the hostname derived from the X-Forwarded-Host or Host HTTP header using the c.Host() method. Returned value is only valid within the handler. Do not store any references. Example: URL: https://example.com:8080 -> Hostname: example.com Make copies or use the Immutable setting instead. Please use Config.EnableTrustedProxyCheck to prevent header spoofing, in case when your app is behind the proxy.

func (*DefaultCtx) IP 

func (c *DefaultCtx) IP() string

IP returns the remote IP address of the request. If ProxyHeader and IP Validation is configured, it will parse that header and return the first valid IP address. Please use Config.EnableTrustedProxyCheck to prevent header spoofing, in case when your app is behind the proxy.

func (*DefaultCtx) IPs 

func (c *DefaultCtx) IPs() []string

IPs returns a string slice of IP addresses specified in the X-Forwarded-For request header. When IP validation is enabled, only valid IPs are returned.

func (*DefaultCtx) Is 

func (c *DefaultCtx) Is(extension string) bool

Is returns the matching content type, if the incoming request's Content-Type HTTP header field matches the MIME type specified by the type parameter

func (*DefaultCtx) IsFromLocal 

func (c *DefaultCtx) IsFromLocal() bool

IsFromLocal will return true if request came from local.

func (*DefaultCtx) IsProxyTrusted 

func (c *DefaultCtx) IsProxyTrusted() bool

IsProxyTrusted checks trustworthiness of remote ip. If EnableTrustedProxyCheck false, it returns true IsProxyTrusted can check remote ip by proxy ranges and ip map.

func (*DefaultCtx) JSON 

func (c *DefaultCtx) JSON(data any, ctype ...string) error

JSON converts any interface or string to JSON. Array and slice values encode as JSON arrays, except that []byte encodes as a base64-encoded string, and a nil slice encodes as the null JSON value. If the ctype parameter is given, this method will set the Content-Type header equal to ctype. If ctype is not given, The Content-Type header will be set to application/json.

func (*DefaultCtx) JSONP 

func (c *DefaultCtx) JSONP(data any, callback ...string) error

JSONP sends a JSON response with JSONP support. This method is identical to JSON, except that it opts-in to JSONP callback support. By default, the callback name is simply callback. 

func (c *DefaultCtx) Links(link ...string)

Links joins the links followed by the property to populate the response's Link HTTP header field.

func (*DefaultCtx) Locals 

func (c *DefaultCtx) Locals(key any, value ...any) any

Locals makes it possible to pass any values under keys scoped to the request and therefore available to all following routes that match the request.

All the values are removed from ctx after returning from the top RequestHandler. Additionally, Close method is called on each value implementing io.Closer before removing the value from ctx.

func (*DefaultCtx) Location 

func (c *DefaultCtx) Location(path string)

Location sets the response Location HTTP header to the specified path parameter.

func (*DefaultCtx) Method 

func (c *DefaultCtx) Method(override ...string) string

Method returns the HTTP request method for the context, optionally overridden by the provided argument. If no override is given or if the provided override is not a valid HTTP method, it returns the current method from the context. Otherwise, it updates the context's method and returns the overridden method as a string.

func (*DefaultCtx) MultipartForm 

func (c *DefaultCtx) MultipartForm() (*multipart.Form, error)

MultipartForm parse form entries from binary. This returns a map[string][]string, so given a key the value will be a string slice.

func (*DefaultCtx) Next 

func (c *DefaultCtx) Next() error

Next executes the next method in the stack that matches the current route.

func (*DefaultCtx) OriginalURL 

func (c *DefaultCtx) OriginalURL() string

OriginalURL contains the original request URL. Returned value is only valid within the handler. Do not store any references. Make copies or use the Immutable setting to use the value outside the Handler.

func (*DefaultCtx) Params 

func (c *DefaultCtx) Params(key string, defaultValue ...string) string

Params is used to get the route parameters. Defaults to empty string "" if the param doesn't exist. If a default value is given, it will return that value if the param doesn't exist. Returned value is only valid within the handler. Do not store any references. Make copies or use the Immutable setting to use the value outside the Handler.

func (*DefaultCtx) Path 

func (c *DefaultCtx) Path(override ...string) string

Path returns the path part of the request URL. Optionally, you could override the path.

func (*DefaultCtx) Port 

func (c *DefaultCtx) Port() string

Port returns the remote port of the request.

func (*DefaultCtx) Protocol 

func (c *DefaultCtx) Protocol() string

Protocol returns the HTTP protocol of request: HTTP/1.1 and HTTP/2.

func (*DefaultCtx) Queries 

func (c *DefaultCtx) Queries() map[string]string

Queries returns a map of query parameters and their values.

GET /?name=alex&wanna_cake=2&id= Queries()["name"] == "alex" Queries()["wanna_cake"] == "2" Queries()["id"] == ""

GET /?field1=value1&field1=value2&field2=value3 Queries()["field1"] == "value2" Queries()["field2"] == "value3"

GET /?list_a=1&list_a=2&list_a=3&list_b[]=1&list_b[]=2&list_b[]=3&list_c=1,2,3 Queries()["list_a"] == "3" Queries()["list_b[]"] == "3" Queries()["list_c"] == "1,2,3"

GET /api/search?filters.author.name=John&filters.category.name=Technology&filters[customer][name]=Alice&filters[status]=pending Queries()["filters.author.name"] == "John" Queries()["filters.category.name"] == "Technology" Queries()["filters[customer][name]"] == "Alice" Queries()["filters[status]"] == "pending"

func (*DefaultCtx) Query 

func (c *DefaultCtx) Query(key string, defaultValue ...string) string

Query returns the query string parameter in the url. Defaults to empty string "" if the query doesn't exist. If a default value is given, it will return that value if the query doesn't exist. Returned value is only valid within the handler. Do not store any references. Make copies or use the Immutable setting to use the value outside the Handler.

func (*DefaultCtx) Range 

func (c *DefaultCtx) Range(size int) (Range, error)

Range returns a struct containing the type and a slice of ranges.

func (*DefaultCtx) Redirect 

func (c *DefaultCtx) Redirect() *Redirect

Redirect returns the Redirect reference. Use Redirect().Status() to set custom redirection status code. If status is not specified, status defaults to 302 Found. You can use Redirect().To(), Redirect().Route() and Redirect().Back() for redirection.

func (*DefaultCtx) Render 

func (c *DefaultCtx) Render(name string, bind Map, layouts ...string) error

Render a template with data and sends a text/html response. We support the following engines: https://github.com/gofiber/template

func (*DefaultCtx) Request 

func (c *DefaultCtx) Request() *fasthttp.Request

Request return the *fasthttp.Request object This allows you to use all fasthttp request methods https://godoc.org/github.com/valyala/fasthttp#Request

func (*DefaultCtx) Reset 

func (c *DefaultCtx) Reset(fctx *fasthttp.RequestCtx)

Reset is a method to reset context fields by given request when to use server handlers.

func (*DefaultCtx) Response 

func (c *DefaultCtx) Response() *fasthttp.Response

Response return the *fasthttp.Response object This allows you to use all fasthttp response methods https://godoc.org/github.com/valyala/fasthttp#Response

func (*DefaultCtx) RestartRouting 

func (c *DefaultCtx) RestartRouting() error

RestartRouting instead of going to the next handler. This may be useful after changing the request path. Note that handlers might be executed again.

func (*DefaultCtx) Route 

func (c *DefaultCtx) Route() *Route

Route returns the matched Route struct.

func (*DefaultCtx) SaveFile 

func (*DefaultCtx) SaveFile(fileheader *multipart.FileHeader, path string) error

SaveFile saves any multipart file to disk.

func (*DefaultCtx) SaveFileToStorage 

func (*DefaultCtx) SaveFileToStorage(fileheader *multipart.FileHeader, path string, storage Storage) error

SaveFileToStorage saves any multipart file to an external storage system.

func (*DefaultCtx) Scheme 

func (c *DefaultCtx) Scheme() string

Scheme contains the request protocol string: http or https for TLS requests. Please use Config.EnableTrustedProxyCheck to prevent header spoofing, in case when your app is behind the proxy.

func (*DefaultCtx) Secure 

func (c *DefaultCtx) Secure() bool

Secure returns whether a secure connection was established.

func (*DefaultCtx) Send 

func (c *DefaultCtx) Send(body []byte) error

Send sets the HTTP response body without copying it. From this point onward the body argument must not be changed.

func (*DefaultCtx) SendFile 

func (c *DefaultCtx) SendFile(file string, config ...SendFile) error

SendFile transfers the file from the given path. The file is not compressed by default, enable this by passing a 'true' argument Sets the Content-Type response HTTP header field based on the filenames extension.

func (*DefaultCtx) SendStatus 

func (c *DefaultCtx) SendStatus(status int) error

SendStatus sets the HTTP status code and if the response body is empty, it sets the correct status message in the body.

func (*DefaultCtx) SendStream 

func (c *DefaultCtx) SendStream(stream io.Reader, size ...int) error

SendStream sets response body stream and optional body size.

func (*DefaultCtx) SendString 

func (c *DefaultCtx) SendString(body string) error

SendString sets the HTTP response body for string types. This means no type assertion, recommended for faster performance

func (*DefaultCtx) Set 

func (c *DefaultCtx) Set(key, val string)

Set sets the response's HTTP header field to the specified key, value.

func (*DefaultCtx) SetUserContext 

func (c *DefaultCtx) SetUserContext(ctx context.Context)

SetUserContext sets a context implementation by user.

func (*DefaultCtx) Stale 

func (c *DefaultCtx) Stale() bool

Stale is not implemented yet, pull requests are welcome!

func (*DefaultCtx) Status 

func (c *DefaultCtx) Status(status int) Ctx

Status sets the HTTP status for the response. This method is chainable.

func (*DefaultCtx) String 

func (c *DefaultCtx) String() string

String returns unique string representation of the ctx.

The returned value may be useful for logging.

func (*DefaultCtx) Subdomains 

func (c *DefaultCtx) Subdomains(offset ...int) []string

Subdomains returns a string slice of subdomains in the domain name of the request. The subdomain offset, which defaults to 2, is used for determining the beginning of the subdomain segments.

func (*DefaultCtx) Type 

func (c *DefaultCtx) Type(extension string, charset ...string) Ctx

Type sets the Content-Type HTTP header to the MIME type specified by the file extension.

func (*DefaultCtx) UserContext 

func (c *DefaultCtx) UserContext() context.Context

UserContext returns a context implementation that was set by user earlier or returns a non-nil, empty context,if it was not set earlier.

func (*DefaultCtx) Vary 

func (c *DefaultCtx) Vary(fields ...string)

Vary adds the given header field to the Vary response header. This will append the header, if not already listed, otherwise leaves it listed in the current location.

func (*DefaultCtx) ViewBind 

func (c *DefaultCtx) ViewBind(vars Map) error

ViewBind Add vars to default view var map binding to template engine. Variables are read by the Render method and may be overwritten.

func (*DefaultCtx) Write 

func (c *DefaultCtx) Write(p []byte) (int, error)

Write appends p into response body.

func (*DefaultCtx) WriteString 

func (c *DefaultCtx) WriteString(s string) (int, error)

WriteString appends s to response body.

func (*DefaultCtx) Writef 

func (c *DefaultCtx) Writef(f string, a ...any) (int, error)

Writef appends f & a into response body writer.

func (*DefaultCtx) XHR 

func (c *DefaultCtx) XHR() bool

XHR returns a Boolean property, that is true, if the request's X-Requested-With header field is XMLHttpRequest, indicating that the request was issued by a client library (such as jQuery).

func (*DefaultCtx) XML 

func (c *DefaultCtx) XML(data any) error

XML converts any interface or string to XML. This method also sets the content header to application/xml.

type EmptyFieldError 

type EmptyFieldError = schema.EmptyFieldError

EmptyFieldError error exposes the internal schema.EmptyFieldError for public use.

type Error 

type Error struct {
	Message string `json:"message"`
	Code    int    `json:"code"`
}

Error represents an error that occurred while handling a request.

func NewError 

func NewError(code int, message ...string) *Error

NewError creates a new Error instance with an optional message

func (*Error) Error 

func (e *Error) Error() string

Error makes it compatible with the `error` interface.

type ErrorHandler 

type ErrorHandler = func(Ctx, error) error

ErrorHandler defines a function that will process all errors returned from any handlers in the stack 

cfg := fiber.Config{}
cfg.ErrorHandler = func(c Ctx, err error) error {
 code := StatusInternalServerError
 var e *fiber.Error
 if errors.As(err, &e) {
   code = e.Code
 }
 c.Set(HeaderContentType, MIMETextPlainCharsetUTF8)
 return c.Status(code).SendString(err.Error())
}
app := fiber.New(cfg)

type GenericType 

type GenericType interface {
	GenericTypeInteger | GenericTypeFloat | bool | string | []byte
}

type GenericTypeFloat 

type GenericTypeFloat interface {
	float32 | float64
}

type GenericTypeInteger 

type GenericTypeInteger interface {
	GenericTypeIntegerSigned | GenericTypeIntegerUnsigned
}

type GenericTypeIntegerSigned 

type GenericTypeIntegerSigned interface {
	int | int8 | int16 | int32 | int64
}

type GenericTypeIntegerUnsigned 

type GenericTypeIntegerUnsigned interface {
	uint | uint8 | uint16 | uint32 | uint64
}

type Group 

type Group struct {
	Prefix string
	// contains filtered or unexported fields
}

Group struct

func (*Group) Add 

func (grp *Group) Add(methods []string, path string, handler Handler, middleware ...Handler) Router

Add allows you to specify multiple HTTP methods to register a route.

func (*Group) All 

func (grp *Group) All(path string, handler Handler, middleware ...Handler) Router

All will register the handler on all HTTP methods

func (*Group) Connect 

func (grp *Group) Connect(path string, handler Handler, middleware ...Handler) Router

Connect registers a route for CONNECT methods that establishes a tunnel to the server identified by the target resource.

func (*Group) Delete 

func (grp *Group) Delete(path string, handler Handler, middleware ...Handler) Router

Delete registers a route for DELETE methods that deletes the specified resource.

func (*Group) Get 

func (grp *Group) Get(path string, handler Handler, middleware ...Handler) Router

Get registers a route for GET methods that requests a representation of the specified resource. Requests using GET should only retrieve data.

func (*Group) Group 

func (grp *Group) Group(prefix string, handlers ...Handler) Router

Group is used for Routes with common prefix to define a new sub-router with optional middleware. 

api := app.Group("/api")
api.Get("/users", handler)

func (*Group) Head 

func (grp *Group) Head(path string, handler Handler, middleware ...Handler) Router

Head registers a route for HEAD methods that asks for a response identical to that of a GET request, but without the response body.

func (*Group) Name 

func (grp *Group) Name(name string) Router

Name Assign name to specific route or group itself.

If this method is used before any route added to group, it'll set group name and OnGroupNameHook will be used. Otherwise, it'll set route name and OnName hook will be used.

func (*Group) Options 

func (grp *Group) Options(path string, handler Handler, middleware ...Handler) Router

Options registers a route for OPTIONS methods that is used to describe the communication options for the target resource.

func (*Group) Patch 

func (grp *Group) Patch(path string, handler Handler, middleware ...Handler) Router

Patch registers a route for PATCH methods that is used to apply partial modifications to a resource.

func (*Group) Post 

func (grp *Group) Post(path string, handler Handler, middleware ...Handler) Router

Post registers a route for POST methods that is used to submit an entity to the specified resource, often causing a change in state or side effects on the server.

func (*Group) Put 

func (grp *Group) Put(path string, handler Handler, middleware ...Handler) Router

Put registers a route for PUT methods that replaces all current representations of the target resource with the request payload.

func (*Group) Route 

func (grp *Group) Route(path string) Register

Route is used to define routes with a common prefix inside the common function. Uses Group method to define new sub-router.

func (*Group) Trace 

func (grp *Group) Trace(path string, handler Handler, middleware ...Handler) Router

Trace registers a route for TRACE methods that performs a message loop-back test along the path to the target resource.

func (*Group) Use 

func (grp *Group) Use(args ...any) Router

Use registers a middleware route that will match requests with the provided prefix (which is optional and defaults to "/"). Also, you can pass another app instance as a sub-router along a routing path. It's very useful to split up a large API as many independent routers and compose them as a single service using Use. The fiber's error handler and any of the fiber's sub apps are added to the application's error handlers to be invoked on errors that happen within the prefix route. 

	app.Use(func(c fiber.Ctx) error {
	     return c.Next()
	})
	app.Use("/api", func(c fiber.Ctx) error {
	     return c.Next()
	})
	app.Use("/api", handler, func(c fiber.Ctx) error {
	     return c.Next()
	})
 	subApp := fiber.New()
	app.Use("/mounted-path", subApp)

This method will match all HTTP verbs: GET, POST, PUT, HEAD etc...

type Handler 

type Handler = func(Ctx) error

Handler defines a function to serve HTTP requests.

type Hooks 

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

Hooks is a struct to use it with App.

func (*Hooks) OnFork 

func (h *Hooks) OnFork(handler ...OnForkHandler)

OnFork is a hook to execute user function after fork process.

func (*Hooks) OnGroup 

func (h *Hooks) OnGroup(handler ...OnGroupHandler)

OnGroup is a hook to execute user functions on each group registeration. Also you can get group properties by group parameter.

func (*Hooks) OnGroupName 

func (h *Hooks) OnGroupName(handler ...OnGroupNameHandler)

OnGroupName is a hook to execute user functions on each group naming. Also you can get group properties by group parameter.

WARN: OnGroupName only works with naming groups, not routes.

func (*Hooks) OnListen 

func (h *Hooks) OnListen(handler ...OnListenHandler)

OnListen is a hook to execute user functions on Listen, ListenTLS, Listener.

func (*Hooks) OnMount 

func (h *Hooks) OnMount(handler ...OnMountHandler)

OnMount is a hook to execute user function after mounting process. The mount event is fired when sub-app is mounted on a parent app. The parent app is passed as a parameter. It works for app and group mounting.

func (*Hooks) OnName 

func (h *Hooks) OnName(handler ...OnNameHandler)

OnName is a hook to execute user functions on each route naming. Also you can get route properties by route parameter.

WARN: OnName only works with naming routes, not groups.

func (*Hooks) OnRoute 

func (h *Hooks) OnRoute(handler ...OnRouteHandler)

OnRoute is a hook to execute user functions on each route registeration. Also you can get route properties by route parameter.

func (*Hooks) OnShutdown 

func (h *Hooks) OnShutdown(handler ...OnShutdownHandler)

OnShutdown is a hook to execute user functions after Shutdown.

type InvalidUnmarshalError 

type InvalidUnmarshalError = json.InvalidUnmarshalError

An InvalidUnmarshalError describes an invalid argument passed to Unmarshal. (The argument to Unmarshal must be a non-nil pointer.)

type ListenConfig 

type ListenConfig struct {
	// GracefulContext is a field to shutdown Fiber by given context gracefully.
	//
	// Default: nil
	GracefulContext context.Context `json:"graceful_context"` //nolint:containedctx // It's needed to set context inside Listen.

	// TLSConfigFunc allows customizing tls.Config as you want.
	//
	// Default: nil
	TLSConfigFunc func(tlsConfig *tls.Config) `json:"tls_config_func"`

	// ListenerFunc allows accessing and customizing net.Listener.
	//
	// Default: nil
	ListenerAddrFunc func(addr net.Addr) `json:"listener_addr_func"`

	// BeforeServeFunc allows customizing and accessing fiber app before serving the app.
	//
	// Default: nil
	BeforeServeFunc func(app *App) error `json:"before_serve_func"`

	// OnShutdownError allows to customize error behavior when to graceful shutdown server by given signal.
	//
	// Print error with log.Fatalf() by default.
	// Default: nil
	OnShutdownError func(err error)

	// OnShutdownSuccess allows to customize success behavior when to graceful shutdown server by given signal.
	//
	// Default: nil
	OnShutdownSuccess func()
	// Known networks are "tcp", "tcp4" (IPv4-only), "tcp6" (IPv6-only)
	// WARNING: When prefork is set to true, only "tcp4" and "tcp6" can be chosen.
	//
	// Default: NetworkTCP4
	ListenerNetwork string `json:"listener_network"`

	// CertFile is a path of certficate file.
	// If you want to use TLS, you have to enter this field.
	//
	// Default : ""
	CertFile string `json:"cert_file"`

	// KeyFile is a path of certficate's private key.
	// If you want to use TLS, you have to enter this field.
	//
	// Default : ""
	CertKeyFile string `json:"cert_key_file"`

	// CertClientFile is a path of client certficate.
	// If you want to use mTLS, you have to enter this field.
	//
	// Default : ""
	CertClientFile string `json:"cert_client_file"`

	// When set to true, it will not print out the «Fiber» ASCII art and listening address.
	//
	// Default: false
	DisableStartupMessage bool `json:"disable_startup_message"`

	// When set to true, this will spawn multiple Go processes listening on the same port.
	//
	// Default: false
	EnablePrefork bool `json:"enable_prefork"`

	// If set to true, will print all routes with their method, path and handler.
	//
	// Default: false
	EnablePrintRoutes bool `json:"enable_print_routes"`
}

ListenConfig is a struct to customize startup of Fiber.

TODO: Add timeout for graceful shutdown.

type ListenData 

type ListenData struct {
	Host string
	Port string
	TLS  bool
}

ListenData is a struct to use it with OnListenHandler

type Map 

type Map map[string]any

Map is a shortcut for map[string]any, useful for JSON returns

type MarshalerError 

type MarshalerError = json.MarshalerError

A MarshalerError represents an error from calling a MarshalJSON or MarshalText method.

type MultiError 

type MultiError = schema.MultiError

MultiError error exposes the internal schema.MultiError for public use.

type OnForkHandler 

type OnForkHandler = func(int) error

OnRouteHandler Handlers define a function to create hooks for Fiber.

type OnGroupHandler 

type OnGroupHandler = func(Group) error

OnRouteHandler Handlers define a function to create hooks for Fiber.

type OnGroupNameHandler 

type OnGroupNameHandler = OnGroupHandler

OnRouteHandler Handlers define a function to create hooks for Fiber.

type OnListenHandler 

type OnListenHandler = func(ListenData) error

OnRouteHandler Handlers define a function to create hooks for Fiber.

type OnMountHandler 

type OnMountHandler = func(*App) error

OnRouteHandler Handlers define a function to create hooks for Fiber.

type OnNameHandler 

type OnNameHandler = OnRouteHandler

OnRouteHandler Handlers define a function to create hooks for Fiber.

type OnRouteHandler 

type OnRouteHandler = func(Route) error

OnRouteHandler Handlers define a function to create hooks for Fiber.

type OnShutdownHandler 

type OnShutdownHandler = func() error

OnRouteHandler Handlers define a function to create hooks for Fiber.

type Range 

type Range struct {
	Type   string
	Ranges []RangeSet
}

Range data for c.Range

type RangeSet 

type RangeSet struct {
	Start int
	End   int
}

RangeSet represents a single content range from a request.

type Redirect 

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

Redirect is a struct that holds the redirect data.

func AcquireRedirect 

func AcquireRedirect() *Redirect

AcquireRedirect return default Redirect reference from the redirect pool

func (*Redirect) Back 

func (r *Redirect) Back(fallback ...string) error

Back redirect to the URL to referer.

func (*Redirect) Message 

func (r *Redirect) Message(key string) string

Message Get flash message by key.

func (*Redirect) Messages 

func (r *Redirect) Messages() map[string]string

Messages Get flash messages.

func (*Redirect) OldInput 

func (r *Redirect) OldInput(key string) string

OldInput Get old input data by key.

func (*Redirect) OldInputs 

func (r *Redirect) OldInputs() map[string]string

OldInputs Get old input data.

func (*Redirect) Route 

func (r *Redirect) Route(name string, config ...RedirectConfig) error

Route redirects to the Route registered in the app with appropriate parameters. If you want to send queries or params to route, you should use config parameter.

func (*Redirect) Status 

func (r *Redirect) Status(code int) *Redirect

Status sets the status code of redirection. If status is not specified, status defaults to 302 Found.

func (*Redirect) To 

func (r *Redirect) To(location string) error

To redirect to the URL derived from the specified path, with specified status.

func (*Redirect) With 

func (r *Redirect) With(key, value string) *Redirect

With You can send flash messages by using With(). They will be sent as a cookie. You can get them by using: Redirect().Messages(), Redirect().Message() Note: You must use escape char before using ',' and ':' chars to avoid wrong parsing.

func (*Redirect) WithInput 

func (r *Redirect) WithInput() *Redirect

WithInput You can send input data by using WithInput(). They will be sent as a cookie. This method can send form, multipart form, query data to redirected route. You can get them by using: Redirect().OldInputs(), Redirect().OldInput()

type RedirectConfig 

type RedirectConfig struct {
	Params  Map               // Route parameters
	Queries map[string]string // Query map
}

RedirectConfig A config to use with Redirect().Route() You can specify queries or route parameters. NOTE: We don't use net/url to parse parameters because of it has poor performance. You have to pass map.

type Register 

type Register interface {
	All(handler Handler, middleware ...Handler) Register
	Get(handler Handler, middleware ...Handler) Register
	Head(handler Handler, middleware ...Handler) Register
	Post(handler Handler, middleware ...Handler) Register
	Put(handler Handler, middleware ...Handler) Register
	Delete(handler Handler, middleware ...Handler) Register
	Connect(handler Handler, middleware ...Handler) Register
	Options(handler Handler, middleware ...Handler) Register
	Trace(handler Handler, middleware ...Handler) Register
	Patch(handler Handler, middleware ...Handler) Register

	Add(methods []string, handler Handler, middleware ...Handler) Register

	Route(path string) Register
}

Register defines all router handle interface generate by Route().

type Registering 

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

Registering struct

func (*Registering) Add 

func (r *Registering) Add(methods []string, handler Handler, middleware ...Handler) Register

Add allows you to specify multiple HTTP methods to register a route.

func (*Registering) All 

func (r *Registering) All(handler Handler, middleware ...Handler) Register

All registers a middleware route that will match requests with the provided path which is stored in register struct. 

app.Route("/").All(func(c fiber.Ctx) error {
     return c.Next()
})
app.Route("/api").All(func(c fiber.Ctx) error {
     return c.Next()
})
app.Route("/api").All(handler, func(c fiber.Ctx) error {
     return c.Next()
})

This method will match all HTTP verbs: GET, POST, PUT, HEAD etc...

func (*Registering) Connect 

func (r *Registering) Connect(handler Handler, middleware ...Handler) Register

Connect registers a route for CONNECT methods that establishes a tunnel to the server identified by the target resource.

func (*Registering) Delete 

func (r *Registering) Delete(handler Handler, middleware ...Handler) Register

Delete registers a route for DELETE methods that deletes the specified resource.

func (*Registering) Get 

func (r *Registering) Get(handler Handler, middleware ...Handler) Register

Get registers a route for GET methods that requests a representation of the specified resource. Requests using GET should only retrieve data.

func (*Registering) Head 

func (r *Registering) Head(handler Handler, middleware ...Handler) Register

Head registers a route for HEAD methods that asks for a response identical to that of a GET request, but without the response body.

func (*Registering) Options 

func (r *Registering) Options(handler Handler, middleware ...Handler) Register

Options registers a route for OPTIONS methods that is used to describe the communication options for the target resource.

func (*Registering) Patch 

func (r *Registering) Patch(handler Handler, middleware ...Handler) Register

Patch registers a route for PATCH methods that is used to apply partial modifications to a resource.

func (*Registering) Post 

func (r *Registering) Post(handler Handler, middleware ...Handler) Register

Post registers a route for POST methods that is used to submit an entity to the specified resource, often causing a change in state or side effects on the server.

func (*Registering) Put 

func (r *Registering) Put(handler Handler, middleware ...Handler) Register

Put registers a route for PUT methods that replaces all current representations of the target resource with the request payload.

func (*Registering) Route 

func (r *Registering) Route(path string) Register

Route returns a new Register instance whose route path takes the path in the current instance as its prefix.

func (*Registering) Trace 

func (r *Registering) Trace(handler Handler, middleware ...Handler) Register

Trace registers a route for TRACE methods that performs a message loop-back test along the r.Path to the target resource.

type ResFmt 

type ResFmt struct {
	Handler   func(Ctx) error
	MediaType string
}

ResFmt associates a Content Type to a fiber.Handler for c.Format

type Route 

type Route struct {

	// Public fields
	Method string `json:"method"` // HTTP method
	Name   string `json:"name"`   // Route's name
	//nolint:revive // Having both a Path (uppercase) and a path (lowercase) is fine
	Path     string    `json:"path"`   // Original registered route path
	Params   []string  `json:"params"` // Case sensitive param keys
	Handlers []Handler `json:"-"`      // Ctx handlers
	// contains filtered or unexported fields
}

Route is a struct that holds all metadata for each registered handler.

type RouteMessage 

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

RouteMessage is some message need to be print when server starts

type Router 

type Router interface {
	Use(args ...any) Router

	Get(path string, handler Handler, middleware ...Handler) Router
	Head(path string, handler Handler, middleware ...Handler) Router
	Post(path string, handler Handler, middleware ...Handler) Router
	Put(path string, handler Handler, middleware ...Handler) Router
	Delete(path string, handler Handler, middleware ...Handler) Router
	Connect(path string, handler Handler, middleware ...Handler) Router
	Options(path string, handler Handler, middleware ...Handler) Router
	Trace(path string, handler Handler, middleware ...Handler) Router
	Patch(path string, handler Handler, middleware ...Handler) Router

	Add(methods []string, path string, handler Handler, middleware ...Handler) Router
	All(path string, handler Handler, middleware ...Handler) Router

	Group(prefix string, handlers ...Handler) Router

	Route(path string) Register

	Name(name string) Router
}

Router defines all router handle interface, including app and group router.

type SendFile 

type SendFile struct {
	// FS is the file system to serve the static files from.
	// You can use interfaces compatible with fs.FS like embed.FS, os.DirFS etc.
	//
	// Optional. Default: nil
	FS fs.FS

	// When set to true, the server tries minimizing CPU usage by caching compressed files.
	// This works differently than the github.com/gofiber/compression middleware.
	// You have to set Content-Encoding header to compress the file.
	// Available compression methods are gzip, br, and zstd.
	//
	// Optional. Default value false
	Compress bool `json:"compress"`

	// When set to true, enables byte range requests.
	//
	// Optional. Default value false
	ByteRange bool `json:"byte_range"`

	// When set to true, enables direct download.
	//
	// Optional. Default: false.
	Download bool `json:"download"`

	// Expiration duration for inactive file handlers.
	// Use a negative time.Duration to disable it.
	//
	// Optional. Default value 10 * time.Second.
	CacheDuration time.Duration `json:"cache_duration"`

	// The value for the Cache-Control HTTP-header
	// that is set on the file response. MaxAge is defined in seconds.
	//
	// Optional. Default value 0.
	MaxAge int `json:"max_age"`
}

SendFile defines configuration options when to transfer file with SendFile.

type Storage 

type Storage interface {
	// Get gets the value for the given key.
	// `nil, nil` is returned when the key does not exist
	Get(key string) ([]byte, error)

	// Set stores the given value for the given key along
	// with an expiration value, 0 means no expiration.
	// Empty key or value will be ignored without an error.
	Set(key string, val []byte, exp time.Duration) error

	// Delete deletes the value for the given key.
	// It returns no error if the storage does not contain the key,
	Delete(key string) error

	// Reset resets the storage and delete all keys.
	Reset() error

	// Close closes the storage and will stop any running garbage
	// collectors and open connections.
	Close() error
}

Storage interface for communicating with different database/key-value providers

type StructValidator 

type StructValidator interface {
	Validate(out any) error
}

StructValidator is an interface to register custom struct validator for binding.

type SyntaxError 

type SyntaxError = json.SyntaxError

A SyntaxError is a description of a JSON syntax error.

type TLSHandler 

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

TLSHandler object

func (*TLSHandler) GetClientInfo 

func (t *TLSHandler) GetClientInfo(info *tls.ClientHelloInfo) (*tls.Certificate, error)

GetClientInfo Callback function to set ClientHelloInfo Must comply with the method structure of https://cs.opensource.google/go/go/+/refs/tags/go1.20:src/crypto/tls/common.go;l=554-563 Since we overlay the method of the tls config in the listener method

type TypeConstraint 

type TypeConstraint int16

TypeConstraint parameter constraint types

type UnknownKeyError 

type UnknownKeyError = schema.UnknownKeyError

UnknownKeyError error exposes the internal schema.UnknownKeyError for public use.

type UnmarshalTypeError 

type UnmarshalTypeError = json.UnmarshalTypeError

An UnmarshalTypeError describes a JSON value that was not appropriate for a value of a specific Go type.

type UnsupportedTypeError 

type UnsupportedTypeError = json.UnsupportedTypeError

An UnsupportedTypeError is returned by Marshal when attempting to encode an unsupported value type.

type UnsupportedValueError 

type UnsupportedValueError = json.UnsupportedValueError

encoding/json errors

type Views 

type Views interface {
	Load() error
	Render(out io.Writer, name string, binding any, layout ...string) error
}

Views is the interface that wraps the Render function.

Source Files

View all Source files

Directories

Path Synopsis
addon
retry
The code has been taken from https://github.com/valyala/fasthttp/pull/526 originally.
 The code has been taken from https://github.com/valyala/fasthttp/pull/526 originally.
internal
memory
Package memory Is a slight copy of the memory storage, but far from the storage interface it can not only work with bytes but directly store any kind of data without having to encode it each time, which gives a huge speed advantage
 Package memory Is a slight copy of the memory storage, but far from the storage interface it can not only work with bytes but directly store any kind of data without having to encode it each time, which gives a huge speed advantage
schema
Package gorilla/schema fills a struct with form values.
 Package gorilla/schema fills a struct with form values.
storage/memory
Package memory Is a copy of the storage memory from the external storage packet as a purpose to test the behavior in the unittests when using a storages from these packets
 Package memory Is a copy of the storage memory from the external storage packet as a purpose to test the behavior in the unittests when using a storages from these packets
tlstest
middleware
adaptor
basicauth
cache
Special thanks to @codemicro for moving this to fiber core Original middleware: github.com/codemicro/fiber-cache
 Special thanks to @codemicro for moving this to fiber core Original middleware: github.com/codemicro/fiber-cache
compress
cors
csrf
earlydata
encryptcookie
envvar
etag
expvar
favicon
healthcheck
helmet
idempotency
keyauth
Special thanks to Echo: https://github.com/labstack/echo/blob/master/middleware/key_auth.go
 Special thanks to Echo: https://github.com/labstack/echo/blob/master/middleware/key_auth.go
limiter
logger
pprof
proxy
recover
redirect
requestid
rewrite
session
skip
static
timeout

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.