draft implementation for supporting java.util.Currency as StandardType

zio-schema-avro/shared/src/main/scala/zio/schema/codec/AvroCodec.scala

@@ -423,6 +423,12 @@ object AvroCodec {
  .toEither
  .left
  .map(e => DecodeError.MalformedFieldWithPath(Chunk.empty, e.getMessage))
+ case StandardType.CurrencyType =>
+ Try(value.asInstanceOf[Utf8])
+ .flatMap(c => Try(java.util.Currency.getInstance(c.toString)))
+ .toEither
+ .left
+ .map(e => DecodeError.MalformedFieldWithPath(Chunk.empty, e.getMessage))
  }
 
  private def decodeMap(value: Any, schema: Schema.Map[Any, Any]) = {
@@ -893,6 +899,8 @@ object AvroCodec {
  case StandardType.ZonedDateTimeType =>
  val zonedDateTime = a.asInstanceOf[java.time.ZonedDateTime]
  zonedDateTime.toString
+ case StandardType.CurrencyType =>
+ a.asInstanceOf[java.util.Currency].getCurrencyCode
  }
 
  private def encodeSequence[A](schema: Schema[A], v: Chunk[A]): Any = {

zio-schema-avro/shared/src/main/scala/zio/schema/codec/AvroPropMarker.scala

@@ -25,6 +25,10 @@ object AvroPropMarker {
  override def propName: String = "zio.schema.codec.avro.either"
  }
 
+ case object CurrencyWrapper extends AvroPropMarker {
+ override def propName: String = "zio.schema.codec.avro.currency"
+ }
+
  final case class DurationChronoUnit(chronoUnit: ChronoUnit) extends AvroPropMarker {
  override def propName: String = DurationChronoUnit.propName
  override def value: Any = chronoUnit.name()

zio-schema-avro/shared/src/main/scala/zio/schema/codec/AvroSchemaCodec.scala

@@ -378,6 +378,12 @@ object AvroSchemaCodec extends AvroSchemaCodec {
  .create(SchemaAvro.Type.STRING)
  .addMarkerProp(StringDiscriminator(StringType.ZoneDateTime))
  )
+ case StandardType.CurrencyType =>
+ Right(
+ SchemaAvro
+ .create(SchemaAvro.Type.STRING)
+ .addMarkerProp(CurrencyWrapper)
+ )
  }
  case Optional(codec, _) =>
  for {

zio-schema-bson/shared/src/main/scala/zio/schema/codec/BsonSchemaCodec.scala

@@ -369,6 +369,7 @@ object BsonSchemaCodec {
  case StandardType.ZoneIdType => BsonCodec.zoneId.asInstanceOf[BsonCodec[A]] //BsonCodec[java.time.ZoneId]
  case StandardType.ZoneOffsetType =>
  BsonCodec.zoneOffset.asInstanceOf[BsonCodec[A]] //BsonCodec[java.time.ZoneOffset]
+ // case StandardType.CurrencyType => BsonCodec.currency.asInstanceOf[BsonCodec[A]] //BsonCodec[java.util.Currency] // TODO: needs implementation in zio-bson
  }
  }
 

zio-schema-msg-pack/shared/src/main/scala/zio/schema/codec/MessagePackDecoder.scala

@@ -278,7 +278,8 @@ private[codec] class MessagePackDecoder(bytes: Chunk[Byte]) {
  decodeString(path).map(OffsetDateTime.parse(_))
  case StandardType.ZonedDateTimeType =>
  decodeString(path).map(ZonedDateTime.parse(_))
- case _ => fail(path, s"Unsupported primitive type $standardType")
+ case StandardType.CurrencyType => decodeString(path).map(java.util.Currency.getInstance(_))
+ case _ => fail(path, s"Unsupported primitive type $standardType")
  }
 
  private def decodeOptional[A](path: Path, schema: Schema.Optional[A]): Result[Option[A]] =

zio-schema-msg-pack/shared/src/main/scala/zio/schema/codec/MessagePackEncoder.scala

@@ -242,6 +242,9 @@ private[codec] class MessagePackEncoder {
  case (StandardType.ZonedDateTimeType, v: ZonedDateTime) =>
  packer.packString(v.toString)
  ()
+ case (StandardType.CurrencyType, v: java.util.Currency) =>
+ packer.packString(v.getCurrencyCode)
+ ()
  case (_, _) =>
  throw new NotImplementedError(s"No encoder for $standardType")
  }

zio-schema-protobuf/shared/src/main/scala/zio/schema/codec/ProtobufCodec.scala

@@ -95,6 +95,7 @@ object ProtobufCodec {
  case StandardType.OffsetTimeType => false
  case StandardType.OffsetDateTimeType => false
  case StandardType.ZonedDateTimeType => false
+ case StandardType.CurrencyType => false
  }
  }
 
@@ -400,6 +401,8 @@ object ProtobufCodec {
  encodePrimitive(fieldNumber, StandardType.StringType, v.toString)
  case (StandardType.ZonedDateTimeType, v: ZonedDateTime) =>
  encodePrimitive(fieldNumber, StandardType.StringType, v.format(DateTimeFormatter.ISO_ZONED_DATE_TIME))
+ case (StandardType.CurrencyType, v: java.util.Currency) =>
+ encodePrimitive(fieldNumber, StandardType.StringType, v.getCurrencyCode)
  case (_, _) =>
  throw new NotImplementedError(s"No encoder for $standardType")
  }
@@ -585,7 +588,8 @@ object ProtobufCodec {
  OffsetDateTime.parse(stringDecoder(context))
  case StandardType.ZonedDateTimeType =>
  ZonedDateTime.parse(stringDecoder(context))
- case st => fail(context, s"Unsupported primitive type $st")
+ case StandardType.CurrencyType => java.util.Currency.getInstance(stringDecoder(context))
+ case st => fail(context, s"Unsupported primitive type $st")
  }
 
  override protected def startCreatingRecord(context: DecoderContext, record: Schema.Record[_]): DecoderContext =

zio-schema-thrift/shared/src/main/scala/zio/schema/codec/ThriftCodec.scala

@@ -355,6 +355,8 @@ object ThriftCodec {
  p.writeString(v.toString)
  case (StandardType.ZonedDateTimeType, v: ZonedDateTime) =>
  p.writeString(v.toString)
+ case (StandardType.CurrencyType, v: java.util.Currency) =>
+ p.writeString(v.getCurrencyCode)
  case (_, _) =>
  fail(s"No encoder for $standardType")
  }
@@ -408,6 +410,7 @@ object ThriftCodec {
  case StandardType.OffsetTimeType => TType.STRING
  case StandardType.OffsetDateTimeType => TType.STRING
  case StandardType.ZonedDateTimeType => TType.STRING
+ case StandardType.CurrencyType => TType.STRING
  case _ => TType.VOID
  }
 
@@ -572,6 +575,8 @@ object ThriftCodec {
  OffsetDateTime.parse(decodeString(context.path))
  case StandardType.ZonedDateTimeType =>
  ZonedDateTime.parse(decodeString(context.path))
+ case StandardType.CurrencyType =>
+ java.util.Currency.getInstance(decodeString(context.path))
  case _ => fail(context, s"Unsupported primitive type $typ")
  }
 

zio-schema-zio-test/shared/src/main/scala/zio/schema/DeriveGen.scala

@@ -513,6 +513,7 @@ object DeriveGen {
  case StandardType.OffsetTimeType => Gen.offsetTime
  case StandardType.OffsetDateTimeType => Gen.offsetDateTime
  case StandardType.ZonedDateTimeType => Gen.zonedDateTime
+ // case StandardType.CurrencyType => Gen.currency // TODO: needs implementation in zio-test
  }
 
  gen.map(_.asInstanceOf[A])

zio-schema/shared/src/main/scala/zio/schema/Differ.scala

@@ -4,12 +4,10 @@ import java.math.{ BigInteger, MathContext }
 import java.time.temporal.{ ChronoField, ChronoUnit }
 import java.time.{
  DayOfWeek,
- Duration => JDuration,
  Instant,
  LocalDate,
  LocalDateTime,
  LocalTime,
- Month => JMonth,
  MonthDay,
  OffsetDateTime,
  OffsetTime,
@@ -18,13 +16,13 @@ import java.time.{
  YearMonth,
  ZoneId,
  ZoneOffset,
+ Duration => JDuration,
+ Month => JMonth,
  ZonedDateTime => JZonedDateTime
 }
-import java.util.UUID
-
+import java.util.{ Currency, UUID }
 import scala.annotation.nowarn
 import scala.collection.immutable.ListMap
-
 import zio.schema.diff.Edit
 import zio.{ Chunk, ChunkBuilder }
 
@@ -255,6 +253,7 @@ object Differ {
  case Schema.Primitive(StandardType.OffsetDateTimeType, _) => offsetDateTime
  case Schema.Primitive(StandardType.ZonedDateTimeType, _) => zonedDateTime
  case Schema.Primitive(StandardType.ZoneOffsetType, _) => zoneOffset
+ case Schema.Primitive(StandardType.CurrencyType, _) => currency
  case Schema.Tuple2(leftSchema, rightSchema, _) => fromSchema(leftSchema) <*> fromSchema(rightSchema)
  case Schema.Optional(schema, _) => fromSchema(schema).optional
  case Schema.Sequence(schema, g, f, _, _) =>
@@ -522,6 +521,13 @@ object Differ {
  }
  }
 
+ val currency: Differ[Currency] =
+ (thisValue: Currency, thatValue: Currency) =>
+ if (thisValue == thatValue)
+ Patch.identical
+ else
+ Patch.Currency(thatValue)
+
  def tuple[A, B](left: Differ[A], right: Differ[B]): Differ[(A, B)] =
  (thisValue: (A, B), thatValue: (A, B)) =>
  (thisValue, thatValue) match {

zio-schema/shared/src/main/scala/zio/schema/Patch.scala

@@ -206,6 +206,13 @@ object Patch {
  override def invert: Patch[JZonedDateTime] = ZonedDateTime(localDateTimeDiff.invert, zoneIdDiff.invert)
  }
 
+ final case class Currency(currencyCodeDiff: java.util.Currency) extends Patch[java.util.Currency] {
+ override def patch(input: java.util.Currency): scala.Either[String, java.util.Currency] =
+ Right(input)
+
+ override def invert: Patch[java.util.Currency] = Currency(currencyCodeDiff)
+ }
+
  final case class Tuple[A, B](leftDifference: Patch[A], rightDifference: Patch[B]) extends Patch[(A, B)] {
 
  override def isIdentical: Boolean = leftDifference.isIdentical && rightDifference.isIdentical

zio-schema/shared/src/main/scala/zio/schema/StandardType.scala

@@ -3,9 +3,10 @@ package zio.schema
 import java.math.BigInteger
 import java.time
 import java.time._
-
 import zio.Chunk
 
+import java.util.Currency
+
 sealed trait StandardType[A] extends Ordering[A] { self =>
  def tag: String
  def defaultValue: Either[String, A]
@@ -51,6 +52,7 @@ object StandardType {
  final val OFFSET_DATE_TIME = "offsetDateTime"
  final val ZONED_DATE_TIME = "zonedDateTime"
  final val UUID = "uuid"
+ final val CURRENCY = "currency"
  }
 
  def fromString(tag: String): Option[StandardType[_]] =
@@ -85,6 +87,7 @@ object StandardType {
  case Tags.OFFSET_DATE_TIME => Some(OffsetDateTimeType)
  case Tags.ZONED_DATE_TIME => Some(ZonedDateTimeType)
  case Tags.UUID => Some(UUIDType)
+ case Tags.CURRENCY => Some(CurrencyType)
  }
 
  def apply[A](implicit standardType: StandardType[A]): StandardType[A] = standardType
@@ -290,4 +293,15 @@ object StandardType {
 
  override def compare(x: ZonedDateTime, y: ZonedDateTime): Int = x.compareTo(y)
  }
+
+ implicit object CurrencyType extends StandardType[java.util.Currency] {
+
+ override def tag: String = Tags.CURRENCY
+
+ override def defaultValue: Either[String, Currency] =
+ Right(java.util.Currency.getInstance(java.util.Locale.getDefault))
+
+ override def compare(x: Currency, y: Currency): Int = x.getCurrencyCode.compareTo(y.getCurrencyCode)
+ }
+
 }