Merge pull request #167 from go-viper/fix-nil-hook

fix: nil value in decode hooks

Author: sagikazarmark

decode_hooks.go

@@ -13,6 +13,15 @@ import (
 	"time"
 )
 
+// safeInterface safely extracts the interface value from a reflect.Value.
+// It returns nil if the value is not valid or is a nil interface.
+func safeInterface(v reflect.Value) any {
+	if !v.IsValid() {
+		return nil
+	}
+	return v.Interface()
+}
+
 // typedDecodeHook takes a raw DecodeHookFunc (an any) and turns
 // it into the proper DecodeHookFunc type, such as DecodeHookFuncType.
 func typedDecodeHook(h DecodeHookFunc) DecodeHookFunc {
@@ -44,10 +53,16 @@ func cachedDecodeHook(raw DecodeHookFunc) func(from reflect.Value, to reflect.Va
 	switch f := typedDecodeHook(raw).(type) {
 	case DecodeHookFuncType:
 		return func(from reflect.Value, to reflect.Value) (any, error) {
+			if !from.IsValid() {
+				return f(reflect.TypeOf((*any)(nil)).Elem(), to.Type(), nil)
+			}
 			return f(from.Type(), to.Type(), from.Interface())
 		}
 	case DecodeHookFuncKind:
 		return func(from reflect.Value, to reflect.Value) (any, error) {
+			if !from.IsValid() {
+				return f(reflect.Invalid, to.Kind(), nil)
+			}
 			return f(from.Kind(), to.Kind(), from.Interface())
 		}
 	case DecodeHookFuncValue:
@@ -70,8 +85,14 @@ func DecodeHookExec(
 ) (any, error) {
 	switch f := typedDecodeHook(raw).(type) {
 	case DecodeHookFuncType:
+		if !from.IsValid() {
+			return f(reflect.TypeOf((*any)(nil)).Elem(), to.Type(), nil)
+		}
 		return f(from.Type(), to.Type(), from.Interface())
 	case DecodeHookFuncKind:
+		if !from.IsValid() {
+			return f(reflect.Invalid, to.Kind(), nil)
+		}
 		return f(from.Kind(), to.Kind(), from.Interface())
 	case DecodeHookFuncValue:
 		return f(from, to)
@@ -92,7 +113,7 @@ func ComposeDecodeHookFunc(fs ...DecodeHookFunc) DecodeHookFunc {
 	}
 	return func(f reflect.Value, t reflect.Value) (any, error) {
 		var err error
-		data := f.Interface()
+		data := safeInterface(f)
 
 		newFrom := f
 		for _, c := range cached {
@@ -102,8 +123,11 @@ func ComposeDecodeHookFunc(fs ...DecodeHookFunc) DecodeHookFunc {
 			}
 			if v, ok := data.(reflect.Value); ok {
 				newFrom = v
-			} else {
+			} else if data != nil {
 				newFrom = reflect.ValueOf(data)
+			} else {
+				// Keep newFrom as invalid (zero) Value when data is nil
+				newFrom = reflect.Value{}
 			}
 		}
 

decode_hooks_test.go

@@ -333,6 +333,55 @@ func TestComposeDecodeHookFunc_ReflectValueHook(t *testing.T) {
 	}
 }
 
+// TestComposeDecodeHookFunc_NilValue tests that ComposeDecodeHookFunc
+// doesn't panic when a hook returns nil (issue #121).
+func TestComposeDecodeHookFunc_NilValue(t *testing.T) {
+	hook := func(f reflect.Kind, t reflect.Kind, data any) (any, error) {
+		return data, nil
+	}
+
+	f := ComposeDecodeHookFunc(hook, hook)
+
+	// Test with nil input - this should not panic
+	result, err := DecodeHookExec(f, reflect.Value{}, reflect.ValueOf(""))
+	if err != nil {
+		t.Fatalf("unexpected error: %s", err)
+	}
+	if result != nil {
+		t.Fatalf("expected nil result, got: %#v", result)
+	}
+}
+
+// TestComposeDecodeHookFunc_DecodeNilRemain tests the specific scenario from issue #121
+// where using ComposeDecodeHookFunc with DecodeNil and ,remain tag causes a panic.
+func TestComposeDecodeHookFunc_DecodeNilRemain(t *testing.T) {
+	v := make(map[string]any)
+	v["m"] = nil
+
+	var result struct {
+		V map[string]any `mapstructure:",remain"`
+	}
+
+	hook := func(f reflect.Kind, t reflect.Kind, data any) (any, error) {
+		return data, nil
+	}
+
+	dec, err := NewDecoder(&DecoderConfig{
+		DecodeHook: ComposeDecodeHookFunc(hook, hook),
+		DecodeNil:  true,
+		Result:     &result,
+	})
+	if err != nil {
+		t.Fatalf("unexpected error creating decoder: %s", err)
+	}
+
+	// This should not panic
+	err = dec.Decode(&v)
+	if err != nil {
+		t.Fatalf("unexpected error decoding: %s", err)
+	}
+}
+
 func TestStringToSliceHookFunc(t *testing.T) {
 	// Test comma separator
 	commaSuite := decodeHookTestSuite[string, []string]{