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

mapstructure.go

@@ -278,6 +278,10 @@ 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
+
+	// DecodeNil, if set to true, will try to perform decoding on the input even
+	// if the input is nil.
+	DecodeNil bool
 }
 
 // A Decoder takes a raw interface value and turns it into structured
@@ -461,7 +465,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.DecodeNil || d.config.DecodeHook == nil {
+			return nil
+		}
 	}
 
 	if !inputVal.IsValid() {

mapstructure_test.go

@@ -3083,6 +3083,111 @@ func TestDecoder_IgnoreUntaggedFieldsWithStruct(t *testing.T) {
 	}
 }
 
+func TestDecoder_DecodeNil(t *testing.T) {
+	t.Parallel()
+
+	type Transformed struct {
+		Message string
+	}
+
+	var nilInput *Transformed
+
+	tests := []struct {
+		name           string
+		decodeNil      bool
+		input          interface{}
+		expectedResult Transformed
+		decodeHook     DecodeHookFunc
+	}{
+		{
+			name:      "decodeNil=true for nil input with hook",
+			decodeNil: true,
+			input:     nilInput,
+			decodeHook: func(f, t reflect.Type, v interface{}) (interface{}, error) {
+				return Transformed{Message: "hello world!"}, nil
+			},
+			expectedResult: Transformed{Message: "hello world!"},
+		},
+		{
+			name:           "decodeNil=true for nil input without hook",
+			decodeNil:      true,
+			input:          nilInput,
+			expectedResult: Transformed{Message: ""},
+		},
+		{
+			name:      "decodeNil=false for nil input with hook",
+			decodeNil: false,
+			input:     nilInput,
+			decodeHook: func(f, t reflect.Type, v interface{}) (interface{}, error) {
+				return Transformed{Message: "hello world!"}, nil
+			},
+			expectedResult: Transformed{Message: ""},
+		},
+		{
+			name:           "decodeNil=false for nil input without hook",
+			decodeNil:      false,
+			input:          nilInput,
+			expectedResult: Transformed{Message: ""},
+		},
+		{
+			name:           "decodeNil=true for non-nil input without hook",
+			decodeNil:      true,
+			input:          map[string]interface{}{"message": "this is a message"},
+			expectedResult: Transformed{Message: "this is a message"},
+		},
+		{
+			name:      "decodeNil=true for non-nil input with hook",
+			decodeNil: true,
+			input:     map[string]interface{}{"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:           "decodeNil=false for non-nil input without hook",
+			decodeNil:      false,
+			input:          map[string]interface{}{"message": "this is a message"},
+			expectedResult: Transformed{Message: "this is a message"},
+		},
+		{
+			name:      "decodeNil=false for non-nil input with hook",
+			decodeNil: false,
+			input:     map[string]interface{}{"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,
+				DecodeNil:  test.decodeNil,
+				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)