Allow `CasterFactory`/`SerializerFactory` to read `CastWith`/`SerializeWith` attributes from interfaces

[oruborus]

Description

When casting or serializing propertys that are typed to an interface the CasterFactory/SerializerFactory do not read the CastWith/SerializeWith attributes from interfaces definition.

As I see it, changes (if ($*With === null && ($type->isClass() || $type->isInterface())) {) need to be made here:

tempest-framework/packages/mapper/src/CasterFactory.php

Line 64 in e26572b

if ($castWith === null && $type->isClass()) {

and here:

tempest-framework/packages/mapper/src/SerializerFactory.php

Line 67 in e26572b

if ($serializeWith === null && $type->isClass()) {

Benefits

Less need for adding CastWith/SerializeWith attributes to properties typed to interfaces and more getting out of the way.

[innocenzi]

Hey, maybe I'm misunderstanding what you are trying to solve here, but aren't you looking for custom mappers?

https://tempestphp.com/2.x/features/mapper#custom-mappers

[oruborus]

Hey, maybe I'm misunderstanding what you are trying to solve here, but aren't you looking for custom mappers?

https://tempestphp.com/2.x/features/mapper#custom-mappers

I was serializing some very similar types (hence the interface) and thaught it would be cool to just apply the attributes to the interface and use one generalized serializor.

[innocenzi]

Could you show me some code so I understand a bit better your use case?

[xHeaven]

Could you show me some code so I understand a bit better your use case?

I think it's the difference between this:

#[CastWith(MoneyCaster::class)]
interface MoneyInterface
{
    public function getAmount(): int;
    public function getCurrency(): string;
}

final readonly class Money implements MoneyInterface
{
    public function __construct(
        private int $amount,
        private string $currency,
    ) {}

    public function getAmount(): int => $this->amount;
    public function getCurrency(): string => $this->currency;
}

final class MoneyCaster implements Caster
{
    public function cast(mixed $input): MoneyInterface
    {
        [$amount, $currency] = explode(' ', $input);
        return new Money((int) $amount, $currency);
    }
}

final readonly class Order
{
    public function __construct(
        public string $id,
        #[CastWith(MoneyCaster::class)]  // <-- CastWith on prop
        public MoneyInterface $total,
    ) {}
}

final readonly class Invoice
{
    public function __construct(
        public string $id,
        #[CastWith(MoneyCaster::class)]  // <-- CastWith on prop
        public MoneyInterface $amount,
        #[CastWith(MoneyCaster::class)]  // <-- CastWith on prop again
        public MoneyInterface $tax,
    ) {}
}

and this:

#[CastWith(MoneyCaster::class)]  // <-- defined on interface
interface MoneyInterface
{
    public function getAmount(): int;
    public function getCurrency(): string;
}

final readonly class Money implements MoneyInterface
{
    public function __construct(
        private int $amount,
        private string $currency,
    ) {}

    public function getAmount(): int => $this->amount;
    public function getCurrency(): string => $this->currency;
}

final class MoneyCaster implements Caster
{
    public function cast(mixed $input): MoneyInterface
    {
        [$amount, $currency] = explode(' ', $input);
        return new Money((int) $amount, $currency);
    }
}

final readonly class Order
{
    public function __construct(
        public string $id,
        public MoneyInterface $total,  // <-- no extra attribute
    ) {}
}

final readonly class Invoice
{
    public function __construct(
        public string $id,
        public MoneyInterface $amount,  // <-- no extra attribute
        public MoneyInterface $tax,     // <-- no extra attribute
    ) {}
}

[innocenzi]

Right, definitely makes sense, thank you

[oruborus]

I think it's the difference between this:

...

Yes, exactly. Thank you for clearing that up for me 🥇