Transform wrapped class

[jeengbe]

I have a class domain class Model and a WithId[M] that wraps a domain class with metadata such as id, revision, createdAt, etc.

Let A be the model class and WithB[X] the wrapper class with:

//> using dep io.scalaland::chimney::0.8.3

import io.scalaland.chimney.dsl.*

case class A(a: String)

case class WithB[X](b: String, x: X)

case class C(a: String, b: String)

WithB("b", A("a")).transformInto[C]

I understand that Chimney by itself can't (and shouldn't) resolve a on WithB[A], but I can't find a way to write an appropriate Transformer given that works for all X.

---

Changing

case class WithB[X](b: String, x: X)

to

case class WithB[X](b: String, x: X):
  export x.*

while technically exposing all fields, isn't accepted either.

---

I am relatively new to Scala, please let me know if the above WithId[X] pattern is a nono, and possibly what a better solution is.

[MateuszKubuszok]

Currently the only way to combine values from 2 levels of nesting is:

• to select one of them as the main source of values
• connect values from the other level of nesting manually

//> using dep io.scalaland::chimney::0.8.3
import io.scalaland.chimney.dsl.*

case class A(a: String)
case class WithB[X](b: String, x: X)
case class C(a: String, b: String) // I modified this for this example, see below

// WithB[A] as the "main" object
WithB("b", A("a")).into[C].withFieldComputed(_.a, _.x.a).transform
// or A as the "main" object
val withB = WithB("b", A("a")) 
withB.x.into[C].withFieldConst(_.b, withB.b).transform

Handling it magically OOTB is not in the scope ever (since the compilation time would explode if the macro would try to randomly traverse the whole tree of values until some matching field would be found), but pointing Chimney which 2 values could be (recursively) merged was already requested in #115 and in #208. Then it would be possible to write something like

val withB = WithB("b", A("a"))
// From what I understand .x seem to have majority of the fields necessary
withB.x.into[C].withFallbackTo(withB).transform

but this functionality is rather complex (since it would have to recursively merge 2 values, not just the first layer) and is unlikely to be implemented anytime soon.

Another issue with your code is that withB.b is of type String and C expects Int so some conversion or manual computations have to be provided: implicit Transformer[String, Int], .withFieldConst, .withFieldComputed, etc. Additionally, since String to Int conversion is fallible I'd rather used PartialTransformers:

//> using dep io.scalaland::chimney::0.8.3
import io.scalaland.chimney.dsl.*

case class A(a: String)
case class WithB[X](b: String, x: X)
case class C(a: String, b: Int)

// PartialTransformer handles None, Exceptions, etc
WithB("b", A("a"))
  .intoPartial[C] 
  .withFieldComputed(_.a, _.x.a)
  .withFieldComputed(_.b, _.b.toInt)
  .transform
// or
val withB = WithB("b", A("a"))
withB.x.intoPartial[C]
  .withFieldComputed(_.b, _ => withB.b.toInt)
  .transform

I am assuming that this is just the demo, showing the issue, but if there would be real use case with such a ratio of generated code to the required customization I might have converted the code by hand.

Ideally, in the future (after #115), if WithB would be often used and every use case had the same String to Int conversion (or whatever types are actually there) it would be possible to do:

// catches Exceptions from .toInt
implicit val stringToInt: PartialTransformer[String, Int] =
  PartialTransformer.fromFunction(str => str.toInt)

val withB = WithB("b", A("a"))
withB.x.intoPartial[C].withFallbackTo(withB).transform

but with the current functionalities Chimney requires providing at least .b field manually AND providing a way of converting String to Int somehow.

[jeengbe]

This seems to be the best solution for now, then, thank you for your answer!

// or A as the "main" object
val withB = WithB("b", A("a")) 
withB.x.into[C].withFieldConst(_.b, withB.b).transform

C#b was indeed supposed to be a string, that error must have arisen during revisions of the snippet. I've updated the code in the main discussion accordingly.

[jeengbe]

There is no way this worked this smoothly, this library is insane

It would be nice, however, if withFieldConst also were able to do transformations out of the box.

My domain WithId[M] has a field updatedAt: java.time.Instant, however, the protobuf class has updatedAt: Option[com.google.protobuf.timestamp.Timestamp], so the line:

.withFieldConst(
  _.createdAt,
  thing.createdAt
)

(correctly) gives

Cannot prove that java.time.Instant <:< Option[com.google.protobuf.timestamp.Timestamp].

and requires instead:

.withFieldConst(
  _.createdAt,
  account.createdAt
    .transformInto[Option[protobuf.timestamp.Timestamp]]
)

[MateuszKubuszok]

Well, this is rather rare, having to use external objects to set them in withFieldConst while also converting them. You might check if inference would figure that out:

.withFieldConst(_.createdAt, account.createdAt.transformInto)

If it could be taken from the original object, you could have used something like:

.withFieldRenamed(
  _.createdAt,
  _.something.account.createdAt
)