refactor: added RequestError interface and its implementations

ralvarezdev · ralvarezdev · commit 3ffe037a8291 · 2025-01-13T16:14:21.000-04:00
* Added RequestError interface and its implementations (FieldError, HeaderError and ParameterError)
* Re-structured folders
diff --git a/http/client_ip.go b/http/client_ip.go
@@ -1,14 +1,15 @@
 package http
 
 import (
+	"github.com/ralvarezdev/go-net/http/status"
 	"net/http"
 	"strings"
 )
 
 // GetClientIP returns the client's IP address from the request
 func GetClientIP(r *http.Request) string {
 	// Check if the request has a forwarded IP from a proxy or load balancer
-	forwarded := r.Header.Get(XForwardedFor)
+	forwarded := r.Header.Get(status.XForwardedFor)
 	if forwarded != "" {
 		// X-Forwarded-For can contain multiple IP addresses, the client's IP is the first one
 		ip := strings.Split(forwarded, ",")[0]
diff --git a/http/errors.go b/http/errors.go
@@ -2,11 +2,15 @@ package http
 
 import (
 	"errors"
+	gojwtnethttp "github.com/ralvarezdev/go-jwt/net/http"
+	gonethttpresponse "github.com/ralvarezdev/go-net/http/response"
 )
 
 var (
-	ErrInvalidRequestBody         = "invalid request body: %v"
 	ErrNilRequestBody             = errors.New("request body cannot be nil")
 	ErrInDevelopment              = errors.New("in development")
-	ErrInvalidAuthorizationHeader = errors.New("invalid authorization header")
+	ErrInvalidAuthorizationHeader = gonethttpresponse.NewHeaderError(
+		gojwtnethttp.AuthorizationHeaderKey,
+		"invalid authorization header",
+	)
 )
diff --git a/http/handler/handler.go b/http/handler/handler.go
@@ -2,9 +2,9 @@ package handler
 
 import (
 	goflagsmode "github.com/ralvarezdev/go-flags/mode"
-	gonethttperrors "github.com/ralvarezdev/go-net/http/errors"
 	gonethttpjson "github.com/ralvarezdev/go-net/http/json"
 	gonethttpresponse "github.com/ralvarezdev/go-net/http/response"
+	gonethttperrors "github.com/ralvarezdev/go-net/http/status/errors"
 	"net/http"
 )
 
diff --git a/http/json/body.go b/http/json/body.go
@@ -32,12 +32,14 @@ func bodyDecodeErrorHandler(
 			return encoder.Encode(
 				w,
 				gonethttpresponse.NewDebugFailResponse(
-					gonethttpresponse.NewFieldErrorsBodyData(
-						fieldName,
-						fmt.Errorf(
-							ErrFieldInvalidValue,
-							fieldTypeName,
-							fieldValue,
+					gonethttpresponse.NewRequestErrorsBodyData(
+						gonethttpresponse.NewFieldError(
+							fieldName,
+							fmt.Sprintf(
+								ErrFieldInvalidValue,
+								fieldTypeName,
+								fieldValue,
+							),
 						),
 					),
 					err,
diff --git a/http/json/decoder.go b/http/json/decoder.go
@@ -3,8 +3,8 @@ package json
 import (
 	"encoding/json"
 	goflagsmode "github.com/ralvarezdev/go-flags/mode"
-	gonethttperrors "github.com/ralvarezdev/go-net/http/errors"
 	gonethttpresponse "github.com/ralvarezdev/go-net/http/response"
+	gonethttpstatuserrors "github.com/ralvarezdev/go-net/http/status/errors"
 	"io"
 	"net/http"
 )
@@ -52,7 +52,7 @@ func (d *DefaultDecoder) Decode(
 	if dest == nil {
 		_ = d.encoder.Encode(
 			w, gonethttpresponse.NewDebugErrorResponse(
-				gonethttperrors.InternalServerError,
+				gonethttpstatuserrors.InternalServerError,
 				err,
 				nil,
 				nil,
diff --git a/http/json/encoder.go b/http/json/encoder.go
@@ -3,8 +3,8 @@ package json
 import (
 	"encoding/json"
 	"github.com/ralvarezdev/go-flags/mode"
-	gonethttperrors "github.com/ralvarezdev/go-net/http/errors"
 	gonethttpresponse "github.com/ralvarezdev/go-net/http/response"
+	gonethttpstatuserrors "github.com/ralvarezdev/go-net/http/status/errors"
 	"net/http"
 )
 
@@ -43,7 +43,7 @@ func (d *DefaultEncoder) Encode(
 		return d.Encode(
 			w,
 			gonethttpresponse.NewDebugErrorResponse(
-				gonethttperrors.InternalServerError,
+				gonethttpstatuserrors.InternalServerError,
 				err,
 				nil,
 				nil,
diff --git a/http/json/errors.go b/http/json/errors.go
@@ -5,7 +5,6 @@ import (
 )
 
 var (
-	ErrNilData                 = errors.New("json data is nil")
 	ErrNilEncoder              = errors.New("json encoder is nil")
 	ErrNilDecoder              = errors.New("json decoder is nil")
 	ErrUnmarshalBodyDataFailed = errors.New("failed to unmarshal json body data")
diff --git a/http/json/stream_decoder.go b/http/json/stream_decoder.go
@@ -3,8 +3,8 @@ package json
 import (
 	"encoding/json"
 	goflagsmode "github.com/ralvarezdev/go-flags/mode"
-	gonethttperrors "github.com/ralvarezdev/go-net/http/errors"
 	gonethttpresponse "github.com/ralvarezdev/go-net/http/response"
+	gonethttpstatuserrors "github.com/ralvarezdev/go-net/http/status/errors"
 	"net/http"
 )
 
@@ -42,7 +42,7 @@ func (d *DefaultStreamDecoder) Decode(
 	if dest == nil {
 		_ = d.encoder.Encode(
 			w, gonethttpresponse.NewDebugErrorResponse(
-				gonethttperrors.InternalServerError,
+				gonethttpstatuserrors.InternalServerError,
 				err,
 				nil,
 				nil,
diff --git a/http/json/stream_encoder.go b/http/json/stream_encoder.go
@@ -3,8 +3,8 @@ package json
 import (
 	"encoding/json"
 	goflagsmode "github.com/ralvarezdev/go-flags/mode"
-	gonethttperrors "github.com/ralvarezdev/go-net/http/errors"
 	gonethttpresponse "github.com/ralvarezdev/go-net/http/response"
+	gonethttpstatuserrors "github.com/ralvarezdev/go-net/http/status/errors"
 	"net/http"
 )
 
@@ -36,7 +36,7 @@ func (d *DefaultStreamEncoder) Encode(
 		_ = d.Encode(
 			w,
 			gonethttpresponse.NewDebugErrorResponse(
-				gonethttperrors.InternalServerError,
+				gonethttpstatuserrors.InternalServerError,
 				err,
 				nil,
 				nil,
diff --git a/http/jwt/validator/handler.go b/http/jwt/validator/handler.go
@@ -1,13 +1,17 @@
 package validator
 
 import (
+	gojwtnethttp "github.com/ralvarezdev/go-jwt/net/http"
 	gonethttpjson "github.com/ralvarezdev/go-net/http/json"
 	gonethttpresponse "github.com/ralvarezdev/go-net/http/response"
 	"net/http"
 )
 
 // FailHandler handles the possible JWT validation errors
-type FailHandler func(w http.ResponseWriter, err ...error)
+type FailHandler func(
+	w http.ResponseWriter,
+	error error,
+)
 
 // NewDefaultFailHandler function
 func NewDefaultFailHandler(
@@ -18,13 +22,18 @@ func NewDefaultFailHandler(
 		return nil, gonethttpjson.ErrNilEncoder
 	}
 
-	return func(w http.ResponseWriter, err ...error) {
+	return func(
+		w http.ResponseWriter,
+		error error,
+	) {
 		// Encode the response
 		_ = jsonEncoder.Encode(
 			w, gonethttpresponse.NewFailResponse(
-				gonethttpresponse.NewFieldErrorsBodyData(
-					"authorization",
-					err...,
+				gonethttpresponse.NewRequestErrorsBodyData(
+					gonethttpresponse.NewHeaderError(
+						gojwtnethttp.AuthorizationHeaderKey,
+						error.Error(),
+					),
 				),
 				nil,
 				http.StatusUnauthorized,
diff --git a/http/response/common.go b/http/response/common.go
diff --git a/http/response/constants.go b/http/response/constants.go
diff --git a/http/response/errors.go b/http/response/errors.go
@@ -5,6 +5,5 @@ import (
 )
 
 var (
-	ErrNilResponse           = errors.New("response cannot be nil")
-	ErrNilResponseHTTPStatus = errors.New("response http status cannot be nil")
+	ErrNilResponse = errors.New("response cannot be nil")
 )
diff --git a/http/response/types.go b/http/response/types.go
@@ -20,11 +20,29 @@ type (
 		Code    *int        `json:"code,omitempty"`
 	}
 
+	// RequestError struct
+	RequestError interface {
+		Key() string
+		Error() string
+	}
+
 	// FieldError struct
 	FieldError struct {
 		Field string
 		Err   string
 	}
+
+	// HeaderError struct
+	HeaderError struct {
+		Header string
+		Err    string
+	}
+
+	// ParameterError struct
+	ParameterError struct {
+		Parameter string
+		Err       string
+	}
 )
 
 // NewJSendSuccessBody creates a new success response body
@@ -169,37 +187,85 @@ func NewFieldError(
 	}
 }
 
+// Key returns the field name
+func (f *FieldError) Key() string {
+	return f.Field
+}
+
 // Error returns the field error as a string
 func (f *FieldError) Error() string {
 	return f.Err
 }
 
-// NewFieldErrorsBodyData creates a new field errors body data
-func NewFieldErrorsBodyData(
-	fieldErrors ...FieldError,
+// NewHeaderError creates a new header error
+func NewHeaderError(
+	header, err string,
+) *HeaderError {
+	return &HeaderError{
+		Header: header,
+		Err:    err,
+	}
+}
+
+// Key returns the header name
+func (h *HeaderError) Key() string {
+	return h.Header
+}
+
+// Error returns the header error as a string
+func (h *HeaderError) Error() string {
+	return h.Err
+}
+
+// NewParameterError creates a new parameter error
+func NewParameterError(
+	parameter, err string,
+) *ParameterError {
+	return &ParameterError{
+		Parameter: parameter,
+		Err:       err,
+	}
+}
+
+// Key returns the parameter name
+func (p *ParameterError) Key() string {
+	return p.Parameter
+}
+
+// Error returns the parameter error as a string
+func (p *ParameterError) Error() string {
+	return p.Err
+
+}
+
+// NewRequestErrorsBodyData creates a new request errors body data
+func NewRequestErrorsBodyData(
+	requestErrors ...RequestError,
 ) *map[string]*[]string {
-	// Check if there are field errors
-	if len(fieldErrors) == 0 {
+	// Check if there are request errors
+	if len(requestErrors) == 0 {
 		return nil
 	}
 
-	// Initialize the field errors map
-	fieldErrorsMap := make(map[string]*[]string)
+	// Initialize the request errors map
+	requestErrorsMap := make(map[string]*[]string)
+
+	// Iterate over the request errors
+	for _, requestError := range requestErrors {
+		// Check if the request name exists in the map
+		requestKeyErrors, ok := requestErrorsMap[requestError.Key()]
 
-	// Iterate over the field errors
-	for _, fieldError := range fieldErrors {
-		// Check if the field name exists in the map
-		if _, ok := fieldErrorsMap[fieldError.Field]; !ok {
-			// Initialize the field errors slice
-			fieldErrorsMap[fieldError.Field] = &[]string{fieldError.Err}
+		if !ok {
+			// Initialize the request errors slice
+			requestErrorsMap[requestError.Key()] = &[]string{requestError.Error()}
 		} else {
-			// Append the error to the field errors slice
-			*fieldErrorsMap[fieldError.Field] = append(
-				*fieldErrorsMap[fieldError.Field],
-				fieldError.Err,
+			// Append the error to the request errors slice
+			*requestKeyErrors = append(
+				*requestKeyErrors,
+				requestError.Key(),
 			)
 		}
 	}
 
-	return &fieldErrorsMap
+	return &requestErrorsMap
 }
diff --git a/http/status/constants.go b/http/status/constants.go
@@ -1,4 +1,4 @@
-package http
+package status
 
 import (
 	"net/http"
diff --git a/http/status/errors/errors.go b/http/status/errors/errors.go
@@ -1,8 +1,8 @@
-package http
+package errors
 
 import (
 	"errors"
-	gonethttp "github.com/ralvarezdev/go-net/http"
+	gonethttp "github.com/ralvarezdev/go-net/http/status"
 )
 
 var (
diff --git a/http/status/response/errors.go b/http/status/response/errors.go
@@ -0,0 +1,16 @@
+package response
+
+import (
+	"github.com/ralvarezdev/go-net/http/response"
+	gonethttperrors "github.com/ralvarezdev/go-net/http/status/errors"
+	"net/http"
+)
+
+var (
+	InternalServerError = response.NewErrorResponse(
+		gonethttperrors.InternalServerError,
+		nil,
+		nil,
+		http.StatusInternalServerError,
+	)
+)
diff --git a/http/status/response/send.go b/http/status/response/send.go

Original file line number	Diff line number	Diff line change
`@@ -2,9 +2,9 @@ package handler`
`2`	`2`
`3`	`3`	`import (`
`4`	`4`	`goflagsmode "github.com/ralvarezdev/go-flags/mode"`
`5`		`- gonethttperrors "github.com/ralvarezdev/go-net/http/errors"`
`6`	`5`	`gonethttpjson "github.com/ralvarezdev/go-net/http/json"`
`7`	`6`	`gonethttpresponse "github.com/ralvarezdev/go-net/http/response"`
	`7`	`+ gonethttperrors "github.com/ralvarezdev/go-net/http/status/errors"`
`8`	`8`	`"net/http"`
`9`	`9`	`)`
`10`	`10`
Original file line number	Diff line number	Diff line change
`@@ -5,7 +5,6 @@ import (`
`5`	`5`	`)`
`6`	`6`
`7`	`7`	`var (`
`8`		`- ErrNilData = errors.New("json data is nil")`
`9`	`8`	`ErrNilEncoder = errors.New("json encoder is nil")`
`10`	`9`	`ErrNilDecoder = errors.New("json decoder is nil")`
`11`	`10`	`ErrUnmarshalBodyDataFailed = errors.New("failed to unmarshal json body data")`