UnmarshalJSON(v any) missing

[remster]

Is your feature request related to a problem? Please describe.
I have this function which has to return map[string][]interface{}:

func rulesets(ldClient *ld.LDClient, ldctx ldcontext.Context) (result map[string][]interface{}) {
	result = map[string][]interface{}{"foo": {"!=", "kind", "bar"}}
	ldval, _ := ldClient.JSONVariation("airspace_filter", ldctx, ldvalue.FromJSONMarshal(result))
	// I need LaunchDarkly to give me 'map[string][]interface{}' and not ldvalue. I shouldn't 
        // need to render the actual json so that I can unrender it back to 'map[string][]interface{}'
	if bytes, err := ldval.MarshalJSON(); err == nil {
		flagValue := map[string][]interface{}{}
		if err = json.Unmarshal(bytes, &flagValue); err == nil {
			result = flagValue
		}
	}
	return result
}

Describe the solution you'd like
I'd like this file to offer

// UnmarshalJSON stores itself in the value pointed to by v
func (v *Value) UnmarshalJSON(v any) error {
	bytes, err := v.MarshalJSON(); 
        if err == nil {
		return json.Unmarshal(bytes, v)
	}
        return err
}

Instead I see

// UnmarshalJSON parses a Value from JSON.
func (v *Value) UnmarshalJSON(data []byte) error {
	return jreader.UnmarshalJSONWithReader(data, v)
}

And its docu doesn't really say what it does - the grammar doesn't help.

[cwaldren-ld]

Hi @remster, thanks for the feedback.

Would Value.AsArbitraryValue() work for you?

It's not exactly what you need, but might be workable. Here's an example (ldvalue package prefix omitted from builder methods for brevity):

expected := map[string]interface{}{"foo": []interface{}{"!=", "kind", "bar"}}

got := ObjectBuild().Set("foo", ArrayOf(String("!="), String("kind"), String("bar"))).Build()

assert.Equal(t, expected, got.AsArbitraryValue())

[remster]

Thanks @cwaldren-ld - i don't think how it could help. The value i need to produce can be complex (many entries in the array) and it comes from the LaunchDarkly frontend as the value of the feature flag. I need to turn that which comes from LD into map[string]interface{} before or without knowing what's inside.

[cwaldren-ld]

I need to turn that which comes from LD into map[string]interface{} before or without knowing what's inside.

That's what AsArbitraryValue() does:

... objects are represented as ... map[string]any. They are deep-copied, which preserves immutability of the Value but may be an expensive operation.

Would you mind outlining what an example of your JSON might look like?

I think I'm not quite understanding the issue still, as the API I've linked does return map[string]any.

[remster]

our json is simply a mapbox filter and it can look like so:

["any",["<","floor",400],["and",["in","type",["population","traffic"]],[">","magnitude",60]]]

A product manager, with the LaunchDarkly web console, sets its value and the golang code reads the value into map[string]interface{}. So at no point i need to "craft" that ld value from literals in the go code like you sugested:

ObjectBuild().Set("foo", ArrayOf(String("!="), String("kind"), String("bar"))).Build()

I need to turn an ldvalue that comes from

ldval, err := ldClient.JSONVariation("mapbox_filter", ldctx, ldvalue.FromJSONMarshal(default))

intomap[string]interface{}

[cwaldren-ld]

I used the ObjectBuild() just to demonstrate how the AsArbitraryValue() works, as a Go-style test. You wouldn't use that in your own code, since you already have an ldvalue.Value.

I need to turn an ldvalue that comes from... (example)

..into map[string]interface{}

Call AsArbitraryValue():

ldval, err := ldClient.JSONVariation("mapbox_filter", ldctx, ldvalue.FromJSONMarshal(default))

mapFromStringToInterface := ldval.AsArbitraryValue().(map[string]interface{})

// Now you have a map[string]interface{}.

[remster]

Oh I see. Sorry. I was i think distracted by that ObjectBuild()
So that would be pretty and neat, but somehow doesn't work for me - i gave it 10mins time i have now to test:

[cwaldren-ld]

That's because AsArbitraryValue() returns a map[string]interface{}, not a map[string][]interface{}.

First, cast it to map[string]interface{} exactly as I showed in the example.

Then for each value in the map, you can cast it to a []interface.