Initial commit: Open sourcing all of the Maple Open Technologies code.

cloud/maplepress-backend/pkg/httperror/error.go

@@ -0,0 +1,187 @@
+package httperror
+
+import (
+	"encoding/json"
+	"net/http"
+)
+
+// ErrorResponse represents an HTTP error response (legacy format)
+type ErrorResponse struct {
+	Error   string `json:"error"`
+	Message string `json:"message"`
+	Code    int    `json:"code"`
+}
+
+// ProblemDetail represents an RFC 9457 compliant error response
+// See: https://datatracker.ietf.org/doc/html/rfc9457
+type ProblemDetail struct {
+	Type     string                 `json:"type"`               // URI reference identifying the problem type
+	Title    string                 `json:"title"`              // Short, human-readable summary
+	Status   int                    `json:"status"`             // HTTP status code
+	Detail   string                 `json:"detail,omitempty"`   // Human-readable explanation
+	Instance string                 `json:"instance,omitempty"` // URI reference identifying the specific occurrence
+	Errors   map[string][]string    `json:"errors,omitempty"`   // Validation errors (extension field)
+	Extra    map[string]interface{} `json:"-"`                  // Additional extension members
+}
+
+// WriteError writes an error response with pretty printing (legacy format)
+func WriteError(w http.ResponseWriter, code int, message string) {
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(code)
+
+	response := ErrorResponse{
+		Error:   http.StatusText(code),
+		Message: message,
+		Code:    code,
+	}
+
+	encoder := json.NewEncoder(w)
+	encoder.SetIndent("", "  ")
+	encoder.Encode(response)
+}
+
+// WriteProblemDetail writes an RFC 9457 compliant error response
+func WriteProblemDetail(w http.ResponseWriter, problem *ProblemDetail) {
+	w.Header().Set("Content-Type", "application/problem+json")
+	w.WriteHeader(problem.Status)
+
+	encoder := json.NewEncoder(w)
+	encoder.SetIndent("", "  ")
+	encoder.Encode(problem)
+}
+
+// BadRequest writes a 400 error
+func BadRequest(w http.ResponseWriter, message string) {
+	WriteError(w, http.StatusBadRequest, message)
+}
+
+// Unauthorized writes a 401 error
+func Unauthorized(w http.ResponseWriter, message string) {
+	WriteError(w, http.StatusUnauthorized, message)
+}
+
+// Forbidden writes a 403 error
+func Forbidden(w http.ResponseWriter, message string) {
+	WriteError(w, http.StatusForbidden, message)
+}
+
+// NotFound writes a 404 error
+func NotFound(w http.ResponseWriter, message string) {
+	WriteError(w, http.StatusNotFound, message)
+}
+
+// Conflict writes a 409 error
+func Conflict(w http.ResponseWriter, message string) {
+	WriteError(w, http.StatusConflict, message)
+}
+
+// TooManyRequests writes a 429 error
+func TooManyRequests(w http.ResponseWriter, message string) {
+	WriteError(w, http.StatusTooManyRequests, message)
+}
+
+// InternalServerError writes a 500 error
+func InternalServerError(w http.ResponseWriter, message string) {
+	WriteError(w, http.StatusInternalServerError, message)
+}
+
+// ValidationError writes an RFC 9457 validation error response (400)
+func ValidationError(w http.ResponseWriter, errors map[string][]string, detail string) {
+	if detail == "" {
+		detail = "One or more validation errors occurred"
+	}
+
+	problem := &ProblemDetail{
+		Type:   "about:blank", // Using about:blank as per RFC 9457 when no specific problem type URI is defined
+		Title:  "Validation Error",
+		Status: http.StatusBadRequest,
+		Detail: detail,
+		Errors: errors,
+	}
+
+	WriteProblemDetail(w, problem)
+}
+
+// ProblemBadRequest writes an RFC 9457 bad request error (400)
+func ProblemBadRequest(w http.ResponseWriter, detail string) {
+	problem := &ProblemDetail{
+		Type:   "about:blank",
+		Title:  "Bad Request",
+		Status: http.StatusBadRequest,
+		Detail: detail,
+	}
+
+	WriteProblemDetail(w, problem)
+}
+
+// ProblemUnauthorized writes an RFC 9457 unauthorized error (401)
+func ProblemUnauthorized(w http.ResponseWriter, detail string) {
+	problem := &ProblemDetail{
+		Type:   "about:blank",
+		Title:  "Unauthorized",
+		Status: http.StatusUnauthorized,
+		Detail: detail,
+	}
+
+	WriteProblemDetail(w, problem)
+}
+
+// ProblemForbidden writes an RFC 9457 forbidden error (403)
+func ProblemForbidden(w http.ResponseWriter, detail string) {
+	problem := &ProblemDetail{
+		Type:   "about:blank",
+		Title:  "Forbidden",
+		Status: http.StatusForbidden,
+		Detail: detail,
+	}
+
+	WriteProblemDetail(w, problem)
+}
+
+// ProblemNotFound writes an RFC 9457 not found error (404)
+func ProblemNotFound(w http.ResponseWriter, detail string) {
+	problem := &ProblemDetail{
+		Type:   "about:blank",
+		Title:  "Not Found",
+		Status: http.StatusNotFound,
+		Detail: detail,
+	}
+
+	WriteProblemDetail(w, problem)
+}
+
+// ProblemConflict writes an RFC 9457 conflict error (409)
+func ProblemConflict(w http.ResponseWriter, detail string) {
+	problem := &ProblemDetail{
+		Type:   "about:blank",
+		Title:  "Conflict",
+		Status: http.StatusConflict,
+		Detail: detail,
+	}
+
+	WriteProblemDetail(w, problem)
+}
+
+// ProblemTooManyRequests writes an RFC 9457 too many requests error (429)
+func ProblemTooManyRequests(w http.ResponseWriter, detail string) {
+	problem := &ProblemDetail{
+		Type:   "about:blank",
+		Title:  "Too Many Requests",
+		Status: http.StatusTooManyRequests,
+		Detail: detail,
+	}
+
+	WriteProblemDetail(w, problem)
+}
+
+// ProblemInternalServerError writes an RFC 9457 internal server error (500)
+func ProblemInternalServerError(w http.ResponseWriter, detail string) {
+	problem := &ProblemDetail{
+		Type:   "about:blank",
+		Title:  "Internal Server Error",
+		Status: http.StatusInternalServerError,
+		Detail: detail,
+	}
+
+	WriteProblemDetail(w, problem)
+}