feat: add error wrapping support to ResolutionError (#438)

* feat: add error wrapping support to ResolutionError

Add the ability to preserve original errors in ResolutionError.
This enables providers to wrap underlying errors while maintaining
backward compatibility, allowing callers to use errors.Is() and
errors.As() for error inspection.

Signed-off-by: Roman Dmytrenko <[email protected]>

* address PR feedback

Signed-off-by: Roman Dmytrenko <[email protected]>

* address PR feedback

Signed-off-by: Roman Dmytrenko <[email protected]>

---------

Signed-off-by: Roman Dmytrenko <[email protected]>

Author: erka

openfeature/resolution_error.go

@@ -30,14 +30,22 @@ const (
 type ResolutionError struct {
 	// fields are unexported, this means providers are forced to create structs of this type using one of the constructors below.
 	// this effectively emulates an enum
-	code    ErrorCode
-	message string
+	code        ErrorCode
+	message     string
+	originalErr error
 }
 
+// Error implements the error interface for ResolutionError.
 func (r ResolutionError) Error() string {
+	// Avoid including original error message to prevent leaking internal details externally.
 	return fmt.Sprintf("%s: %s", r.code, r.message)
 }
 
+// Unwrap allows access to the original error, if any.
+func (r ResolutionError) Unwrap() error {
+	return r.originalErr
+}
+
 // NewProviderNotReadyResolutionError constructs a resolution error with code PROVIDER_NOT_READY
 //
 // Explanation - The value was resolved before the provider was ready.
@@ -61,11 +69,8 @@ func NewFlagNotFoundResolutionError(msg string) ResolutionError {
 // NewParseErrorResolutionError constructs a resolution error with code PARSE_ERROR
 //
 // Explanation - An error was encountered parsing data, such as a flag configuration.
-func NewParseErrorResolutionError(msg string) ResolutionError {
-	return ResolutionError{
-		code:    ParseErrorCode,
-		message: msg,
-	}
+func NewParseErrorResolutionError(msg string, errs ...error) ResolutionError {
+	return newResolutionError(ParseErrorCode, msg, errs...)
 }
 
 // NewTypeMismatchResolutionError constructs a resolution error with code TYPE_MISMATCH
@@ -101,10 +106,25 @@ func NewInvalidContextResolutionError(msg string) ResolutionError {
 // NewGeneralResolutionError constructs a resolution error with code GENERAL
 //
 // Explanation - The error was for a reason not enumerated above.
-func NewGeneralResolutionError(msg string) ResolutionError {
+func NewGeneralResolutionError(msg string, errs ...error) ResolutionError {
+	return newResolutionError(GeneralCode, msg, errs...)
+}
+
+// newResolutionError is a helper to create a ResolutionError with an optional original error.
+func newResolutionError(code ErrorCode, msg string, errs ...error) ResolutionError {
+	var originalErr error
+	switch len(errs) {
+	case 0:
+		originalErr = nil // being explicit
+	case 1:
+		originalErr = errs[0]
+	default:
+		originalErr = errors.Join(errs...)
+	}
 	return ResolutionError{
-		code:    GeneralCode,
-		message: msg,
+		code:        code,
+		message:     msg,
+		originalErr: originalErr,
 	}
 }
 

openfeature/resolution_error_test.go

@@ -0,0 +1,47 @@
+package openfeature
+
+import (
+	"errors"
+	"io"
+	"strings"
+	"testing"
+)
+
+func TestResolutionErrorWithOriginal(t *testing.T) {
+	tests := []struct {
+		name string
+		err  error
+	}{
+		{"general", NewGeneralResolutionError("flag not found", io.ErrNoProgress)},
+		{"parse", NewParseErrorResolutionError("flag not found", io.ErrNoProgress)},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := tt.err
+			t.Run("wraps original error", func(t *testing.T) {
+				if !errors.Is(err, io.ErrNoProgress) {
+					t.Errorf("expected error to wrap %v", io.ErrNoProgress)
+				}
+			})
+
+			t.Run("does not match unrelated error", func(t *testing.T) {
+				if errors.Is(err, io.EOF) {
+					t.Errorf("expected error to not match %v", io.EOF)
+				}
+			})
+
+			t.Run("contains expected message", func(t *testing.T) {
+				if !strings.Contains(err.Error(), "flag not found") {
+					t.Errorf("expected message to contain %q, got %q", "flag not found", err.Error())
+				}
+			})
+
+			t.Run("unwrap returns original", func(t *testing.T) {
+				if unwrapped := errors.Unwrap(err); unwrapped != io.ErrNoProgress {
+					t.Errorf("expected unwrap to return %v, got %v", io.ErrNoProgress, unwrapped)
+				}
+			})
+		})
+	}
+}