mirror of
https://github.com/danog/Valinor.git
synced 2024-12-12 09:09:38 +01:00
90dc586018
The mapper is now more type-sensitive and will fail in the following
situations:
- When a value does not match exactly the awaited scalar type, for
instance a string `"42"` given to a node that awaits an integer.
- When unnecessary array keys are present, for instance mapping an array
`['foo' => …, 'bar' => …, 'baz' => …]` to an object that needs only
`foo` and `bar`.
- When permissive types like `mixed` or `object` are encountered.
These limitations can be bypassed by enabling the flexible mode:
```php
(new \CuyZ\Valinor\MapperBuilder())
->flexible()
->mapper();
->map('array{foo: int, bar: bool}', [
'foo' => '42', // Will be cast from `string` to `int`
'bar' => 'true', // Will be cast from `string` to `bool`
'baz' => '…', // Will be ignored
]);
```
When using this library for a provider application — for instance an API
endpoint that can be called with a JSON payload — it is recommended to
use the strict mode. This ensures that the consumers of the API provide
the exact awaited data structure, and prevents unknown values to be
passed.
When using this library as a consumer of an external source, it can make
sense to enable the flexible mode. This allows for instance to convert
string numeric values to integers or to ignore data that is present in
the source but not needed in the application.
---
All these changes led to a new check that runs on all registered object
constructors. If a collision is found between several constructors that
have the same signature (the same parameter names), an exception will be
thrown.
```php
final class SomeClass
{
public static function constructorA(string $foo, string $bar): self
{
// …
}
public static function constructorB(string $foo, string $bar): self
{
// …
}
}
(new \CuyZ\Valinor\MapperBuilder())
->registerConstructor(
SomeClass::constructorA(...),
SomeClass::constructorB(...),
)
->mapper();
->map(SomeClass::class, [
'foo' => 'foo',
'bar' => 'bar',
]);
// Exception: A collision was detected […]
```
130 lines
3.6 KiB
Markdown
130 lines
3.6 KiB
Markdown
# Construction strategy
|
|
|
|
During the mapping, instances of objects are recursively created and hydrated
|
|
with transformed values. Construction strategies will determine what values are
|
|
needed and how an object is built.
|
|
|
|
## Native constructor
|
|
|
|
If a constructor exists and is public, its arguments will determine which values
|
|
are needed from the input.
|
|
|
|
```php
|
|
final class SomeClass
|
|
{
|
|
public function __construct(
|
|
public readonly string $foo,
|
|
public readonly int $bar,
|
|
) {}
|
|
}
|
|
```
|
|
|
|
## Custom constructor
|
|
|
|
An object may have custom ways of being created, in such cases these
|
|
constructors need to be registered to the mapper to be used. A constructor is a
|
|
callable that can be either:
|
|
|
|
1. A named constructor, also known as a static factory method
|
|
2. The method of a service — for instance a repository
|
|
3. A "callable object" — a class that declares an `__invoke` method
|
|
4. Any other callable — including anonymous functions
|
|
|
|
In any case, the return type of the callable will be resolved by the mapper to
|
|
know when to use it. Any argument can be provided and will automatically be
|
|
mapped using the given source. These arguments can then be used to instantiate
|
|
the object in the desired way.
|
|
|
|
Registering any constructor will disable the native constructor — the
|
|
`__construct` method — of the targeted class. If for some reason it still needs
|
|
to be handled as well, the name of the class must be given to the
|
|
registration method.
|
|
|
|
If several constructors are registered, they must provide distinct signatures to
|
|
prevent collision during mapping — meaning that if two constructors require
|
|
several arguments with the exact same names, the mapping will fail.
|
|
|
|
```php
|
|
(new \CuyZ\Valinor\MapperBuilder())
|
|
->registerConstructor(
|
|
// Allow the native constructor to be used
|
|
Color::class,
|
|
|
|
// Register a named constructor (1)
|
|
Color::fromHex(...),
|
|
|
|
/**
|
|
* An anonymous function can also be used, for instance when the desired
|
|
* object is an external dependency that cannot be modified.
|
|
*
|
|
* @param 'red'|'green'|'blue' $color
|
|
* @param 'dark'|'light' $darkness
|
|
*/
|
|
function (string $color, string $darkness): Color {
|
|
$main = $darkness === 'dark' ? 128 : 255;
|
|
$other = $darkness === 'dark' ? 0 : 128;
|
|
|
|
return new Color(
|
|
$color === 'red' ? $main : $other,
|
|
$color === 'green' ? $main : $other,
|
|
$color === 'blue' ? $main : $other,
|
|
);
|
|
}
|
|
)
|
|
->mapper()
|
|
->map(Color::class, [/* … */]);
|
|
|
|
final class Color
|
|
{
|
|
/**
|
|
* @param int<0, 255> $red
|
|
* @param int<0, 255> $green
|
|
* @param int<0, 255> $blue
|
|
*/
|
|
public function __construct(
|
|
public readonly int $red,
|
|
public readonly int $green,
|
|
public readonly int $blue
|
|
) {}
|
|
|
|
/**
|
|
* @param non-empty-string $hex
|
|
*/
|
|
public static function fromHex(string $hex): self
|
|
{
|
|
if (strlen($hex) !== 6) {
|
|
throw new DomainException('Must be 6 characters long');
|
|
}
|
|
|
|
/** @var int<0, 255> $red */
|
|
$red = hexdec(substr($hex, 0, 2));
|
|
/** @var int<0, 255> $green */
|
|
$green = hexdec(substr($hex, 2, 2));
|
|
/** @var int<0, 255> $blue */
|
|
$blue = hexdec(substr($hex, 4, 2));
|
|
|
|
return new self($red, $green, $blue);
|
|
}
|
|
}
|
|
```
|
|
|
|
1. …or for PHP < 8.1:
|
|
|
|
```php
|
|
[Color::class, 'fromHex'],
|
|
```
|
|
|
|
## Properties
|
|
|
|
If no constructor is registered, properties will determine which values are
|
|
needed from the input.
|
|
|
|
```php
|
|
final class SomeClass
|
|
{
|
|
public readonly string $foo;
|
|
|
|
public readonly int $bar;
|
|
}
|
|
```
|