(feat) improving response format

.gitignore

@@ -0,0 +1 @@
+.idea

README.md

@@ -66,12 +66,13 @@ func main() {
  }
 
  // Step 2: Send a success response
- httpsuite.SendResponse(w, "Request received successfully", http.StatusOK, &req)
+ httpsuite.SendResponse[SampleRequest](w, http.StatusOK, *req, nil, nil)
 	})
 
 	log.Println("Starting server on :8080")
 	http.ListenAndServe(":8080", r)
 }
+
 ```
 
 Check out the [example folder for a complete project](./examples) demonstrating how to integrate **httpsuite** into 

examples/main.go

@@ -35,7 +35,7 @@ func main() {
  }
 
  // Step 2: Send a success response
- httpsuite.SendResponse(w, "Request received successfully", http.StatusOK, &req)
+ httpsuite.SendResponse[SampleRequest](w, http.StatusOK, *req, nil, nil)
 	})
 
 	log.Println("Starting server on :8080")

request.go

@@ -30,7 +30,8 @@ func ParseRequest[T RequestParamSetter](w http.ResponseWriter, r *http.Request,
 
 	if r.Body != http.NoBody {
  if err := json.NewDecoder(r.Body).Decode(&request); err != nil {
- SendResponse[any](w, "Invalid JSON format", http.StatusBadRequest, nil)
+ SendResponse[any](w, http.StatusBadRequest, nil,
+ []Error{{Code: http.StatusBadRequest, Message: "Invalid JSON format"}}, nil)
  return empty, err
  }
 	}
@@ -44,19 +45,22 @@ func ParseRequest[T RequestParamSetter](w http.ResponseWriter, r *http.Request,
 	for _, key := range pathParams {
  value := chi.URLParam(r, key)
  if value == "" {
- SendResponse[any](w, "Parameter "+key+" not found in request", http.StatusBadRequest, nil)
+ SendResponse[any](w, http.StatusBadRequest, nil,
+ []Error{{Code: http.StatusBadRequest, Message: "Parameter " + key + " not found in request"}}, nil)
  return empty, errors.New("missing parameter: " + key)
  }
 
  if err := request.SetParam(key, value); err != nil {
- SendResponse[any](w, "Failed to set field "+key, http.StatusInternalServerError, nil)
+ SendResponse[any](w, http.StatusInternalServerError, nil,
+ []Error{{Code: http.StatusInternalServerError, Message: "Failed to set field " + key, Details: err.Error()}}, nil)
  return empty, err
  }
 	}
 
 	// Validate the combined request struct
 	if validationErr := IsRequestValid(request); validationErr != nil {
- SendResponse[ValidationErrors](w, "Validation error", http.StatusBadRequest, validationErr)
+ SendResponse[any](w, http.StatusBadRequest, nil,
+ []Error{{Code: http.StatusBadRequest, Message: "Validation error", Details: validationErr}}, nil)
  return empty, errors.New("validation error")
 	}
 

response.go

@@ -1,53 +1,80 @@
 package httpsuite
 
 import (
+	"bytes"
 	"encoding/json"
 	"log"
 	"net/http"
 )
 
 // Response represents the structure of an HTTP response, including a status code, message, and optional body.
+// T represents the type of the `Data` field, allowing this structure to be used flexibly across different endpoints.
 type Response[T any] struct {
-Code int `json:"code"`
-Message string `json:"message"`
-Body T `json:"body,omitempty"`
+DataT `json:"data,omitempty"`
+Errors []Error `json:"errors,omitempty"`
+Meta*Meta `json:"meta,omitempty"`
 }
 
-// Marshal serializes the Response struct into a JSON byte slice.
-// It logs an error if marshalling fails.
-func (r *Response[T]) Marshal() []byte {
-	jsonResponse, err := json.Marshal(r)
-	if err != nil {
- log.Printf("failed to marshal response: %v", err)
-	}
+// Error represents an error in the aPI response, with a structured format to describe issues in a consistent manner.
+type Error struct {
+	// Code unique error code or HTTP status code for categorizing the error
+	Code int `json:"code"`
+	// Message user-friendly message describing the error.
+	Message string `json:"message"`
+	// Details additional details about the error, often used for validation errors.
+	Details interface{} `json:"details,omitempty"`
+}
 
-	return jsonResponse
+// Meta provides additional information about the response, such as pagination details.
+// This is particularly useful for endpoints returning lists of data.
+type Meta struct {
+	// Page the current page number
+	Page int `json:"page,omitempty"`
+	// PageSize the number of items per page
+	PageSize int `json:"page_size,omitempty"`
+	// TotalPages the total number of pages available.
+	TotalPages int `json:"total_pages,omitempty"`
+	// TotalItems the total number of items across all pages.
+	TotalItems int `json:"total_items,omitempty"`
 }
 
-// SendResponse creates a Response struct, serializes it to JSON, and writes it to the provided http.ResponseWriter.
-// If the body parameter is non-nil, it will be included in the response body.
-func SendResponse[T any](w http.ResponseWriter, message string, code int, body *T) {
+// SendResponse sends a JSON response to the client, using a unified structure for both success and error responses.
+// T represents the type of the `data` payload. This function automatically adapts the response structure
+// based on whether `data` or `errors` is provided, promoting a consistent API format.
+//
+// Parameters:
+// - w: The http.ResponseWriter to send the response.
+// - code: HTTP status code to indicate success or failure.
+// - data: The main payload of the response. Use `nil` for error responses.
+// - errs: A slice of Error structs to describe issues. Use `nil` for successful responses.
+// - meta: Optional metadata, such as pagination information. Use `nil` if not needed.
+func SendResponse[T any](w http.ResponseWriter, code int, data T, errs []Error, meta *Meta) {
+	w.Header().Set("Content-Type", "application/json")
+
 	response := &Response[T]{
- Code: code,
- Message: message,
-	}
-	if body != nil {
- response.Body = *body
+ Data: data,
+ Errors: errs,
+ Meta: meta,
 	}
 
-	writeResponse[T](w, response)
-}
+	// Set the status code after encoding to ensure no issues with writing the response body
+	w.WriteHeader(code)
+
+	// Attempt to encode the response as JSON
+	var buffer bytes.Buffer
+	if err := json.NewEncoder(&buffer).Encode(response); err != nil {
+ log.Printf("Error writing response: %v", err)
 
-// writeResponse serializes a Response and writes it to the http.ResponseWriter with appropriate headers.
-// If an error occurs during the write, it logs the error and sends a 500 Internal Server Error response.
-func writeResponse[T any](w http.ResponseWriter, r *Response[T]) {
-jsonResponse := r.Marshal()
+ errResponse := `{"errors":[{"code":500,"message":"Internal Server Error"}]}`
+ http.Error(w, errResponse, http.StatusInternalServerError)
+ return
+}
 
-w.Header().Set("Content-Type", "application/json")
-	w.WriteHeader(r.Code)
+// Set the status code after success encoding
+	w.WriteHeader(code)
 
-	if _, err := w.Write(jsonResponse); err != nil {
+	// Write the encoded response to the ResponseWriter
+	if _, err := w.Write(buffer.Bytes()); err != nil {
  log.Printf("Error writing response: %v", err)
- http.Error(w, "Internal Server Error", http.StatusInternalServerError)
 	}
 }

response_test.go

@@ -12,115 +12,63 @@ type TestResponse struct {
 	Key string `json:"key"`
 }
 
-func TestResponse_Marshal(t *testing.T) {
+func Test_SendResponse(t *testing.T) {
 	tests := []struct {
- name string
- response Response[any]
- expected string
+ name string
+ code int
+ data any
+ errs []Error
+ meta *Meta
+ expectedCode int
+ expectedJSON string
 	}{
  {
- name: "Basic Response",
- response: Response[any]{Code: 200, Message: "OK"},
- expected: `{"code":200,"message":"OK"}`,
+ name: "200 OK with TestResponse body",
+ code: http.StatusOK,
+ data: &TestResponse{Key: "value"},
+ errs: nil,
+ expectedCode: http.StatusOK,
+ expectedJSON: `{"data":{"key":"value"}}`,
  },
  {
- name: "Response with Body",
- response: Response[any]{Code: 201, Message: "Created", Body: map[string]string{"id": "123"}},
- expected: `{"code":201,"message":"Created","body":{"id":"123"}}`,
+ name: "404 Not Found without body",
+ code: http.StatusNotFound,
+ data: nil,
+ errs: []Error{{Code: http.StatusNotFound, Message: "Not Found"}},
+ expectedCode: http.StatusNotFound,
+ expectedJSON: `{"errors":[{"code":404,"message":"Not Found"}]}`,
  },
  {
- name: "Response with Empty Body",
- response: Response[any]{Code: 204, Message: "No Content", Body: nil},
- expected: `{"code":204,"message":"No Content"}`,
- },
-	}
-
-	for _, tt := range tests {
- t.Run(tt.name, func(t *testing.T) {
- jsonResponse := tt.response.Marshal()
- assert.JSONEq(t, tt.expected, string(jsonResponse))
- })
-	}
-}
-
-func Test_SendResponse(t *testing.T) {
-	tests := []struct {
- name string
- message string
- code int
- body any
- expectedCode int
- expectedBody string
- expectedHeader string
-	}{
- {
- name: "200 OK with TestResponse body",
- message: "Success",
- code: http.StatusOK,
- body: &TestResponse{Key: "value"},
- expectedCode: http.StatusOK,
- expectedBody: `{"code":200,"message":"Success","body":{"key":"value"}}`,
- expectedHeader: "application/json",
+ name: "200 OK with pagination metadata",
+ code: http.StatusOK,
+ data: &TestResponse{Key: "value"},
+ meta: &Meta{TotalPages: 100, Page: 1, PageSize: 10},
+ expectedCode: http.StatusOK,
+ expectedJSON: `{"data":{"key":"value"},"meta":{"total_pages":100,"page":1,"page_size":10}}`,
  },
  {
- name: "404 Not Found without body",
- message: "Not Found",
- code: http.StatusNotFound,
- body: nil,
- expectedCode: http.StatusNotFound,
- expectedBody: `{"code":404,"message":"Not Found"}`,
- expectedHeader: "application/json",
+ name: "400 Bad Request with multiple errors",
+ code: http.StatusBadRequest,
+ errs: []Error{{Code: 400, Message: "Invalid email"}, {Code: 400, Message: "Invalid password"}},
+ expectedCode: http.StatusBadRequest,
+ expectedJSON: `{"errors":[{"code":400,"message":"Invalid email"},{"code":400,"message":"Invalid password"}]}`,
  },
 	}
 
 	for _, tt := range tests {
  t.Run(tt.name, func(t *testing.T) {
-recorder := httptest.NewRecorder()
+w := httptest.NewRecorder()
 
- switch body := tt.body.(type) {
- case *TestResponse:
- SendResponse[TestResponse](recorder, tt.message, tt.code, body)
+ switch data := tt.data.(type) {
+ case TestResponse:
+ SendResponse[TestResponse](w, tt.code, data, tt.errs, tt.meta)
  default:
- SendResponse(recorder, tt.message, tt.code, &tt.body)
+ SendResponse[any](w, tt.code, tt.data, tt.errs, tt.meta)
  }
 
- assert.Equal(t, tt.expectedCode, recorder.Code)
- assert.Equal(t, tt.expectedHeader, recorder.Header().Get("Content-Type"))
- assert.JSONEq(t, tt.expectedBody, recorder.Body.String())
- })
-	}
-}
-
-func TestWriteResponse(t *testing.T) {
-	tests := []struct {
- name string
- response Response[any]
- expectedCode int
- expectedBody string
-	}{
- {
- name: "200 OK with Body",
- response: Response[any]{Code: 200, Message: "OK", Body: map[string]string{"id": "123"}},
- expectedCode: 200,
- expectedBody: `{"code":200,"message":"OK","body":{"id":"123"}}`,
- },
- {
- name: "500 Internal Server Error without Body",
- response: Response[any]{Code: 500, Message: "Internal Server Error"},
- expectedCode: 500,
- expectedBody: `{"code":500,"message":"Internal Server Error"}`,
- },
-	}
-
-	for _, tt := range tests {
- t.Run(tt.name, func(t *testing.T) {
- recorder := httptest.NewRecorder()
-
- writeResponse(recorder, &tt.response)
-
- assert.Equal(t, tt.expectedCode, recorder.Code)
- assert.Equal(t, "application/json", recorder.Header().Get("Content-Type"))
- assert.JSONEq(t, tt.expectedBody, recorder.Body.String())
+ assert.Equal(t, tt.expectedCode, w.Code)
+ assert.Equal(t, "application/json", w.Header().Get("Content-Type"))
+ assert.JSONEq(t, tt.expectedJSON, w.Body.String())
  })
 	}
 }