inertiaframe

type Endpoint[M any] interface {
	// Execute processes the validated request and returns a Response.
	// Errors are automatically handled based on type (e.g., ValidationErrorer).
	Execute(context.Context, *Request[M]) (Response, error)

	// Meta returns routing metadata (HTTP method and path pattern).
	Meta() Meta
}

type Handler = httphandler.Handler

type HandlerFunc = httphandler.HandlerFunc

type Meta struct {
	// Method is the HTTP method (GET, POST, PUT, DELETE, etc.).
	Method string

	// Path is the URL pattern, following http.ServeMux syntax (e.g., "/users/{id}").
	Path string
}

type Middleware = httpmiddleware.Middleware

type MiddlewareFunc = httpmiddleware.MiddlewareFunc

type MountOpts[M any] struct {
	// Validator validates requests before execution. If nil, no validation is performed.
	Validator Validator[M]

	// FormDecoder parses form-urlencoded and multipart requests.
	// Defaults to DefaultFormDecoder if nil.
	FormDecoder *form.Decoder

	// ErrorHandler handles execution errors. Defaults to DefaultErrorHandler if nil.
	ErrorHandler httphandler.ErrorHandler

	// JSONUnmarshalOptions customizes JSON parsing (e.g., for protobuf).
	JSONUnmarshalOptions []json.Options
}

type Mux interface {
	// Handle registers a handler for a pattern (e.g., "POST /users/{id}").
	Handle(pattern string, h http.Handler)
}

type RawRequestExtractor interface {
	// Extract parses and populates fields from the raw HTTP request.
	Extract(*http.Request) error
}

type RawResponseWriter interface {
	Write(http.ResponseWriter, *http.Request) error
}

type Request[M any] struct {
	// Message is the decoded request payload (from JSON or form data).
	// If M implements RawRequestExtractor, custom extraction logic is used.
	Message M
}

type Response interface {
	// Component returns the frontend component name to render.
	// Must be non-empty unless the response implements RawResponseWriter.
	Component() string

	// Proper returns the props to send to the component.
	// Can be nil for redirect responses or when no props are needed.
	Proper() inertia.Proper
}

type ResponseOption func(*ResponseOptions)

type ResponseOptioner interface {
	Options() ResponseOptions
}

type ResponseOptions struct {
	// ClearHistory instructs the client to clear its history stack.
	ClearHistory bool

	// EncryptHistory instructs the client to encrypt the history state.
	EncryptHistory bool

	// Concurrency sets the maximum concurrent lazy prop resolutions for this response.
	Concurrency int
}

type Validator[M any] interface {
	// Validate checks the request message for errors.
	// If validation fails, return a ValidationErrorer to send errors to the client,
	// or any other error to trigger error handling.
	Validate(M) error
}

type ValidatorFunc[M any] func(M) error