🎉first commit

custom_errors/errors.go

@@ -0,0 +1,114 @@
+package customerrors
+
+import (
+	"errors"
+	"fmt"
+
+	"github.com/go-playground/validator/v10"
+)
+
+var (
+	ErrInvalidJSON = errors.New("invalid JSON file")
+	ErrInvalidFile = errors.New("invalid file")
+)
+
+func As(err error, target any) bool {
+	return errors.As(err, target)
+}
+
+func Is(err, target error) bool {
+	return errors.Is(err, target)
+}
+
+type Error interface {
+	Error() string
+	Unwrap() error
+}
+
+type TypeError struct {
+	Expected string
+	Received string
+	Field    string
+	err      error
+}
+
+func NewTypeError(expected, received, field string, err error) *TypeError {
+	return &TypeError{
+		Expected: expected,
+		Received: received,
+		Field:    field,
+		err:      err,
+	}
+}
+
+func (e *TypeError) Error() string {
+	return "Expected " + e.Expected + " but received " + e.Received + " in field " + e.Field
+}
+
+func (e *TypeError) Unwrap() error {
+	return e.err
+}
+
+type InvalidFileError struct {
+	FileName string
+	err      error
+}
+
+func NewInvalidFileError(fileName string, err error) *InvalidFileError {
+	return &InvalidFileError{
+		FileName: fileName,
+		err:      err,
+	}
+}
+
+func (e *InvalidFileError) Error() string {
+	return "Invalid file: " + e.FileName
+}
+
+func (e *InvalidFileError) Unwrap() error {
+	return e.err
+}
+
+type FileNotFoundError struct {
+	FileName string
+	err      error
+}
+
+func NewFileNotFoundError(fileName string, err error) *FileNotFoundError {
+	return &FileNotFoundError{
+		FileName: fileName,
+		err:      err,
+	}
+}
+
+func (e *FileNotFoundError) Error() string {
+	return "File not found: " + e.FileName
+}
+
+func (e *FileNotFoundError) Unwrap() error {
+	return e.err
+}
+
+type ValidationErrors struct {
+	MapErrors map[string]string
+	errors    validator.ValidationErrors
+}
+
+func NewValidationErrors(errsMap map[string]string, errs validator.ValidationErrors) *ValidationErrors {
+	return &ValidationErrors{
+		MapErrors: errsMap,
+		errors:    errs,
+	}
+}
+
+func (errs *ValidationErrors) Error() string {
+	var errorsStr string
+	for k, v := range errs.MapErrors {
+		errorsStr += fmt.Sprintf("[%s]: %s\n", k, v)
+	}
+	return errorsStr
+}
+
+func (errs *ValidationErrors) Unwrap() error {
+	return errs.errors
+}

custom_errors/formaters.go

@@ -0,0 +1,76 @@
+package customerrors
+
+import (
+	"fmt"
+	"net"
+	"net/url"
+	"strings"
+
+	// "github.com/aykhans/dodo/config"
+	"github.com/aykhans/dodo/config"
+	"github.com/go-playground/validator/v10"
+)
+
+func OSErrorFormater(err error) error {
+	errStr := err.Error()
+	if strings.Contains(errStr, "no such file or directory") {
+		fileName1 := strings.Index(errStr, "open")
+		fileName2 := strings.LastIndex(errStr, ":")
+		return NewFileNotFoundError(errStr[fileName1+5:fileName2], err)
+	}
+	return ErrInvalidFile
+}
+
+func CobraErrorFormater(err error) error {
+	return err
+}
+
+func ValidationErrorsFormater(errs validator.ValidationErrors) error {
+	errsStr := make(map[string]string)
+	for _, err := range errs {
+		switch err.Tag() {
+		case "required":
+			errsStr[err.Field()] = fmt.Sprintf("Field \"%s\" is required", err.Field())
+		case "gte":
+			errsStr[err.Field()] = fmt.Sprintf("Value of \"%s\" must be greater than or equal to \"%s\"", err.Field(), err.Param())
+		case "lte":
+			errsStr[err.Field()] = fmt.Sprintf("Value of \"%s\" must be less than or equal to \"%s\"", err.Field(), err.Param())
+		case "filepath":
+			errsStr[err.Field()] = fmt.Sprintf("Invalid file path for \"%s\" field: \"%s\"", err.Field(), err.Value())
+		case "http_url":
+			errsStr[err.Field()] = fmt.Sprintf("Invalid URL for \"%s\" field: \"%s\"", err.Field(), err.Value())
+		// --------------------------------------| Custom validations |--------------------------------------
+		case "http_method":
+			errsStr[err.Field()] = fmt.Sprintf("Invalid HTTP method for \"%s\" field: \"%s\"", err.Field(), err.Value())
+		case "url_map_slice":
+			values := err.Value().(config.ProxySlice)
+			for i, value := range values {
+				if _, ok := value["url"]; !ok {
+					errsStr[fmt.Sprintf("%s[%d]", err.Field(), i)] = fmt.Sprintf("Field \"url\" is required for \"%s\" field", err.Field())
+				} else {
+					errsStr[fmt.Sprintf("%s[%d]", err.Field(), i)] = fmt.Sprintf("Invalid url for \"%s\" field: \"%s\"", err.Field(), value["url"])
+				}
+			}
+		case "string_bool":
+			errsStr[err.Field()] = fmt.Sprintf("Invalid value for \"%s\" field: \"%s\"", err.Field(), err.Value())
+		default:
+			errsStr[err.Field()] = fmt.Sprintf("Invalid value for \"%s\" field: \"%s\"", err.Field(), err.Value())
+		}
+	}
+	return NewValidationErrors(errsStr, errs)
+}
+
+func RequestErrorsFormater(err error) string {
+	switch e := err.(type) {
+	case *url.Error:
+		if netErr, ok := e.Err.(net.Error); ok && netErr.Timeout() {
+			return "Timeout Error"
+		}
+		if strings.Contains(e.Error(), "http: ContentLength=") {
+			println(e.Error())
+			return "Empty Body Error"
+		}
+		// TODO: Add more cases
+	}
+	return "Unknown Error"
+}