Merge pull request #76 from gone-io/feature/update

enhance error handling and add `WarpThirdComponent ` for third component injecting

Author: Degfy

error.go

@@ -131,18 +131,50 @@ func ToError(input any) Error {
 	if input == nil {
 		return nil
 	}
-	switch input := input.(type) {
+	switch err := input.(type) {
 	case Error:
-		return input
+		return err
 	case error:
-		return NewInnerErrorSkip(input.Error(), http.StatusInternalServerError, 2)
+		return newIError(err, http.StatusInternalServerError, 2)
 	case string:
-		return NewInnerErrorSkip(input, http.StatusInternalServerError, 2)
+		return NewInnerErrorSkip(err, http.StatusInternalServerError, 2)
 	default:
 		return NewInnerErrorSkip(fmt.Sprintf("%v", input), http.StatusInternalServerError, 2)
 	}
 }
 
+var _ Error = (*withMessage)(nil)
+
+type withMessage struct {
+	cause Error
+	msg   string
+}
+
+func (e *withMessage) Code() int {
+	return e.cause.Code()
+}
+
+func (e *withMessage) GetStatusCode() int {
+	return e.cause.GetStatusCode()
+}
+
+func (e *withMessage) Error() string {
+	return e.msg + ";" + e.cause.Error()
+}
+func (e *withMessage) Msg() string {
+	if e.msg == "" {
+		return e.cause.Msg()
+	}
+	return e.msg
+}
+func (e *withMessage) SetMsg(msg string) {
+	e.msg = msg
+}
+
+func (e *withMessage) Unwrap() error {
+	return e.cause
+}
+
 // ToErrorWithMsg converts any input to an Error type with an additional message prefix.
 // If input is nil, returns nil.
 // If msg is not empty, prepends it to the error message in format "msg: original_error_msg".
@@ -151,16 +183,20 @@ func ToErrorWithMsg(input any, msg string) Error {
 	if input == nil {
 		return nil
 	}
-	err := ToError(input)
-	if msg != "" {
-		err.SetMsg(fmt.Sprintf("%s: %s", msg, err.Msg()))
+	return &withMessage{
+		cause: ToError(input),
+		msg:   msg,
 	}
-	return err
+}
+
+func ToErrorf(input any, format string, params ...any) error {
+	return ToErrorWithMsg(input, fmt.Sprintf(format, params...))
 }
 
 type iError struct {
 	*defaultErr
 	trace []byte
+	cause error
 }
 
 func (e *iError) Error() string {
@@ -172,6 +208,10 @@ func (e *iError) Stack() []byte {
 	return e.trace
 }
 
+func (e *iError) Unwrap() error {
+	return e.cause
+}
+
 // NewInnerError creates a new InnerError with message and code, skipping one stack frame.
 // Parameters:
 //   - msg: error message
@@ -241,6 +281,14 @@ func NewInnerErrorSkip(msg string, code int, skip int) Error {
 	}
 }
 
+func newIError(err error, code int, skip int) Error {
+	return &iError{
+		defaultErr: &defaultErr{code: code, msg: err.Error(), statusCode: http.StatusInternalServerError},
+		trace:      PanicTrace(2, skip),
+		cause:      err,
+	}
+}
+
 // Error Code：1001~1999 used for gone framework.
 const (
 	GonerNameNotFound   = 1001

error_test.go

@@ -1,6 +1,7 @@
 package gone
 
 import (
+	"errors"
 	"fmt"
 	"net/http"
 	"strings"
@@ -200,7 +201,7 @@ func TestToErrorWithMsg(t *testing.T) {
 			name:    "with prefix",
 			input:   "test error",
 			msg:     "prefix",
-			wantMsg: "prefix: test error",
+			wantMsg: "prefix",
 		},
 		{
 			name:    "without prefix",
@@ -343,3 +344,40 @@ func TestBError_SetMsg(t *testing.T) {
 		})
 	}
 }
+
+func TestToErrorf(t *testing.T) {
+	t.Run("input nil", func(t *testing.T) {
+		err := ToErrorf(nil, "test error")
+		if err != nil {
+			t.Error("must be nil")
+		}
+	})
+
+	t.Run("input error", func(t *testing.T) {
+		var err = errors.New("test error")
+		newErr := ToErrorf(err, "my-test")
+
+		if !errors.Is(newErr, err) {
+			t.Error("must be input error")
+		}
+
+		var gErr Error
+		if !errors.As(newErr, &gErr) {
+			t.Error("must be GoneError")
+		}
+
+		if gErr.GetStatusCode() != http.StatusInternalServerError {
+			t.Error("must be 500")
+		}
+
+		if gErr.Msg() != "my-test" {
+			t.Error("must be my-test")
+		}
+
+		gErr.SetMsg("my-test2")
+		if gErr.Msg() != "my-test2" {
+			t.Error("must be my-test2")
+		}
+
+	})
+}

experimental.go renamed to func_provider.go

@@ -2,10 +2,11 @@ package gone
 
 import "reflect"
 
-// FunctionProvider is an experimental type that may change or be removed in future releases.
+// FunctionProvider is a function, which first parameter is tagConf, and second parameter is a struct that can be injected.
+// And the function must return a T type value and error.
 type FunctionProvider[P, T any] func(tagConf string, param P) (T, error)
 
-// XProvider is an experimental type that may change or be removed in future releases.
+// XProvider is a Goner Provider was created by WrapFunctionProvider.
 type XProvider[T any] struct {
 	Flag
 	injector FuncInjector `gone:"*"`
@@ -20,7 +21,7 @@ func (p *XProvider[T]) Provide(tagConf string) (T, error) {
 	return obj, nil
 }
 
-// WrapFunctionProvider is an experimental function that may change or be removed in future releases.
+// WrapFunctionProvider can wrap a FunctionProvider to a Provider.
 func WrapFunctionProvider[P, T any](fn FunctionProvider[P, T]) *XProvider[T] {
 	p := XProvider[T]{}
 
@@ -52,3 +53,11 @@ func WrapFunctionProvider[P, T any](fn FunctionProvider[P, T]) *XProvider[T] {
 	}
 	return &p
 }
+
+// WarpThirdComponent can wrap a third component to a Goner Provider which can make third component to inject Goners.
+func WarpThirdComponent[T any](t T) Goner {
+	provider := WrapFunctionProvider(func(tagConf string, param struct{}) (T, error) {
+		return t, nil
+	})
+	return provider
+}

experimental_test.go renamed to func_provider_test.go

@@ -66,3 +66,21 @@ func TestWrapFunctionProvider(t *testing.T) {
 		}
 	})
 }
+
+func TestWarpThirdComponent(t *testing.T) {
+	type ThirdComponent struct {
+		ID string
+	}
+
+	var thirdComponent = ThirdComponent{
+		ID: "third",
+	}
+
+	NewApp().
+		Load(WarpThirdComponent(thirdComponent)).
+		Run(func(thirdComponent ThirdComponent) {
+			if thirdComponent.ID != "third" {
+				t.Errorf("Expected %v, got %v", "third", thirdComponent.ID)
+			}
+		})
+}