feat: plain map and slice

README.md

@@ -115,7 +115,7 @@ When a non-`nil` union value is encountered, a single key is en/decoded. The key
 type name, or scheam full name in the case of a named schema (enum, fixed or record).
 * ***T:** This is allowed in a "nullable" union. A nullable union is defined as a two schema union, 
 with one of the types being `null` (ie. `["null", "string"]` or `["string", "null"]`), in this case 
-a `*T` is allowed, with `T` matching the conversion table above. In the case of a slice, the slice can be used
+a `*T` is allowed, with `T` matching the conversion table above. In the case of a slice or a map, the slice or the map can be used
 directly.
 * **any:** An `interface` can be provided and the type or name resolved. Primitive types
 are pre-registered, but named types, maps and slices will need to be registered with the `Register` function. 

cmd/avrogen/main.go

@@ -25,6 +25,8 @@ type config struct {
 	FullName    bool
 	Encoders    bool
 	FullSchema  bool
+	PlainMap    bool
+	PlainSlice  bool
 	StrictTypes bool
 	Initialisms string
 }
@@ -45,6 +47,8 @@ func realMain(args []string, stdout, stderr io.Writer) int {
 	flgs.BoolVar(&cfg.Encoders, "encoders", false, "Generate encoders for the structs.")
 	flgs.BoolVar(&cfg.FullSchema, "fullschema", false, "Use the full schema in the generated encoders.")
 	flgs.BoolVar(&cfg.StrictTypes, "strict-types", false, "Use strict type sizes (e.g. int32) during generation.")
+	flgs.BoolVar(&cfg.PlainMap, "plain-map", false, "Use a plain map instead of a ptr for nullable map unions.")
+	flgs.BoolVar(&cfg.PlainSlice, "plain-slice", false, "Use a plain slice instead of a ptr for nullable slice unions.")
 	flgs.StringVar(&cfg.Initialisms, "initialisms", "", "Custom initialisms <VAL>[,...] for struct and field names.")
 	flgs.StringVar(&cfg.TemplateFileName, "template-filename", "", "Override output template with one loaded from file.")
 	flgs.Usage = func() {
@@ -85,6 +89,8 @@ func realMain(args []string, stdout, stderr io.Writer) int {
 		gen.WithEncoders(cfg.Encoders),
 		gen.WithInitialisms(initialisms),
 		gen.WithTemplate(string(template)),
+		gen.WithPlainMap(cfg.PlainMap),
+		gen.WithPlainSlice(cfg.PlainSlice),
 		gen.WithStrictTypes(cfg.StrictTypes),
 		gen.WithFullSchema(cfg.FullSchema),
 	}

cmd/avrogen/main_test.go

@@ -189,6 +189,33 @@ func TestAvroGen_GeneratesSchemaWithStrictTypes(t *testing.T) {
 	assert.Equal(t, want, got)
 }
 
+func TestAvroGen_GeneratePlain(t *testing.T) {
+	for _, opt := range []string{"map", "slice"} {
+		t.Run(opt, func(t *testing.T) {
+			t.Parallel()
+
+			path := t.TempDir()
+			file := filepath.Join(path, "test.go")
+
+			args := []string{"avrogen", "-pkg", "testpkg", "-o", file, "-plain-" + opt, "testdata/schema.avsc"}
+			gotCode := realMain(args, io.Discard, io.Discard)
+			require.Equal(t, 0, gotCode)
+
+			got, err := os.ReadFile(file)
+			require.NoError(t, err)
+
+			if *update {
+				err = os.WriteFile("testdata/golden_plain"+opt+".go", got, 0600)
+				require.NoError(t, err)
+			}
+
+			want, err := os.ReadFile("testdata/golden_plain" + opt + ".go")
+			require.NoError(t, err)
+			assert.Equal(t, want, got)
+		})
+	}
+}
+
 func TestParseTags(t *testing.T) {
 	tests := []struct {
 		name string

cmd/avrogen/testdata/schema.avsc

@@ -5,6 +5,8 @@
   "doc": "Test is a test struct",
   "fields": [
     { "name": "someString", "type": "string", "doc": "SomeString is a string" },
-    { "name": "someInt", "type": "int" }
+    { "name": "someInt", "type": "int" },
+    { "name":  "someNullableMap", "type":  ["null", {"type": "map", "values": "int"}]},
+    { "name":  "someNullableSlice", "type":  ["null", {"type": "array", "items": "int"}]}
   ]
-}
+}

codec_union.go

@@ -13,10 +13,18 @@ import (
 func createDecoderOfUnion(d *decoderContext, schema *UnionSchema, typ reflect2.Type) ValDecoder {
 	switch typ.Kind() {
 	case reflect.Map:
-		if typ.(reflect2.MapType).Key().Kind() != reflect.String ||
-			typ.(reflect2.MapType).Elem().Kind() != reflect.Interface {
+		if typ.(reflect2.MapType).Key().Kind() != reflect.String {
 			break
 		}
+
+		if typ.(reflect2.MapType).Elem().Kind() != reflect.Interface {
+			if !schema.Nullable() {
+				break
+			}
+
+			return decoderOfNullableUnion(d, schema, typ)
+		}
+
 		return decoderOfMapUnion(d, schema, typ)
 	case reflect.Slice:
 		if !schema.Nullable() {
@@ -44,10 +52,18 @@ func createDecoderOfUnion(d *decoderContext, schema *UnionSchema, typ reflect2.T
 func createEncoderOfUnion(e *encoderContext, schema *UnionSchema, typ reflect2.Type) ValEncoder {
 	switch typ.Kind() {
 	case reflect.Map:
-		if typ.(reflect2.MapType).Key().Kind() != reflect.String ||
-			typ.(reflect2.MapType).Elem().Kind() != reflect.Interface {
+		if typ.(reflect2.MapType).Key().Kind() != reflect.String {
 			break
 		}
+
+		if typ.(reflect2.MapType).Elem().Kind() != reflect.Interface {
+			if !schema.Nullable() {
+				break
+			}
+
+			return encoderOfNullableUnion(e, schema, typ)
+		}
+
 		return encoderOfMapUnion(e, schema, typ)
 	case reflect.Slice:
 		if !schema.Nullable() {
@@ -179,6 +195,8 @@ func decoderOfNullableUnion(d *decoderContext, schema Schema, typ reflect2.Type)
 		isPtr = true
 	case *reflect2.UnsafeSliceType:
 		baseTyp = v
+	case *reflect2.UnsafeMapType:
+		baseTyp = v
 	}
 	decoder := decoderOfType(d, union.Types()[typeIdx], baseTyp)
 
@@ -249,6 +267,8 @@ func encoderOfNullableUnion(e *encoderContext, schema Schema, typ reflect2.Type)
 		isPtr = true
 	case *reflect2.UnsafeSliceType:
 		baseTyp = v
+	case *reflect2.UnsafeMapType:
+		baseTyp = v
 	}
 	encoder := encoderOfType(e, union.Types()[typeIdx], baseTyp)
 

decoder_union_test.go

@@ -225,6 +225,42 @@ func TestDecoder_UnionPtrReversedNull(t *testing.T) {
 	assert.Nil(t, got)
 }
 
+func TestDecoder_UnionNullableMap(t *testing.T) {
+	tt := []struct {
+		name string
+		data []byte
+		want map[string]string
+	}{{
+		name: "WithData",
+		data: []byte{0x02, 0x01, 0x10, 0x06, 0x66, 0x6F, 0x6F, 0x06, 0x66, 0x6F, 0x6F, 0x00},
+		want: map[string]string{"foo": "foo"},
+	}, {
+		name: "Empty",
+		data: []byte{0x02, 0x00},
+		want: map[string]string{},
+	}, {
+		name: "Null",
+		data: []byte{0x00},
+		want: nil,
+	}}
+
+	schema := `["null", {"type":"map", "values": "string"}]`
+
+	for _, test := range tt {
+		t.Run(test.name, func(t *testing.T) {
+			defer ConfigTeardown()
+
+			dec, _ := avro.NewDecoder(schema, bytes.NewReader(test.data))
+
+			var got map[string]string
+			err := dec.Decode(&got)
+
+			require.NoError(t, err)
+			assert.Equal(t, test.want, got)
+		})
+	}
+}
+
 func TestDecoder_UnionNullableSlice(t *testing.T) {
 	defer ConfigTeardown()
 

encoder_union_test.go

@@ -256,6 +256,43 @@ func TestEncoder_UnionPtrNotNullable(t *testing.T) {
 	assert.Error(t, err)
 }
 
+func TestEncoder_UnionNullableMap(t *testing.T) {
+	tt := []struct {
+		name string
+		data map[string]string
+		want []byte
+	}{{
+		name: "WithData",
+		data: map[string]string{"foo": "foo"},
+		want: []byte{0x02, 0x01, 0x10, 0x06, 0x66, 0x6F, 0x6F, 0x06, 0x66, 0x6F, 0x6F, 0x00},
+	}, {
+		name: "Empty",
+		data: map[string]string{},
+		want: []byte{0x02, 0x00},
+	}, {
+		name: "Null",
+		data: nil,
+		want: []byte{0x00},
+	}}
+
+	schema := `["null", {"type":"map", "values": "string"}]`
+
+	for _, test := range tt {
+		t.Run(test.name, func(t *testing.T) {
+			defer ConfigTeardown()
+
+			buf := bytes.NewBuffer([]byte{})
+			enc, err := avro.NewEncoder(schema, buf)
+			require.NoError(t, err)
+
+			err = enc.Encode(test.data)
+
+			require.NoError(t, err)
+			assert.Equal(t, test.want, buf.Bytes())
+		})
+	}
+}
+
 func TestEncoder_UnionNullableSlice(t *testing.T) {
 	defer ConfigTeardown()
 

gen/gen.go

@@ -24,6 +24,8 @@ type Config struct {
 	FullName     bool
 	Encoders     bool
 	FullSchema   bool
+	PlainMap     bool
+	PlainSlice   bool
 	StrictTypes  bool
 	Initialisms  []string
 	LogicalTypes []LogicalType
@@ -43,6 +45,9 @@ const (
 	Kebab TagStyle = "kebab"
 	// UpperCamel is a style like ImWrittenInUpperCamel.
 	UpperCamel TagStyle = "upper-camel"
+
+	prefixMap   string = "map["
+	prefixSlice string = "[]"
 )
 
 //go:embed output_template.tmpl
@@ -85,6 +90,8 @@ func StructFromSchema(schema avro.Schema, w io.Writer, cfg Config) error {
 		WithInitialisms(cfg.Initialisms),
 		WithStrictTypes(cfg.StrictTypes),
 		WithFullSchema(cfg.FullSchema),
+		WithPlainMap(cfg.PlainMap),
+		WithPlainSlice(cfg.PlainSlice),
 	}
 	for _, opt := range cfg.LogicalTypes {
 		opts = append(opts, WithLogicalType(opt))
@@ -168,6 +175,20 @@ func WithFullSchema(b bool) OptsFunc {
 	}
 }
 
+// WithPlainMap configures the generator to emit a plain map and not a map ptr for nullable unions.
+func WithPlainMap(b bool) OptsFunc {
+	return func(g *Generator) {
+		g.plainMap = b
+	}
+}
+
+// WithPlainSlice configures the generator to emit a plain map and not a map ptr for nullable unions.
+func WithPlainSlice(b bool) OptsFunc {
+	return func(g *Generator) {
+		g.plainSlice = b
+	}
+}
+
 // LogicalType used when the name of the "LogicalType" field in the Avro schema matches the Name attribute.
 type LogicalType struct {
 	// Name of the LogicalType
@@ -210,6 +231,8 @@ type Generator struct {
 	fullName     bool
 	encoders     bool
 	fullSchema   bool
+	plainMap     bool
+	plainSlice   bool
 	strictTypes  bool
 	initialisms  []string
 	logicalTypes map[avro.LogicalType]LogicalType
@@ -356,6 +379,14 @@ func (g *Generator) resolveUnionTypes(s *avro.UnionSchema) string {
 		types = append(types, g.generate(elem))
 	}
 	if s.Nullable() {
+		if g.plainMap && strings.HasPrefix(types[0], prefixMap) {
+			return types[0]
+		}
+
+		if g.plainSlice && strings.HasPrefix(types[0], prefixSlice) {
+			return types[0]
+		}
+
 		return "*" + types[0]
 	}
 	return "any"