AsMap with map[string]interface{} cannot set nil value

[qneyrat]

AsMap cannot handle nil value.
In case, you run jwt.Token.AsMap with claim "foo" is type map (zero value is nil) is "null" in jwt.
When you call AsMap on it, it throw panic "panic: reflect: call of reflect.Value.Type on zero Value".
It's normal because reflect.ValueOf(nil) has not type because is nil but if dst is map type it's settable.
You can run this to reproduce:

func TestAsMap(t *testing.T) {
	t.Run("maps", func(t *testing.T) {
		inputs := []interface{}{
			map[string]interface{}{
				"foo": "one",
				"bar": "two",
				"baz": nil,
			},
		}
		for _, x := range inputs {
			input := x
			t.Run(fmt.Sprintf("%T", input), func(t *testing.T) {
				ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
				defer cancel()
				dst := reflect.New(reflect.TypeOf(input))
				dst.Elem().Set(reflect.MakeMap(reflect.TypeOf(input)))
				if !assert.NoError(t, mapiter.AsMap(ctx, input, dst.Interface()), `mapiter.AsMap should succeed`) {
					return
				}
				if !assert.Equal(t, input, dst.Elem().Interface(), `maps should be the same`) {
					return
				}
			})
		}
	})
}

[MattBrittan]

I have encountered the same issue (token contained "user_access": null); currently using the below hack to prevent panics (with jwt).

package main

import (
	"context"

	"github.com/lestrrat-go/jwx/jwt"
)

func main() {
	token := jwt.New()
	token.Set("test", interface{}(nil))
	fixToken(token)

	// Below will not panic
	_, _ = token.AsMap(context.Background())

	// Demonstrate issue if hack is not included (will panic)
	token.Set("test", interface{}(nil))
	_, _ = token.AsMap(context.Background())
}

// fixToken removes interface{}(nil) values from the token because they cause panics in iter.AsMap
func fixToken(token jwt.Token) {
	// Hacky Fix for https://github.com/lestrrat-go/iter/issues/1
	token.Walk(context.Background(), VisitorFunc(func(k string, v interface{}) error {
		if v == interface{}(nil) {
			token.Remove(k)
		}
		return nil
	}))
}

// VisitorFunc is a type of Visitor based on a function
type VisitorFunc func(string, interface{}) error

func (fn VisitorFunc) Visit(s string, v interface{}) error {
	return fn(s, v)
}

[lestrrat]

Oh oops, sorry I didn't realize this existed until now. Reading...

[lestrrat]

Hi, thanks for the report, and sorry for not noticing this sooner.
I will cut a release and update jwx shortly.