Add support for encoding byte array as base64 string

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>()
+ }
+ }
  }
 }