package apperr import ( "errors" "net/http" ) // Code is the machine-readable error code used by the API contract. type Code string const ( CodeInvalidRequest Code = "invalid_request" CodeUnauthorized Code = "unauthorized" CodeNotFound Code = "not_found" CodeConflict Code = "conflict" CodePayloadTooLarge Code = "payload_too_large" CodeUnsupportedMediaType Code = "unsupported_media_type" CodeRateLimited Code = "rate_limited" CodeUnavailable Code = "unavailable" CodeInternalError Code = "internal_error" CodeValidation Code = CodeInvalidRequest CodeBadRequest Code = CodeInvalidRequest CodeInternal Code = CodeInternalError ) func (c Code) HTTPStatus() int { switch c { case CodeInvalidRequest: return http.StatusBadRequest case CodeUnauthorized: return http.StatusUnauthorized case CodeNotFound: return http.StatusNotFound case CodeConflict: return http.StatusConflict case CodePayloadTooLarge: return http.StatusRequestEntityTooLarge case CodeUnsupportedMediaType: return http.StatusUnsupportedMediaType case CodeRateLimited: return http.StatusTooManyRequests case CodeUnavailable: return http.StatusServiceUnavailable default: return http.StatusInternalServerError } } // AppError adds a public message and API code to an optional underlying error. type AppError struct { code Code message string cause error } func New(code Code, message string) *AppError { return &AppError{code: code, message: message} } // Wrap returns nil for a nil cause. func Wrap(err error, code Code, message string) error { if err == nil { return nil } return &AppError{code: code, message: message, cause: err} } func (e *AppError) Error() string { if e == nil { return "" } if e.cause != nil { return e.message + ": " + e.cause.Error() } return e.message } func (e *AppError) Unwrap() error { if e == nil { return nil } return e.cause } func (e *AppError) Code() Code { if e == nil { return CodeInternalError } return e.code } func (e *AppError) Message() string { if e == nil { return "" } return e.message } // As finds an AppError even when it is wrapped with fmt.Errorf("...: %w", err). func As(err error) (*AppError, bool) { var appErr *AppError if !errors.As(err, &appErr) || appErr == nil { return nil, false } return appErr, true } // Root is retained for existing HTTP handler call sites. func Root(err error) *AppError { appErr, _ := As(err) return appErr } // PublicMessage never exposes an unknown error or the cause of a server error. func PublicMessage(err error) string { appErr, ok := As(err) if !ok || appErr.Code().HTTPStatus() >= http.StatusInternalServerError { return "internal server error" } return appErr.Message() }