how to rename JSON object keys

[nsitbon]

Hi after looking at the documentation I can't find a way to rename JSON object keys. Can you show me how to do that please.

Best regards

[ohler55]

In go there is no way to rename a map key. You can, however, add and delete keys so deleting a key with Del and then SetOne will have the same effect. Be aware that if calling either during an iteration of the map may rearrange the map leaving some keys untouched.

[nsitbon]

Thank you for your answer : I'm not talking about Go here but about the possibilities offered by your library. I'm receiving a deep JSON object inside one of my endpoint and I want to rename some specific keys. It's very easy to change object values using your library but I'm struggling to change object keys.
Best regards

[ohler55]

Would code for the solution described be useful?

[nsitbon]

Hi @ohler55 I was able to write a working version using your hints but I'm far from what I thought I could do. This is the first time I'm dealing with JSONPATH and your library and even JSONPATH is very limited. The first 2 features I was looking for were

• be able to rename a JSON object key
• be able to apply a transformation on any JSON object matching arbitrary key inside a JSON object

it turns out that both aren't handled natively (for the second see https://stackoverflow.com/a/78445097/24913827).
I still would like to thank you for your precious time and help. I'm still hesitating between trying to make things work with JSONPATH and your library OR trying to make a new library with a new query syntax...

Here is the code for those who would be interested

func renameKey(jsValue any, oldKey, newKey string) error {
	x, err := jp.ParseString("$.." + oldKey)

	if err != nil {
		return err
	}

	exprs := x.Locate(jsValue, 0)

	matchingObjects, err := slice.MapWithErr(exprs, func(expr jp.Expr) (map[string]any, error) {
		if y, err := jp.ParseString(strings.TrimSuffix(expr.String(), "."+oldKey)); err != nil {
			return nil, err
		} else {
			return y.Get(jsValue)[0].(map[string]any), nil
		}
	})

	if err != nil {
		return err
	}

	slice.Foreach(matchingObjects, func(m map[string]any) {
		old := m[oldKey]
		delete(m, oldKey)
		m[newKey] = old
	})

	return nil
}

func TestRenameKey(t *testing.T) {
	data, err := oj.ParseString(`{"a":{"a": 1, "b": {"a": 2}}, "b": 4}`)
	require.NoError(t, err)

	err = renameKey(data, "a", "c")
	require.NoError(t, err)

	r, _ := json.Marshal(data)
	require.JSONEq(t, `{"c":{"c": 1, "b": {"c": 2}}, "b": 4}`, string(r))
}

[ohler55]

It's a bit round about but if it works for you that's good. You could simplify and improve performance it by using this function:

func RenameKeys(data any, oldKey, newKey string) error {
	x := jp.D().C(oldKey)
	for _, np := range x.Locate(data, 0) {
		value := np.First(data)
		_ = np.Del(data)
		np[len(np)-1] = jp.Child(newKey)
		if err := np.SetOne(data, value); err != nil {
			return err
		}
	}
	return nil
}

[nsitbon]

I must admit I'm not confortable with this line np[len(np)-1] = jp.Child(newKey) : np seems to encapsulate the behaviour of a queue where you're calling the First method and then you go back to standard Golang subscripting operator to mutate the last element... doesn't really makes sense to me but I have to trust you ;-)

[ohler55]

If you look at the jp.Expr you will see it is a slice of jp.Frags. It perfectly reasonable to replace elements of the slice. Converting the slice to a string, replacing the string suffix, and then converting back to a slice is more error prone and very inefficient.

[ohler55]

func TestRename(t *testing.T) {
	data := oj.MustParse([]byte(`
{
    "firstName": "John",
    "lastName": "doe",
    "age": 26,
    "address": {
        "streetAddress": "naist street",
        "city": "Nara",
        "postalCode": "630-0192",
        "other": {
            "type": 456
        }
    },
    "phoneNumbers": [
        {
            "type": "iPhone",
            "number": "0123-4567-8888"
        },
        {
            "type": "home",
            "number": "0123-4567-8910"
        }
    ]
}
`))
	path := jp.MustParseString("$..type")
	fmt.Printf("before: %s\n", pretty.SEN(data))
	for _, np := range path.Locate(data, -1) {
		value := np.First(data)
		np.MustDel(data)
		np[len(np)-1] = jp.Child("newType")
		np.MustSetOne(data, value)
	}
	fmt.Printf("after: %s\n", pretty.SEN(data))
}