feat: New Avro entrypoint

[Chuckame]

Here is the new proposed avro entrypoint 🥳

Goal

Provide an unified, easy and extensible way of encoding and decoding avro. Unified and easy as it should only have methods on the Avro class (no streams, no builders, ...). Extensible as avro can be used in multiple contexts, and some requires adding some metadata (data files) or schema info (confluent schema registry, single object).

Closes #163 #141

Requirements to merge:

• Encode everything at root (not only records)
• Encode natively to bytes

Breaking changes:

• No more AvroInputStream and AvroOutputStream, thanks to the encodeSequenceXxx and decodeSequenceXxx replacements with AvroSerializationDelegate
• No more encoding to and from Generic data, as the final goal of this library is to encode and decode in avro, not in Generic data, and also another step of removing the java avro library (no more public api in java, except for the Schemas)
• encodeToByteArray and decodeFromByteArray will now be pure avro (no header, just the encoded data itself without decorators) while before it was in Data mode (avro data file format)

Tickets to open after that:

• Create the necessary serializers to encode and decode Generic data (from bytes to generic, and from generic to bytes)

The methods

Each base method having a Schema and a SerializerStrategy or DeserializerStrategy has its related extension method to automagically get the SerializerStrategy or DeserializerStrategy and the schema from the reified type.

We now fully support java streams and ByteArray.

We are now able of streaming the avro contents with the new encodeSequence and decodeSequence methods, useful for reading avro files by example!

Example of usage

• Just encode a string payload

  val bytes = Avro.encodeToByteArray("a value to be encoded")
  val value = Avro.decodeFromByteArray<String>(bytes)

• Just encode a record payload

  val bytes = Avro.encodeToByteArray(ARecord(stringField = "something", intField = 42))
  val value = Avro.decodeFromByteArray<ARecord>(bytes)

• Encode to the avro data file format

  val avro = Avro {
  serializationDelegate = Builtins.DataFile
  }
  File("file.avro").outputStream().use { outputStream ->
  AvroObjectContainerFile().encodeToStream(sequenceOf("a", "b", "c"), outputStream)
  }
  File("file.avro").inputStream().use { inputStream ->
  val sequence = avro.decodeFromStream<String>(inputStream)
  }

• Just generate a schema from a type:

  val schema = Avro.schema<MySerializedType>()

[jangalinski]

Seems like you are aiming for static access, while in the current version, there is a default instance (Avro.default) to use, but also the option to create a custom instance. This is quite important when working with custom logical types .. am I missing st. or would we loose the option of configuring a custom instance?

[Chuckame]

Seems like you are aiming for static access, while in the current version, there is a default instance (Avro.default) to use, but also the option to create a custom instance. This is quite important when working with custom logical types .. am I missing st. or would we loose the option of configuring a custom instance?

To encode in single data object mode, then you are forced to not use the default avro instance but you need to create your own instance. Avro {...} is the new constructor, exactly the same way as Json from official kotlinx format.

So to sum up, technically it's exactly the same as before (you can use the default instance Avro, that was previously Avro.default, or you can create and customize your own instance with Avro{...}, that is the same as Avro({...}), were before it was Avro(AvroConfiguration(...))), while now we have a more kotlin-esque api.