CurrencyProvider?

[francislavoie]

We have some currencies like BTC which are treated "equally" to other currencies in our database -- it would be nice if instead of needing to make a new Currency when making a Money, I could instead configure a currency provider globally (extending the ISO one) so I could instead just do Money::of('0.123', 'BTC').

Of course I feel dirty recommending any global state, but I'm not sure how else it could be implemented 🤔

[BenMorel]

Hi, this has been discussed to some extent in #5.

I know this is a common requirement, however as you guessed, I’m against any type of global state... Maybe your best bet is to create a MoneyFactory that would replicate the of() and ofMinor() factory methods, while transparently accepting custom currency codes?

I'm actually thinking that this MoneyFactory could be provided by the library; you’d only have to implement a CurrencyProvider that takes a currency code and returns a Currency instance. Here is how it would look like:

class MyCurrencyProvider implements CurrencyProvider
{
    public function getCurrency($currencyCode): Currency
    {
        switch ($currencyCode) {
            case 'BTC':
                return new Currency(...);

            // ... other currencies as required
        }

        // handle ISO currencies as normal

        return ISOCurrencyProvider::getInstance()->getCurrency($currencyCode);
    }
}

$factory = new MoneyFactory(new MyCurrencyProvider);

$money = $factory->of('0.0123', 'BTC'); // use this instead of Money::of()

Would this work for you?

[francislavoie]

Yeah! That's pretty good. MoneyFactory could easily be dependency injected etc. I like it.

[BenMorel]

I actually gave it a shot, but I feel like this MoneyFactory does not bring much value:

final class MoneyFactory
{
    /**
     * @var CurrencyProvider
     */
    private $currencyProvider;

    /**
     * @param CurrencyProvider $currencyProvider
     */
    public function __construct(CurrencyProvider $currencyProvider)
    {
        $this->currencyProvider = $currencyProvider;
    }

    public function of($amount, $currency, ?Context $context = null, int $roundingMode = RoundingMode::UNNECESSARY) : Money
    {
        if (! $currency instanceof Currency) {
            $currency = $this->currencyProvider->getCurrency($currency);
        }

        return Money::of($amount, $currency, $context, $roundingMode);
    }

    public function ofMinor($minorAmount, $currency, ?Context $context = null, int $roundingMode = RoundingMode::UNNECESSARY) : Money
    {
        if (! $currency instanceof Currency) {
            $currency = $this->currencyProvider->getCurrency($currency);
        }

        return Money::ofMinor($minorAmount, $currency, $context, $roundingMode);
    }
}

Sure, it allows you to do:

$money = $factory->of('0.0123', 'BTC');

But is it much better than this?

$money = Money::of('0.0123', $currencyProvider->getCurrency('BTC'));

[BenMorel]

Another option could be to pass the CurrencyProvider to of(), but the method is already bloated:

$money = Money::of('0.0123', 'BTC', null, RoundingMode::UNNECESSARY, $currencyProvider);

[francislavoie]

Another advantage to the factory is that you could specify a different default context or rounding mode for all monies being created - for example I think I'd want to always use HALF_UP rounding for all the monies in a particular part of my app.

$factory = (new MoneyFactory)
	->withCurrencyProvider($provider)
	->withRoundingMode(RoundingMode::HALF_UP);
$money = $factory->of('0.0123', 'BTC');

[BenMorel]

Interesting idea, though using a default rounding mode potentially means that you change the MoneyFactory::of() signature to not include a RoundingMode? Or make it nullable, so that it defaults to the one configured in the factory.

This may work, but I'm not sure if I see a value in using a default rounding mode!

[francislavoie]

Fair enough - I can always just set up the factory idea in my own project if it's not shipped with the library 🙂

[BenMorel]

I pushed a proof of concept here: 62f7eea

Comments welcome.

[francislavoie]

Nice. I like it.

Did you consider the withCurrencyProvider approach instead of making the constructor params nullable? I could imagine someone would want to override the context but not the currencies or rounding, etc. With "withers", you could just set up any combination of those 3 things without say, needing to pass null for one or more of the params.

[BenMorel]

I did, actually. Would you expect this to return a new instance?

[francislavoie]

🤔 I don't think it would need to, as a factory. I think return $this; fluent interface is appropriate for this. I don't think the withers for this sort of factory needs to be immutable.

[Big-Shark]

@BenMorel @francislavoie What do you think about this api

ISOCurrencyProvider::getInstance()->addCurrency(new Currency(
    'XBT',     // currency code
    0,         // numeric currency code, useful when storing monies in a database; set to 0 if unused
    'Bitcoin', // currency name
    8          // default scale
));

// And 
Money::of('0.0123', 'BTC);

or we can create AggregateCurrencyProvider and use something like that

AggregateCurrencyProvider::getInstance()->addCurrencyProvider(new CryptocurrencyProvider());

and use AggregateCurrencyProvider in currency class, but we will need ISOCurrencyProvider in constructorby default

[BenMorel]

@Big-Shark That's creating a global context, which is usually bad (ISOCurrencyProvider is fine, as it's immutable).

You'll want to pass your CurrencyProvider around instead, probably using your DI container.

[Big-Shark]

@BenMorel yes, but when we will use MoneyFactory we need to use DI for creating VO, and we can not use this in entity.
We need thinking, how we can use same api for iso currency, and cryptocurrency in one project.

[BenMorel]

@Big-Shark There is no way around the fact that you cannot have Money::of(1, 'BTC'); in your code without relying on a global context. A global currency provider is bad, as Money may be used in your app, but also in libraries etc., and conflicts may occur.

The only possible solution is a factory and DI. And if you need to instantiate a custom currency from within a value object, you need to refactor it so that the VO method accepts a Currency instance instead of a currency code, or takes the factory as a parameter.