Abstract Item

AbstractItem

This class provide an abstract "item" that you can add to your collections. Instead of writing and defining all the properties and respective getters/setters of your objects this class provides an easy way to achieve that by using PHP's __call method to magically provide those getters and setters.

Since many of the times we are building those objects based on data collected from some source (usually getting it in an array) this abstract class also provides a way to "build" your instances based on array data.

The basic structure of a class extending this is the following:

<?php
declare(strict_types=1);

final class MyItem extends AbstractItem
{
    protected const PROPERTIES = [
        'id',
        'name',
        'createdAt'
        'simpleName',
        'verified',
        'industryId',
    ];

    public function __construct()
    {
        parent::__construct(['createdAt' => new DateTime()]);
    }

    protected static function getBuilders(): array
    {
        return [
            'id'        => static fn(array $data): ?int => $data['id'] ?? null,
            'name'      => static fn(array $data): ?string => $data['name'] ?? null,
            'createdAt' => static fn(array $data)? DateTime => $data['createdAt'] ?? null,
            'simpleName' => self::buildStringGetter('simpleName'),
            'verified'   => self::buildBoolGetter('verified'),
            'industryId' => self::buildIntGetter('industryId'),
        ];
    }
}

Defining the properties

Looking at the snippet above one must define which properties our class will hold. So override the constant PROPERTIES and these will be the properties available.

Naming conventions for setters and getters

Based on the properties defined on your subclass the class will accept calls to each of them with the format:

Field: myField

Setter: $item->setMyField($value);

Getter: $value = $item->getMyField()

If you want to use different prefixes for setters/getters you can! Just override the SETTER_PREFIX and/or GETTER_PREFIX constants.

Example:

<?php
declare(strict_types=1);

final class MyItem extends AbstractItem
{
    protected const PROPERTIES = [
        'id',
        'name',
        'createdAt'
    ];

    protected const SETTER_PREFIX = 'change';
    protected const GETTER_PREFIX = '';
}

Field: myField

Setter: $item->changeMyField($value);

Getter: $value = $item->myField()

Initialization

By default, the abstract class can receive an array that will be used to populate the properties. If we want we can override the constructor and pass some of the default values to the parent.

Code hints

Since all the setters/getters are "magic" we might feel the need to have code hints. Just declare PHPDoc blocks in your class.

Example:

<?php
declare(strict_types=1);

/**
 * @method int|null getId()
 * @method string|null getName()
 * @method DateTime|null getCreatedAt()
 * @method string|null getExtraFieldNotUsedInBuild()
 * @method MyItem setId(?int $id)
 * @method MyItem setName(?string $name)
 * @method MyItem setCreatedAt(?DateTime $createdAt)
 */
final class MyItem extends AbstractItem
{
    protected const PROPERTIES = [
        'id',
        'name',
        'createdAt'
    ];
}

Builders

As said above the class can help you to build your instances from data stored in arrays. Every subclass will have the method build.

<?php
declare(strict_types=1);

/**
 * @param array $data
 *
 * @return static
 */
public static function build(array $data): self;

But in order for it to work your subclass must implement the getBuilders static method.

This method will basically return a map of 'property' => callable to get data for the property:

[
    'itemProperty' => static fn(array $data): mixed => $valueForTheProperty,
]