webFramework

type BeforeCommitHook func(*RequestContext) error

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

type CookieHelpers interface {
	GetCookie(name string) string
	SetCookie(cookie *http.Cookie)
}

type ErrorContext struct {
	// Request is the v2 request context.
	Request *RequestContext

	// Error is the error to handle.
	Error error

	// Status is the resolved HTTP status code for this error.
	Status int
}

type ErrorHandler func(ErrorContext) error

type FakeParserV2 struct {
	legacy.FakeParser

	// ResponseStatus captures the last status code passed to SendResponse.
	ResponseStatus int

	// ResponseContentType captures the last content type passed to SendResponse.
	ResponseContentType string

	// ResponseBody captures the last body bytes passed to SendResponse.
	ResponseBody []byte

	// ResponseWritten reports whether SendResponse was called.
	ResponseWritten bool

	// Cookies stores request cookies by name.
	Cookies map[string]string

	// SetCookies captures cookies set via SetCookie.
	SetCookies []*http.Cookie

	// HooksRan reports whether the hook runner was invoked.
	HooksRan bool
	// contains filtered or unexported fields
}

type FlashContext interface {
	Add(key, value string)
	Get(key string) string
	Peek(key string) string
	Has(key string) bool
	Clear()
	GetAll() map[string]string
}

type RequestContext struct {
	// Context is the v2 request context (may carry cancellation, tracing).
	Context context.Context

	// LegacyContext is the framework-native context expected by
	// libContext.InitContext (e.g. *gin.Context, *fiber.Ctx, context.Context
	// with net/http request/response). Used by the legacy handler adapter.
	// It is typed as any because *fiber.Ctx does not implement
	// context.Context but is a valid input to libContext.InitContext.
	LegacyContext any

	// Parser is the v2 request parser.
	Parser RequestParser

	// Legacy is the v1 WebFramework, providing access to existing
	// query, persistence, response, logging, and tracing infrastructure.
	// Its Parser field is the same object as Parser above (type-asserted
	// to the legacy RequestParser interface).
	Legacy legacy.WebFramework

	// Session is the per-request session, loaded by session middleware.
	// May be nil if session middleware has not run. Typed as SessionContext
	// interface to avoid an import cycle with the session package while
	// providing typed access (no type assertions needed in handlers).
	// The concrete type is *session.Session, which satisfies SessionContext.
	Session SessionContext

	// Flash is the per-request flash, loaded by session middleware.
	// May be nil if session middleware has not run. Typed as FlashContext
	// interface to avoid an import cycle with the session package while
	// providing typed access. The concrete type is *session.Flash, which
	// satisfies FlashContext.
	Flash FlashContext
	// contains filtered or unexported fields
}

type RequestParser interface {
	legacy.RequestParser

	// SendResponse writes a raw response with the given status code,
	// content type, and body bytes. The adapter handles framework-specific
	// transport mechanics (gin.Context.Writer, fiber.Ctx, http.ResponseWriter).
	//
	// If a CommitState has been bound via SetCommitState and the response
	// is already committed, this method returns nil without writing.
	// On successful write, the commit state is marked committed.
	SendResponse(status int, contentType string, body []byte) error

	// GetCookie returns the value of the named request cookie.
	// Returns "" if the cookie does not exist.
	GetCookie(name string) string

	// SetCookie sets an HTTP response cookie.
	SetCookie(cookie *http.Cookie)

	// SetCommitState binds the request's CommitState to this parser so
	// that SendResponse can check and update the committed status.
	// Adapters call this during request setup, after creating the parser
	// and before running handlers.
	SetCommitState(cs *CommitState)

	// SetBeforeCommitHookRunner binds a function that runs before-commit
	// hooks before the response is written. SendResponse implementations
	// must call this function (if non-nil) before writing the response,
	// so that direct writes (not going through response.Handler.commit)
	// also execute hooks such as session cookie persistence.
	//
	// The function is idempotent: repeated calls return nil after the
	// first invocation. Hook errors are logged inside the runner and do
	// not block the write.
	SetBeforeCommitHookRunner(fn func() error)
}

type SessionContext interface {
	Get(key string) any
	GetString(key string) string
	Set(key string, value any)
	Delete(key string)
	Clear()
	IsDirty() bool
	ID() string
}

type StatusResolver func(error) int

type WebFrameworkV2 struct {
	RequestContext
}