Decoding bytearray inputs

[vkrizan]

Hello.

A Decode getting a bytearray ([]byte) input from a stringified number does an assumed pre-conversion before writing it into the output. The output type isn't respected. This is troublesome when decoding base64 inputs (e.g. k8s Secrets data).

Input:

[]byte(strconv.Itoa(1234))

Output types:

string
int

Minimal test:

package main

import (
	"fmt"
	"strconv"

	"github.com/go-viper/mapstructure/v2"
)

func main() {
	var o1 string
	var o2 int

	in := []byte(strconv.Itoa(1234))
	fmt.Printf("Input: %#v\n", in)

	for _, out := range []interface{}{&o1, &o2} {
		fmt.Printf("\nOutput type: %T\n", out)
		err := mapstructure.Decode(in, out)
		if err != nil {
			fmt.Printf("Error: %+v\n", err)
		} else {
			fmt.Printf("Output: %#v\n", out)
		}
	}
}

Output:

Input: []byte{0x31, 0x32, 0x33, 0x34}

Output type: *string
Error: '' expected type 'string', got unconvertible type '[]uint8', value: '[49 50 51 52]'

Output type: *int
Error: '' expected type 'int', got unconvertible type '[]uint8', value: '[49 50 51 52]'

Is this a bug, or have I not understood the mapstructure decoding correctly?

Workaround: use mapstructure.WeakDecode() instead.

Thank you!

[vkrizan]

I got off guard by the []uint8 and haven't realized that it is technically a byte array.

Anyhow, here is an example with a struct:

func main() {
	var out struct{ Num string }

	in := make(map[string][]byte)
	in["num"] = []byte(strconv.Itoa(1234))

	fmt.Printf("Input: %#v\n", in)

	fmt.Printf("\nOutput type: %T\n", out)
	err := mapstructure.Decode(in, &out)
	if err != nil {
		fmt.Printf("Error: %+v\n", err)

		err := mapstructure.WeakDecode(in, &out)
		if err != nil {
			fmt.Printf("Error (weakdecode): %+v\n", err)
		} else {
			fmt.Printf("Output (weakdecode): %#v\n", out)
		}

	} else {
		fmt.Printf("Output: %#v\n", out)
	}
}

Output:

Input: map[string][]uint8{"num":[]uint8{0x31, 0x32, 0x33, 0x34}}

Output type: struct { Num string }
Error: decoding failed due to the following error(s):

'Num' expected type 'string', got unconvertible type '[]uint8', value: '[49 50 51 52]'
Output (weakdecode): struct { Num string }{Num:"1234"}

I wonder whether bytearrays could be decode to strings without a weak decode. Or have a tag that would allow for a string fields to be converted from bytearrays (i.e. to support base64 decoded inputs).