feat(decoder-configs): add flag to force decoding nil input in decoder config

mapstructure.go

@@ -278,6 +278,11 @@ type DecoderConfig struct {
 	// field name or tag. Defaults to `strings.EqualFold`. This can be used
 	// to implement case-sensitive tag values, support snake casing, etc.
 	MatchName func(mapKey, fieldName string) bool
+
+	// ForceDecode forces the [DecoderConfig.DecodeHook] to run on the
+	// value passed into `input` in [Decoder.Decode] regardless of what
+	// the `input` contains.
+	ForceDecode bool
 }
 
 // A Decoder takes a raw interface value and turns it into structured
@@ -461,7 +466,10 @@ func (d *Decoder) decode(name string, input interface{}, outVal reflect.Value) e
 				d.config.Metadata.Keys = append(d.config.Metadata.Keys, name)
 			}
 		}
-		return nil
+
+		if !d.config.ForceDecode || d.config.DecodeHook == nil {
+			return nil
+		}
 	}
 
 	if !inputVal.IsValid() {

mapstructure_test.go

@@ -3083,6 +3083,109 @@ func TestDecoder_IgnoreUntaggedFieldsWithStruct(t *testing.T) {
 	}
 }
 
+func TestDecoder_ForceDecode(t *testing.T) {
+	t.Parallel()
+
+	type transformed struct {
+		message string
+	}
+
+	tests := []struct {
+		name           string
+		forceDecode    bool
+		input          *transformed
+		expectedResult transformed
+		decodeHook     DecodeHookFunc
+	}{
+		{
+			name:        "forceDecode=true for nil input with hook",
+			forceDecode: true,
+			input:       nil,
+			decodeHook: func(f, t reflect.Type, v interface{}) (interface{}, error) {
+				return transformed{message: "hello world!"}, nil
+			},
+			expectedResult: transformed{message: "hello world!"},
+		},
+		{
+			name:           "forceDecode=true for nil input without hook",
+			forceDecode:    true,
+			input:          nil,
+			expectedResult: transformed{message: ""},
+		},
+		{
+			name:        "forceDecode=false for nil input with hook",
+			forceDecode: false,
+			input:       nil,
+			decodeHook: func(f, t reflect.Type, v interface{}) (interface{}, error) {
+				return transformed{message: "hello world!"}, nil
+			},
+			expectedResult: transformed{message: ""},
+		},
+		{
+			name:           "forceDecode=false for nil input without hook",
+			forceDecode:    false,
+			input:          nil,
+			expectedResult: transformed{message: ""},
+		},
+		{
+			name:           "forceDecode=true for non-nil input without hook",
+			forceDecode:    true,
+			input:          &transformed{message: "this is a message"},
+			expectedResult: transformed{message: "this is a message"},
+		},
+		{
+			name:        "forceDecode=true for non-nil input with hook",
+			forceDecode: true,
+			input:       &transformed{message: "this is a message"},
+			decodeHook: func(f, t reflect.Type, v interface{}) (interface{}, error) {
+				return transformed{message: "this is another message"}, nil
+			},
+			expectedResult: transformed{message: "this is another message"},
+		},
+		{
+			name:           "forceDecode=false for non-nil input without hook",
+			forceDecode:    false,
+			input:          &transformed{message: "this is a message"},
+			expectedResult: transformed{message: "this is a message"},
+		},
+		{
+			name:        "forceDecode=false for non-nil input with hook",
+			forceDecode: true,
+			input:       &transformed{message: "this is a message"},
+			decodeHook: func(f, t reflect.Type, v interface{}) (interface{}, error) {
+				return transformed{message: "this is another message"}, nil
+			},
+			expectedResult: transformed{message: "this is another message"},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+
+			var result transformed
+			config := &DecoderConfig{
+				Result:      &result,
+				ForceDecode: test.forceDecode,
+				DecodeHook:  test.decodeHook,
+			}
+
+			decoder, err := NewDecoder(config)
+			if err != nil {
+				t.Fatalf("err: %s", err)
+			}
+
+			err = decoder.Decode(test.input)
+			if err != nil {
+				t.Fatalf("got an err: %s", err)
+			}
+
+			if result != test.expectedResult {
+				t.Errorf("result should be: %#v, got %#v", test.expectedResult, result)
+			}
+		})
+	}
+}
+
 func testSliceInput(t *testing.T, input map[string]interface{}, expected *Slice) {
 	var result Slice
 	err := Decode(input, &result)