feat: dereference schemas where possible (hamba#291)

cmd/avrosv/main_test.go

@@ -112,7 +112,7 @@ func TestAvroSv_Verbose(t *testing.T) {
 		{
 			name:    "dumps a schema with a reference to an existing schema",
 			args:    []string{"avrosv", "-v", "testdata/schema.avsc", "testdata/withref-schema.avsc"},
-			out:     "{\"name\":\"testref\",\"type\":\"record\",\"fields\":[{\"name\":\"someref\",\"type\":\"test\"}]}\n",
+			out:     "{\"name\":\"testref\",\"type\":\"record\",\"fields\":[{\"name\":\"someref\",\"type\":{\"name\":\"test\",\"type\":\"record\",\"fields\":[{\"name\":\"someString\",\"type\":\"string\"}]}}]}\n",
 			wantErr: false,
 		},
 	}

schema.go

@@ -1225,7 +1225,7 @@ func (s *RefSchema) Type() Type {
 }
 
 // Schema returns the schema being referenced.
-func (s *RefSchema) Schema() Schema {
+func (s *RefSchema) Schema() NamedSchema {
 	return s.actual
 }
 

schema_parse.go

@@ -67,7 +67,11 @@ func ParseBytesWithCache(schema []byte, namespace string, cache *SchemaCache) (S
 		json = string(schema)
 	}
 
-	return parseType(namespace, json, cache)
+	s, err := parseType(namespace, json, cache)
+	if err != nil {
+		return nil, err
+	}
+	return derefSchema(s), nil
 }
 
 func parseType(namespace string, v any, cache *SchemaCache) (Schema, error) {
@@ -530,3 +534,24 @@ func decodeMap(in, v any, meta *mapstructure.Metadata) error {
 	decoder, _ := mapstructure.NewDecoder(cfg)
 	return decoder.Decode(in)
 }
+
+func derefSchema(schema Schema) Schema {
+	seen := map[string]struct{}{}
+
+	return walkSchema(schema, func(schema Schema) Schema {
+		if ns, ok := schema.(NamedSchema); ok {
+			seen[ns.FullName()] = struct{}{}
+			return schema
+		}
+
+		ref, isRef := schema.(*RefSchema)
+		if !isRef {
+			return schema
+		}
+
+		if _, haveSeen := seen[ref.Schema().FullName()]; !haveSeen {
+			return ref.Schema()
+		}
+		return schema
+	})
+}

schema_test.go

@@ -1255,6 +1255,15 @@ func TestSchema_FingerprintUsingInvalidType(t *testing.T) {
 	assert.Error(t, err)
 }
 
+func TestSchema_MultiFile(t *testing.T) {
+	got, err := avro.ParseFiles("testdata/superhero-part1.avsc", "testdata/superhero-part2.avsc")
+
+	require.NoError(t, err)
+	want, err := avro.ParseFiles("testdata/superhero.avsc")
+	require.NoError(t, err)
+	assert.Equal(t, want, got)
+}
+
 func TestSchema_Interop(t *testing.T) {
 	schm := `
 {

schema_walk.go

@@ -0,0 +1,21 @@
+package avro
+
+func walkSchema(schema Schema, fn func(Schema) Schema) Schema {
+	schema = fn(schema)
+
+	switch s := schema.(type) {
+	case *RecordSchema:
+		for _, f := range s.Fields() {
+			f.typ = walkSchema(f.typ, fn)
+		}
+	case *ArraySchema:
+		s.items = walkSchema(s.items, fn)
+	case *MapSchema:
+		s.values = walkSchema(s.values, fn)
+	case *UnionSchema:
+		for i, st := range s.types {
+			s.types[i] = walkSchema(st, fn)
+		}
+	}
+	return schema
+}

testdata/superhero-part1.avsc

@@ -0,0 +1,12 @@
+{
+  "type": "record",
+  "name": "Superpower",
+  "namespace": "com.model",
+  "fields": [
+    {"name": "id", "type": "int"},
+    {"name": "name", "type": "string"},
+    {"name": "damage", "type": "float"},
+    {"name": "energy", "type": "float"},
+    {"name": "passive", "type": "boolean"}
+  ]
+}

testdata/superhero-part2.avsc

@@ -0,0 +1,16 @@
+{
+    "type": "record",
+    "name": "Superhero",
+    "namespace": "com.model",
+    "fields": [
+        {"name": "id", "type": "int"},
+        {"name": "affiliation_id", "type": "int"},
+        {"name": "name", "type": "string"},
+        {"name": "life", "type": "float"},
+        {"name": "energy", "type": "float"},
+        {"name": "powers", "type": {
+                "type": "array",
+                "items": {"type": "Superpower"}}
+        }
+    ]
+}