Unmarshaling from JSON key containing a single quote

I feel quite puzzled by this.
I need to load some data (coming from a French database) that is serialized in JSON and in which some keys have a single quote.

Here is a simplified version:

package main

import (
	"encoding/json"
	"fmt"
)

type Product struct {
	Name string `json:"nom"`
	Cost int64  `json:"prix d'achat"`
}

func main() {
	var p Product
	err := json.Unmarshal([]byte(`{"nom":"savon", "prix d'achat": 170}`), &p)
	fmt.Printf("product cost: %d\nerror: %s\n", p.Cost, err)
}

// product cost: 0
// error: %!s(<nil>)

Unmarshaling leads to no errors however the "prix d'achat" (p.Cost) is not correctly parsed.

When I unmarshal into a map[string]any, the "prix d'achat" key is parsed as I would expect:

package main

import (
	"encoding/json"
	"fmt"
)

func main() {
	blob := map[string]any{}
	err := json.Unmarshal([]byte(`{"nom":"savon", "prix d'achat": 170}`), &blob)
	fmt.Printf("blob: %f\nerror: %s\n", blob["prix d'achat"], err)
}

// blob: 170.000000
// error: %!s(<nil>)

I checked the json.Marshal documentation on struct tags and I cannot find any issue with the data I'm trying to process.

Am I missing something obvious here?
How can I parse a JSON key containing a single quote using struct tags?

Thanks a lot for any insight!

I didn't find anything in the documentation, but the JSON encoder considers single quote to be a reserved character in tag names.

func isValidTag(s string) bool {
	if s == "" {
		return false
	}
	for _, c := range s {
		switch {
		case strings.ContainsRune("!#$%&()*+-./:;<=>?@[]^_{|}~ ", c):
			// Backslash and quote chars are reserved, but
			// otherwise any punctuation chars are allowed
			// in a tag name.
		case !unicode.IsLetter(c) && !unicode.IsDigit(c):
			return false
		}
	}
	return true
}

I think opening an issue is justified here. In the meantime, you're going to have to implement json.Unmarshaler and/or json.Marshaler. Here is a start:

func (p *Product) UnmarshalJSON(b []byte) error {
	type product Product // revent recursion
	var _p product

	if err := json.Unmarshal(b, &_p); err != nil {
		return err
	}

	*p = Product(_p)

	return unmarshalFieldsWithSingleQuotes(p, b)
}

func unmarshalFieldsWithSingleQuotes(dest interface{}, b []byte) error {
	// Look through the JSON tags. If there is one containing single quotes,
	// unmarshal b again, into a map this time. Then unmarshal the value
	// at the map key corresponding to the tag, if any.
	var m map[string]json.RawMessage

	t := reflect.TypeOf(dest).Elem()
	v := reflect.ValueOf(dest).Elem()

	for i := 0; i < t.NumField(); i++ {
		tag := t.Field(i).Tag.Get("json")
		if !strings.Contains(tag, "'") {
			continue
		}

		if m == nil {
			if err := json.Unmarshal(b, &m); err != nil {
				return err
			}
		}

		if j, ok := m[tag]; ok {
			if err := json.Unmarshal(j, v.Field(i).Addr().Interface()); err != nil {
				return err
			}
		}
	}

	return nil
}

Try it on the playground: https://go.dev/play/p/aupACXorjOO