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 9457](https://www.rfc-editor.org/rfc/rfc9457.html) 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

@@ -2,12 +2,18 @@ package http
 
 import (
 	"encoding/json"
+	"errors"
 	"net/http"
 	"reflect"
 
 	resTypes "gofr.dev/pkg/gofr/http/response"
 )
 
+var (
+	errEmptyResponse     = errors.New("internal server error")
+	errMissingStatusCode = errors.New("internal server error: missing status code")
+)
+
 // NewResponder creates a new Responder instance from the given http.ResponseWriter..
 func NewResponder(w http.ResponseWriter, method string) *Responder {
 	return &Responder{w: w, method: method}
@@ -22,7 +28,7 @@ type Responder struct {
 // Respond sends a response with the given data and handles potential errors, setting appropriate
 // status codes and formatting responses as JSON or raw data as needed.
 func (r Responder) Respond(data any, err error) {
-	statusCode, errorObj := getStatusCode(r.method, data, err)
+	statusCode, errorObj := r.determineResponse(data, err)
 
 	var resp any
 	switch v := data.(type) {
@@ -58,6 +64,54 @@ func (r Responder) Respond(data any, err error) {
 	_ = json.NewEncoder(r.w).Encode(resp)
 }
 
+func (r Responder) determineResponse(data any, err error) (statusCode int, errObj any) {
+	// Handle empty struct case first
+	if err != nil && isEmptyStruct(data) {
+		return http.StatusInternalServerError, createErrorResponse(errEmptyResponse)
+	}
+
+	statusCode, errorObj := getStatusCode(r.method, data, err)
+
+	// Ensure valid status code
+	if statusCode == 0 {
+		statusCode = http.StatusInternalServerError
+
+		if errorObj == nil {
+			errorObj = createErrorResponse(errMissingStatusCode)
+		}
+	}
+
+	return statusCode, errorObj
+}
+
+// isEmptyStruct checks if a value is a struct with all zero/empty fields.
+func isEmptyStruct(data any) bool {
+	if data == nil {
+		return false
+	}
+
+	v := reflect.ValueOf(data)
+
+	// Handle pointers by dereferencing them
+	if v.Kind() == reflect.Ptr {
+		if v.IsNil() {
+			return false // nil pointer isn't an empty struct
+		}
+
+		v = v.Elem()
+	}
+
+	// Only check actual struct types
+	if v.Kind() != reflect.Struct {
+		return false
+	}
+
+	// Compare against a zero value of the same type
+	zero := reflect.Zero(v.Type()).Interface()
+
+	return reflect.DeepEqual(data, zero)
+}
+
 // getStatusCode returns corresponding HTTP status codes.
 func getStatusCode(method string, data any, err error) (statusCode int, errResp any) {
 	if err == nil {
@@ -90,10 +144,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,129 @@ 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, ok := body["error"].(map[string]any)
+	if !ok {
+		t.Fatalf("Expected error object to be of type map[string]any, got %T", body["error"])
+	}
+
+	assert.Equal(t, "resource not found", errorObj["message"])
+	assert.EqualValues(t, 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, ok := body["error"].(map[string]any)
+	if !ok {
+		t.Fatalf("Expected error object to be of type map[string]any, got %T", body["error"])
+	}
+
+	assert.Equal(t, "original message", errorObj["message"])
+	assert.Equal(t, "additional info", errorObj["info"])
+}
+
+// EmptyError represents an error as an empty struct.
+// It implements the error interface.
+type emptyError struct{}
+
+// Error implements the error interface.
+func (emptyError) Error() string {
+	return "error occurred"
+}
+
+func TestResponder_EmptyErrorStruct(t *testing.T) {
+	recorder := httptest.NewRecorder()
+	responder := Responder{w: recorder, method: http.MethodGet}
+
+	statusCode, errObj := responder.determineResponse(nil, emptyError{})
+
+	assert.Equal(t, http.StatusInternalServerError, statusCode,
+		"TestResponder_EmptyErrorStruct Failed!")
+	assert.Equal(t, map[string]any{"message": "error occurred"}, errObj,
+		"TestResponder_EmptyErrorStruct Failed!")
+}
+
+func TestIsEmptyStruct(t *testing.T) {
+	tests := []struct {
+		desc     string
+		data     any
+		expected bool
+	}{
+		{"nil value", nil, false},
+		{"empty struct", struct{}{}, true},
+		{"non-empty struct", struct{ ID int }{ID: 1}, false},
+		{"nil pointer to struct", (*struct{})(nil), false},
+		{"pointer to non-empty struct", &struct{ ID int }{ID: 1}, false},
+		{"non-struct type", 42, false},
+	}
+
+	for i, tc := range tests {
+		result := isEmptyStruct(tc.data)
+
+		assert.Equal(t, tc.expected, result, "TEST[%d] Failed: %s", i, tc.desc)
+	}
+}
+
+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()