En/error fields

docs/advanced-guide/gofr-errors/page.md

@@ -64,3 +64,35 @@ func (c customError) LogLevel() logging.Level {
 	return logging.WARN
 }
 ```
+
+## Extended Error Responses
+
+For RFC 7807-style error responses with additional fields, implement the ResponseMarshaller interface:
+
+```go
+type ResponseMarshaler interface {
+    Response() map[string]any
+}
+```
+
+#### Usage:
+```go
+type ValidationError struct {
+    Field   string
+    Message string
+    Code    int
+}
+
+func (e ValidationError) Error() string    { return e.Message }
+func (e ValidationError) StatusCode() int  { return e.Code }
+
+func (e ValidationError) Response() map[string]any {
+    return map[string]any{
+        "field":   e.Field,
+        "type":    "validation_error",
+        "details": "Invalid input format",
+    }
+}
+```
+
+> NOTE: The `message` field is reserved and always populated from `Error()` method. Avoid using message as a key in the response map

pkg/gofr/http/responder.go

@@ -90,10 +90,28 @@ func handleSuccess(method string, data any) (statusCode int, err any) {
 	}
 }
 
+// ResponseMarshaller defines an interface for errors that can provide custom fields.
+// This enables errors to extend the error response with additional fields.
+type ResponseMarshaller interface {
+	Response() map[string]any
+}
+
+// createErrorResponse returns an error response that always contains a "message" field,
+// and if the error implements ResponseMarshaller, it merges custom fields into the response.
 func createErrorResponse(err error) map[string]any {
-	return map[string]any{
-		"message": err.Error(),
+	resp := map[string]any{"message": err.Error()}
+
+	if rm, ok := err.(ResponseMarshaller); ok {
+		for k, v := range rm.Response() {
+			if k == "message" {
+				continue // Skip to avoid overriding the Error() message
+			}
+
+			resp[k] = v
+		}
 	}
+
+	return resp
 }
 
 // response represents an HTTP response.

pkg/gofr/http/responder_test.go

@@ -2,6 +2,7 @@ package http
 
 import (
 	"bytes"
+	"encoding/json"
 	"net/http"
 	"net/http/httptest"
 	"os"
@@ -207,6 +208,80 @@ func TestResponder_TemplateResponse(t *testing.T) {
 	assert.Equal(t, expectedBody, responseBody)
 }
 
+func TestResponder_CustomErrorWithResponse(t *testing.T) {
+	w := httptest.NewRecorder()
+	responder := NewResponder(w, http.MethodGet)
+
+	customErr := &CustomError{
+		Code:    http.StatusNotFound,
+		Message: "resource not found",
+		Title:   "Custom Error",
+	}
+
+	responder.Respond(nil, customErr)
+
+	resp := w.Result()
+	defer resp.Body.Close()
+
+	assert.Equal(t, http.StatusNotFound, resp.StatusCode)
+
+	var body map[string]any
+	err := json.NewDecoder(resp.Body).Decode(&body)
+	require.NoError(t, err)
+
+	errorObj := body["error"].(map[string]any)
+
+	assert.Equal(t, "resource not found", errorObj["message"])
+	assert.Equal(t, int(http.StatusNotFound), int(errorObj["code"].(float64)))
+	assert.Equal(t, "Custom Error", errorObj["title"])
+}
+
+type CustomError struct {
+	Code    int
+	Message string
+	Title   string
+}
+
+func (e *CustomError) Error() string   { return e.Message }
+func (e *CustomError) StatusCode() int { return e.Code }
+func (e *CustomError) Response() map[string]any {
+	return map[string]any{"title": e.Title, "code": e.Code}
+}
+
+func TestResponder_ReservedMessageField(t *testing.T) {
+	w := httptest.NewRecorder()
+	responder := NewResponder(w, http.MethodGet)
+
+	msgErr := &MessageOverrideError{
+		Msg: "original message",
+	}
+
+	responder.Respond(nil, msgErr)
+
+	resp := w.Result()
+	defer resp.Body.Close()
+
+	var body map[string]any
+	err := json.NewDecoder(resp.Body).Decode(&body)
+	require.NoError(t, err)
+
+	errorObj := body["error"].(map[string]any)
+	assert.Equal(t, "original message", errorObj["message"])
+	assert.Equal(t, "additional info", errorObj["info"])
+}
+
+type MessageOverrideError struct {
+	Msg string
+}
+
+func (e *MessageOverrideError) Error() string { return e.Msg }
+func (*MessageOverrideError) Response() map[string]any {
+	return map[string]any{
+		"message": "trying to override",
+		"info":    "additional info",
+	}
+}
+
 func createTemplateFile(t *testing.T, path, content string) {
 	t.Helper()