Add support for encoding byte array as base64 string

Author: OptimumCode

json-schema-validator-objects/src/commonMain/kotlin/io/github/optimumcode/json/schema/wrappers/objects/Wrappers.kt

@@ -8,6 +8,7 @@ import io.github.optimumcode.json.schema.model.AbstractElement
 import io.github.optimumcode.json.schema.model.ArrayElement
 import io.github.optimumcode.json.schema.model.ObjectElement
 import io.github.optimumcode.json.schema.model.PrimitiveElement
+import io.github.optimumcode.json.schema.wrappers.objects.internal.encodeBase64
 import kotlin.jvm.JvmInline
 import kotlin.jvm.JvmName
 import kotlin.jvm.JvmOverloads
@@ -24,17 +25,24 @@ public class WrappingConfiguration internal constructor(
    * If set to `true` the [Char] is converted to a codepoint (and then to [Long])
    */
   public val charAsCodepoint: Boolean = false,
+  /**
+   * If set to `true` the [ByteArray] is encoded using Base64 encoding and wrapped as a [PrimitiveElement].
+   * Otherwise, the [ByteArray] is wrapped as an [ArrayElement].
+   */
+  public val byteArrayAsBase64String: Boolean = true,
 )
 
 @ExperimentalApi
 @JvmOverloads
 public fun wrappingConfiguration(
   allowSets: Boolean = false,
   charAsCodepoint: Boolean = false,
+  byteArrayAsBase64String: Boolean = true,
 ): WrappingConfiguration =
   WrappingConfiguration(
     allowSets = allowSets,
     charAsCodepoint = charAsCodepoint,
+    byteArrayAsBase64String = byteArrayAsBase64String,
   )
 
 /**
@@ -59,10 +67,14 @@ public fun wrappingConfiguration(
  * * [Map] -> keys MUST have a [String] type, values MUST be one of the supported types
  * * [List] -> elements MUST be one of the supported types
  * * [Array] -> elements MUST be one of the supported types
+ * * [CharArray], [ByteArray], [ShortArray], [IntArray], [LongArray], [FloatArray], [DoubleArray]
  *
  * If [WrappingConfiguration.allowSets] is enabled [Set] is also converted to [ArrayElement].
  * Please be aware that in order to have consistent verification results
  * the [Set] must be one of the ORDERED types, e.g. [LinkedHashSet].
+ *
+ * If [WrappingConfiguration.byteArrayAsBase64String] is enabled (enabled by default)
+ * a [ByteArray] will be encoded using Base64 and wrapped as a [PrimitiveElement].
  */
 @JvmOverloads
 @ExperimentalApi
@@ -83,7 +95,12 @@ public fun wrapAsElement(
     obj is DoubleArray -> ListWrapper(obj.map { wrapAsElement(it, configuration) })
     obj is FloatArray -> ListWrapper(obj.map { wrapAsElement(it, configuration) })
     obj is CharArray -> ListWrapper(obj.map { wrapAsElement(it, configuration) })
-    obj is ByteArray -> ListWrapper(obj.map { wrapAsElement(it, configuration) })
+    obj is ByteArray ->
+      if (configuration.byteArrayAsBase64String) {
+        PrimitiveWrapper(obj.encodeBase64())
+      } else {
+        ListWrapper(obj.map { wrapAsElement(it, configuration) })
+      }
     obj is Set<*> && configuration.allowSets ->
       ListWrapper(obj.map { wrapAsElement(it, configuration) })
 

json-schema-validator-objects/src/commonMain/kotlin/io/github/optimumcode/json/schema/wrappers/objects/internal/Base64.kt

@@ -0,0 +1,7 @@
+package io.github.optimumcode.json.schema.wrappers.objects.internal
+
+import kotlin.io.encoding.Base64
+import kotlin.io.encoding.ExperimentalEncodingApi
+
+@OptIn(ExperimentalEncodingApi::class)
+internal fun ByteArray.encodeBase64(): String = Base64.Default.encode(this)

json-schema-validator-objects/src/commonTest/kotlin/io/github/optimumcode/json/schema/wrappers/objects/WrappersTest.kt

@@ -26,6 +26,13 @@ class WrappersTest : FunSpec() {
     fun Any?.str(): String =
       when (this) {
         is Array<*> -> this.contentToString()
+        is ByteArray -> this.contentToString()
+        is ShortArray -> this.contentToString()
+        is IntArray -> this.contentToString()
+        is LongArray -> this.contentToString()
+        is FloatArray -> this.contentToString()
+        is DoubleArray -> this.contentToString()
+        is CharArray -> this.contentToString()
         else -> toString()
       }
 
@@ -35,7 +42,8 @@ class WrappersTest : FunSpec() {
       emptyMap<String, Any>() to ObjectElement::class,
       listOf<Any>() to ArrayElement::class,
       emptyArray<Any>() to ArrayElement::class,
-      byteArrayOf() to ArrayElement::class,
+      // by default ByteArray is encoded as base64 string
+      byteArrayOf() to PrimitiveElement::class,
       shortArrayOf() to ArrayElement::class,
       intArrayOf() to ArrayElement::class,
       longArrayOf() to ArrayElement::class,
@@ -297,6 +305,18 @@ class WrappersTest : FunSpec() {
           wrapAsElement(MyNumber())
         }.message.shouldStartWith("unsupported number type:")
       }
+
+    test("byte array can be wrapped as an array element") {
+      wrapAsElement(
+        byteArrayOf(42),
+        wrappingConfiguration(
+          byteArrayAsBase64String = false,
+        ),
+      ).shouldBeInstanceOf<ArrayElement> {
+        it.size shouldBe 1
+        it.single().shouldBeInstanceOf<PrimitiveElement>()
+      }
+    }
   }
 }