Xtykutl

I'm developing a tool that can be implemented to simplify the process of creating simple CRUD operations/endpoints. Since my endpoints don't know what kind of struct they'll be receiving, I've created an interface that users can implement, and return an empty object to be filled.

type ItemFactory interface {

    GenerateEmptyItem() interface{}

}

And the users would implement something like:

type Test struct {

    TestString string `json:"testString"`

    TestInt int `json:"testInt"`

    TestBool bool `json:"testBool"`

}



func (t Test) GenerateEmptyItem() interface{} {

    return Test{}

}

When the Test object gets created, its type is "Test", even though the func returned an interface{}. However, as soon as I try to unmarshal some json of the same format into it, it strips it of its type, and becomes of type "map[string]interface {}".

item := h.ItemFactory.GenerateEmptyItem()



//Prints "Test"

fmt.Printf("%Tn", item)



fmt.Println(reflect.TypeOf(item))



err := ConvertRequestBodyIntoObject(r, &item)

if err != nil {...}



//Prints "map[string]interface {}"

fmt.Printf("%Tn", item)

Func that unmarshalls item:

func ConvertRequestBodyIntoObject(request *http.Request, object interface{}) error {

    body, err := ioutil.ReadAll(request.Body)

    if err != nil {

        return err

    }



    // Unmarshal body into request object

    err = json.Unmarshal(body, object)

    if err != nil {

        return err

    }



    return nil

}

Any suggestions as to why this happens, or how I can work around it?

Thanks

Your question lacks an example showing this behavior so I'm just guessing this is what is happening.

func Generate() interface{} {

    return Test{}

}



func GeneratePointer() interface{} {

    return &Test{}

}



func main() {



    vi := Generate()

    json.Unmarshal(byte(`{}`), &vi)

    fmt.Printf("Generate Type: %Tn", vi)



    vp := GeneratePointer()

    json.Unmarshal(byte(`{}`), vp)

    fmt.Printf("GenerateP Type: %Tn", vp)

}

Which outputs:

Generate Type: map[string]interface {}

GenerateP Type: *main.Test

I suggest you return a pointer in GenerateEmptyItem() instead of the actual struct value which is demonstrated in the GenerateP() example.

Playground Example