Hi guys, topic of transforming domain objects into Dto (or enything else), I know I can do something like:

class Something(val name: String) {
    companion object {
        fun toDto(): Dto(name)
    }
}

data class Dto(val name: String)

But I would prefer to have possibility to write:

Dto.from(foo: Something) = Dto(name = foo.name)

Is it possible?

you mean you don't want companion object in Dto?

I would prefer to avoid companion object on Dto, if possible

fun Something.toDto() = Dto(this.name)

?

But this looks like I am adding some functionality to the domain object, which at first glance looks like breaking the principles

well I would go with companion object. maybe take a look at https://kt.academy/article/ek-factory-functions

Companion object on the

Dto

or

Something

Dto

You can also declare extensions on the companion but outside the class itself:

fun Dto.Companion.from(..)

The problem may be when having multimodule app, whith mediator module that would bind together Domain (containing domain classes) and API (containing dtoS). API will not know about domain, thus would not be possible to add mappiing from domain to dto inside of companion object of DTO

The point was to extend the companion object of the Dto class but not declare that function in the class (so you can declare this outside the module)

aha!

in mediator you also have to have some contract right?

right

and it either can be domain or some 3rd object, right?

Correct, yes

I remember having to write an empty companion at some point, but I thought they intended to remove this constraint. Maybe it's still necessary 😕 I also don't like those empty companions to be frank. If it's still necessary, I'd rather go for the regular extension the other way around without companion:

fun Domain.toDto(): Dto

This actually seems to be a convention in Kotlin, when checking Boolean implementation (there is an empty companion object too)

This begs the question though, why do you dislike the

toDto()

version so much?

The reason is the domain object in this particular case is being translated into multiple different DTOs. In consequence, having:

dto: SomeDto = domain.toDto()
dto: SomeOtherDto = domain.toDto()
dto: YetAnotherDto = domina.toDto()

which reads worse than

dto = SomeDto.from(domain)
dto = SomeOtherDto.from(domain)
dto = YetAnotherDto.from(domain)

That would look really nice to me:

val dto = domain.toSomeDto()
val dto = domain.toSomeOtherDto()
val dto = domain.toYetAnotherDto()

It goes in line with Kotlin's

String.toInt()

and the likes. And it also reads nicer (IMO) when chained, especially with nullable values:

val dto = something.getSomeDomainEntitySomehow()?.toSomeDto()

As opposed to:

val dto = someting.getSomeDomainEntitySomehow()?.let { SomeDto.from(it) }

Yes, those are good points, but some of those transformation may need additional information, which would made it

domain.toSomeDto(other: Info)

vs

SomeDto.from(domain, other)

which IMHO reads easier in the way of understanding how

someDto

composed

If the resulting DTO is an aggregation of data from the domain and from the extra params, and the other info is as important as the one from the domain, then I can see your point. The factory function might be better in this case. However, if the extra info is just a side thing, or information about how to transform from domain to DTO, I would still go for the

toDto(extra info)

variant, like

toInt(radix)

. It always boils down to the message you want to convey, I'll let you judge of that 🙂

That was very nice discussion and interesting points mentioned, thank you 🙂