middleware

type APIKeyAuthMiddleware ¶

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

APIKeyAuthMiddleware authenticates Bearer API-key tokens and injects the owning user into request context using the SAME keys the JWT middleware uses (UserIDKey/UsernameKey/RoleKey via newUserContext), so downstream ctxUser lookups and RBAC are auth-agnostic (architecture Important gap #1). It is mounted onto the Bearer-only /api/v1 group by Story 2.1.

func NewAPIKeyAuthMiddleware(
	verifier APIKeyVerifier,
	userLookup UserLookup,
	logger *util.Logger,
) *APIKeyAuthMiddleware

func (m *APIKeyAuthMiddleware) Handler(next http.Handler) http.Handler

type APIKeyVerifier ¶

type APIKeyVerifier interface {
	Verify(ctx context.Context, fullKey string) (*apikey.APIKey, error)
	UpdateLastUsed(ctx context.Context, id int, ip string) error
}

APIKeyVerifier is the narrow interface the middleware depends on for key verification. *apikey.Service satisfies it (Verify + UpdateLastUsed). Defined here — not in the domain — so the middleware owns its own seam and the domain stays HTTP-agnostic (mirrors the handlers.APIKeyService pattern).

type AdminMiddleware ¶

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

AdminMiddleware represents admin authorization middleware

func NewAdminMiddleware(authMiddleware *AuthMiddleware) *AdminMiddleware

func (m *AdminMiddleware) AdminOnly(next http.Handler) http.Handler

func (m *AdminMiddleware) ModerationOnly(next http.Handler) http.Handler

type AuthMiddleware ¶

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

AuthMiddleware represents authentication middleware

func NewAuthMiddleware(jwtManager *auth.JWTManager) *AuthMiddleware

func (m *AuthMiddleware) OptionalAuth(next http.Handler) http.Handler

func (m *AuthMiddleware) RequireAuth(next http.Handler) http.Handler

func (m *AuthMiddleware) RequireRole(roles ...string) func(http.Handler) http.Handler

type CORSMiddleware ¶

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

func NewCORSMiddleware(allowedOrigins []string, logger *util.Logger) *CORSMiddleware

func (m *CORSMiddleware) Handler(next http.Handler) http.Handler

type CSRFMiddleware ¶

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

func NewCSRFMiddleware(
	logger *util.Logger,
	trustedOrigins []string,
	jwtManager *auth.JWTManager,
) *CSRFMiddleware

func (m *CSRFMiddleware) Handler(next http.Handler) http.Handler

type Capability ¶ added in v1.0.0

type Capability = capability.Capability

Capability names a permission the kernel resolver decides. It aliases the kernel vocabulary (kernel/capability) so existing references keep working; new code should import kernel/capability directly.

type CommentatorMiddleware ¶

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

CommentatorMiddleware handles authorization for Commentator role

func NewCommentatorMiddleware(authMiddleware *AuthMiddleware) *CommentatorMiddleware

func (m *CommentatorMiddleware) CommentatorOnly(next http.Handler) http.Handler

type NoCookieMiddleware ¶

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

func NewNoCookieMiddleware(logger *util.Logger) *NoCookieMiddleware

func (m *NoCookieMiddleware) Handler(next http.Handler) http.Handler

type RateLimitMiddleware ¶

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

func NewRateLimitMiddleware(
	enabled bool,
	authPerMinute, apiPerMinute, publicPerMinute int,
) *RateLimitMiddleware

func (m *RateLimitMiddleware) APIKeyHandler(next http.Handler) http.Handler

func (m *RateLimitMiddleware) AuthHandler(next http.Handler) http.Handler

func (m *RateLimitMiddleware) Handler(next http.Handler) http.Handler

func (m *RateLimitMiddleware) PublicHandler(next http.Handler) http.Handler

type RoleCapabilities ¶ added in v1.0.0

type RoleCapabilities interface {
	IsAdmin(name string) bool
	CanPublish(name string) bool
	CanMedia(name string) bool
	CanComment(name string) bool
	CanManageType(name, postTypeSlug string) bool
}

RoleCapabilities is the narrow interface the resolver depends on for role lookups. *role.Service satisfies it. Defined here — not in the domain — so the middleware owns its own seam and the domain stays HTTP-agnostic (mirrors the APIKeyVerifier pattern).

type SecurityHeadersMiddleware ¶ added in v0.7.0

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

func NewSecurityHeadersMiddleware(cspHeaderName, cspHeaderValue, xFrameOptions string) *SecurityHeadersMiddleware

func (m *SecurityHeadersMiddleware) Handler(next http.Handler) http.Handler

type UserContext ¶

type UserContext struct {
	UserID   string
	Username string
	Role     string
}

UserContext represents user information stored in request context

type UserLookup ¶

type UserLookup interface {
	GetUserByID(ctx context.Context, userID int) (*userdomain.User, error)
}

UserLookup is the narrow interface for resolving the owning user. The middleware needs only GetUserByID. repository.UserRepo satisfies it.