fix(arvoparser): Support array as root schema type

src/main/kotlin/com/github/imflog/schema/registry/parser/AvroSchemaParser.kt

@@ -5,13 +5,19 @@ import com.github.imflog.schema.registry.SchemaType
 import io.confluent.kafka.schemaregistry.client.SchemaRegistryClient
 import org.json.JSONArray
 import org.json.JSONObject
+import org.json.JSONTokener
 import java.io.File
 
 class AvroSchemaParser(
     client: SchemaRegistryClient,
     rootDir: File
 ) : SchemaParser(client, rootDir) {
 
+    data class MainSchema(
+        val schema: JSONObject,
+        val isObject: Boolean,
+    )
+
     override val schemaType: SchemaType = SchemaType.AVRO
 
     override fun resolveLocalReferences(
@@ -20,7 +26,7 @@ class AvroSchemaParser(
         localReferences: List<LocalReference>
     ): String {
         // Load and parse the main schema
-        val mainSchema = JSONObject(loadContent(schemaPath))
+        val mainSchema = loadMainSchema(loadContent(schemaPath))
 
         // Create a map of reference name to schema content
         val referenceSchemas = localReferences.associate { reference ->
@@ -31,8 +37,14 @@ class AvroSchemaParser(
         val visitedReferences = mutableSetOf<String>()
 
         // Process the schema recursively
-        val resolvedSchema = resolveReferences(mainSchema, referenceSchemas, null, visitedReferences)
-        return resolvedSchema.toString()
+        val resolvedSchema = resolveReferences(mainSchema.schema, referenceSchemas, null, visitedReferences)
+        if (mainSchema.isObject) {
+            return resolvedSchema.toString()
+        }
+        val myArray = JSONArray()
+        myArray.put(resolvedSchema.get("items"))
+
+        return myArray.toString();
     }
 
     private fun resolveReferences(
@@ -201,4 +213,25 @@ class AvroSchemaParser(
 
         return null
     }
+
+    // if json is object return it, if array with one item, coerce it into a json object
+    private fun loadMainSchema(input: String): MainSchema {
+        return when (val parsedInput = JSONTokener(input).nextValue()) {
+            is JSONObject -> MainSchema(parsedInput, true)
+            is JSONArray -> {
+                if (parsedInput.length() == 1) {
+                    val mySchema = JSONObject();
+                    mySchema.put("type", "array")
+                    mySchema.put("items", parsedInput.get(0))
+
+                    MainSchema(mySchema, false)
+                } else {
+                    throw IllegalArgumentException("Invalid schema format: array must contain exactly one JSONObject")
+                }
+            }
+            else -> {
+                throw IllegalArgumentException("Invalid schema format: must be a JSONObject or an array containing a JSONObject")
+            }
+        }
+    }
 }

src/test/kotlin/com/github/imflog/schema/registry/parser/AvroSchemaParserTest.kt

@@ -4,6 +4,7 @@ import com.github.imflog.schema.registry.LocalReference
 import io.confluent.kafka.schemaregistry.client.MockSchemaRegistryClient
 import org.assertj.core.api.Assertions
 import org.intellij.lang.annotations.Language
+import org.json.JSONArray
 import org.json.JSONObject
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.TestInstance
@@ -126,6 +127,64 @@ class AvroSchemaParserTest {
         )
     }
 
+    @Test
+    fun `Should resolve simple array type subject correctly`() {
+        // Given
+        val parser = AvroSchemaParser(schemaRegistryClient, File(testFilesPath))
+        val schema = File("${testFilesPath}testSubjectArraySimple.avsc")
+        // When
+        val resolvedSchema = parser.resolveLocalReferences(
+            "test",
+            schema.path,
+            listOf()
+        )
+        // Then
+        val resolved = JSONArray(resolvedSchema).toString()
+
+        @Language("JSON")
+        val expected = """
+          [
+            "string"
+          ]
+        """
+
+        Assertions.assertThat(resolved).isEqualTo(
+            JSONArray(expected).toString()
+        )
+    }
+
+    @Test
+    fun `Should resolve array type subject correctly`() {
+        // Given
+        val parser = AvroSchemaParser(schemaRegistryClient, File(testFilesPath))
+        val reference = LocalReference("B", "${testFilesPath}testType.avsc")
+        val schema = File("${testFilesPath}testSubjectArray.avsc")
+        // When
+        val resolvedSchema = parser.resolveLocalReferences(
+            "test",
+            schema.path,
+            listOf(reference)
+        )
+        // Then
+        val resolved = JSONArray(resolvedSchema).toString()
+
+        @Language("JSON")
+        val expected = """
+          [
+            {
+              "name":"B",
+              "namespace": "com.mycompany",
+              "type": "enum",
+              "symbols": ["X1", "X2"]
+            }
+          ]
+        """
+
+        Assertions.assertThat(resolved).isEqualTo(
+            JSONArray(expected).toString()
+        )
+    }
+
     @Test
     fun `Should handle local recursive type properly`() {
         // Given

src/test/resources/testSubjectArray.avsc

@@ -0,0 +1,3 @@
+[
+  "com.mycompany.B"
+]

src/test/resources/testSubjectArraySimple.avsc

@@ -0,0 +1,3 @@
+[
+  "string"
+]