httperrors

func AssertFieldViolations ¶

func AssertFieldViolations(t *testing.T, err error, fvs ...*FieldViolation)

func Error ¶

func Error(httpStatus int, reason, message string) error

func ErrorMiddleware ¶

func ErrorMiddleware(conf *HTTPErrorMiddlewareConfig) func(http.Handler) http.Handler

ErrorMiddleware creates an HTTP middleware that: 1. Injects i18n context into the request 2. Recovers from panics containing errors 3. Translates and writes structured JSON error responses

Currently uses panic-based error propagation to keep handler signatures as standard http.HandlerFunc. NOTE: In the future, this may be changed to support a handler signature that returns error directly (e.g., type HandlerFunc func(w http.ResponseWriter, r *http.Request) error). The panic-based approach is chosen for now to maintain compatibility with standard http.HandlerFunc.

func Errorf ¶

func Errorf(httpStatus int, reason, format string, a ...any) error

func FormatField ¶

func FormatField(field string, formatFunc func(string) string) string

FormatField formats a dotted field path by applying a formatting function to each segment while preserving array index notations (e.g., [0], [1]).

Parameters:

• field: The original field path (e.g., "user_info.addresses[0].street_name")
• formatFunc: Function to apply to each field segment (e.g., lo.CamelCase)

Returns:

• The formatted field path with proper array index preservation

Example:

FormatField("user_info.addresses[0].street_name", lo.CamelCase)
Returns: "userInfo.addresses[0].streetName"

func HandleError ¶

func HandleError(conf *HTTPErrorMiddlewareConfig, w http.ResponseWriter, r *http.Request, err error)

HandleError translates and writes a structured JSON error response for the given error. It is kept for backward compatibility and intentionally does not return write errors.

func NewErrorMiddleware ¶

func NewErrorMiddleware(ib *i18nx.I18N) func(http.Handler) http.Handler

NewErrorMiddleware is a convenience function that creates an ErrorMiddleware with default configuration.

func Reason ¶

func Reason(err error) string

func ReasonFromStatus ¶

func ReasonFromStatus(httpStatus int) string

ReasonFromStatus returns a default reason string for a given HTTP status code.

func StatusCode ¶

func StatusCode(err error) int

func TranslateError ¶

func TranslateError(err error, ib *i18nx.I18N, lang language.Tag) error

TranslateError translates error messages and field violations using the provided i18n instance and language. It always returns an error derived from a status representation of the input error (typically a *StatusError);

Translation behavior:

• The original message is preserved in the `message` field.
• The translated text is stored in the `localizedMessage` field.
• If the Localized template is set, its key and args are used for translation.
• Otherwise, the error reason is used as the i18n key fallback.
• If already translated (localized is nil), translation is skipped.

func TranslateStatusErrorOnly ¶

func TranslateStatusErrorOnly(err error, ib *i18nx.I18N, lang language.Tag) (error, bool)

TranslateStatusErrorOnly translates only StatusError types, returning the error and a boolean indicating success

func Validate ¶

func Validate(ctx context.Context, input any) error

func WrapHandlerFunc ¶

func WrapHandlerFunc(conf *HTTPErrorMiddlewareConfig, handler http.HandlerFunc) http.HandlerFunc

WrapHandlerFunc wraps a single http.HandlerFunc with httperrors panic recovery and i18n translation. This is useful when only some handlers in a mux use httperrors, and a global middleware is not appropriate.

Usage:

mux.HandleFunc("/api/users/{id}", httperrors.WrapHandlerFunc(conf, h.GetUser))
mux.HandleFunc("/legacy/other", legacyHandler) // not wrapped

func WriteError ¶

func WriteError(conf *HTTPErrorMiddlewareConfig, w http.ResponseWriter, r *http.Request, err error) error

WriteError translates and writes a structured JSON error response for the given error. This is intended for use inside individual handlers that want to explicitly handle errors without relying on panic-based middleware.

Usage:

func (h *UserHandler) GetUser(w http.ResponseWriter, r *http.Request) {
    user, err := h.userService.GetUser(r.Context(), r.PathValue("id"))
    if err != nil {
        if herr := httperrors.WriteError(h.conf, w, r, err); herr != nil {
            slog.ErrorContext(r.Context(), "Failed to write http response error", "error", err, "writeError", herr)
        }
        return
    }
    json.NewEncoder(w).Encode(user)
}

func WriteJSONError ¶

func WriteJSONError(err error, w http.ResponseWriter) error

WriteJSONError writes a structured JSON error response from an error. The HTTP status code is set from the Status object. The response body follows the ErrorResponse format with camelCase fields.