middleware

func CompressionMiddleware ¶

func CompressionMiddleware(config *CompressionConfig) httpcontract.Middleware

func DefaultClientIp ¶ added in v1.11.0

func DefaultClientIp(request httpcontract.Request) string

func DefaultCompressionMiddleware ¶

func DefaultCompressionMiddleware() httpcontract.Middleware

func IpRateLimit ¶

func IpRateLimit(requestsPerMinute int) httpcontract.Middleware

IpRateLimit keys on the direct peer address, so behind a reverse proxy every client shares the proxy's single budget. It builds its config internally and returns only the middleware, so the resolver cannot be set afterwards: use IpRateLimitWithResolver with NewForwardedClientIpResolver where a trusted edge sits in front.

func IpRateLimitWithResolver ¶ added in v1.19.0

func IpRateLimitWithResolver(
	requestsPerMinute int,
	clientIpResolver ClientIpResolver,
) httpcontract.Middleware

IpRateLimitWithResolver is IpRateLimit with the client address read through the given resolver — pass NewForwardedClientIpResolver with the same policy handed to Kernel.SetForwardedHeadersPolicy so a per-IP budget behind a reverse proxy is charged to the client rather than to the proxy. A nil resolver keeps the direct peer.

func RateLimitMiddleware ¶

func RateLimitMiddleware(config *RateLimitConfig) httpcontract.Middleware

func RegisterRateLimitRequestListener ¶ added in v1.19.0

func RegisterRateLimitRequestListener(
	eventDispatcher eventcontract.EventDispatcher,
	config *RateLimitConfig,
)

RegisterRateLimitRequestListener meters every request on kernel.request, before authentication and access control. RateLimitMiddleware meters only what reaches the handler path: a request the security chain refuses is answered before the middleware chain is built, so a burst of wrong credentials consumes no budget there. This door charges that burst and answers it once the budget is gone. The default key is the client address, which exists before any token is resolved; a key extractor reading the authenticated identity falls back the same way the middleware does. Both doors share the configuration, so registering both meters a request once per door — use distinct budgets or one door.

func SimpleRateLimit ¶

func SimpleRateLimit(requestsPerMinute int) httpcontract.Middleware

SimpleRateLimit keys on the direct peer address, so behind a reverse proxy every client shares the proxy's single budget. It builds its config internally and returns only the middleware, so the resolver cannot be set afterwards: use SimpleRateLimitWithResolver with NewForwardedClientIpResolver where a trusted edge sits in front.

func SimpleRateLimitWithResolver ¶ added in v1.19.0

func SimpleRateLimitWithResolver(
	requestsPerMinute int,
	clientIpResolver ClientIpResolver,
) httpcontract.Middleware

SimpleRateLimitWithResolver is SimpleRateLimit with the client address read through the given resolver — pass NewForwardedClientIpResolver with the same policy handed to Kernel.SetForwardedHeadersPolicy so a per-IP budget behind a reverse proxy is charged to the client rather than to the proxy. A nil resolver keeps the direct peer.

func StaticMiddleware ¶

func StaticMiddleware(
	options *static.Options,
) httpcontract.Middleware

func UserRateLimit ¶

func UserRateLimit(
	requestsPerMinute int,
	getUserId KeyExtractor,
) httpcontract.Middleware

UserRateLimit falls back to the direct peer address for a request that carries no user id, so behind a reverse proxy every anonymous client shares the proxy's single budget. It builds its config internally and returns only the middleware, so the resolver cannot be set afterwards: use UserRateLimitWithResolver with NewForwardedClientIpResolver where a trusted edge sits in front.

func UserRateLimitWithResolver ¶ added in v1.19.0

func UserRateLimitWithResolver(
	requestsPerMinute int,
	getUserId KeyExtractor,
	clientIpResolver ClientIpResolver,
) httpcontract.Middleware

UserRateLimitWithResolver is UserRateLimit with the anonymous fallback address read through the given resolver — pass NewForwardedClientIpResolver with the same policy handed to Kernel.SetForwardedHeadersPolicy so unauthenticated traffic behind a reverse proxy is charged per client rather than to the proxy. A nil resolver keeps the direct peer.