User.php

<?php

declare(strict_types=1);

namespace Example\Basic;

class User
{
    /**
     * Schema used to validate input for creating instances of this class
     *
     * @var array
     */
    private static array $_schema = ['type' => 'object', 'required' => ['name', 'status'], 'properties' => ['name' => ['type' => 'string'], 'address' => ['$ref' => '#/definitions/Address'], 'status' => ['anyOf' => [['enum' => ['customer', 'manager'], 'type' => 'string'], ['type' => 'null']]]], 'definitions' => ['Address' => ['type' => 'object', 'properties' => ['street' => ['type' => 'string'], 'house' => ['type' => 'integer']]]]];

    private string $name;

    private ?Address $address = null;

    /**
     * @var 'customer'|'manager'|null
     */
    private ?string $status;

    /**
     * @param 'customer'|'manager'|null $status
     */
    public function __construct(string $name, ?string $status, ?Address $address = null)
    {
        $this->name = $name;
        $this->status = $status;
        $this->address = $address;
    }

    /**
     * Name of the user - required field.
     */
    public function getName(): string
    {
        return $this->name;
    }

    /**
     * Name of the user - required field.
     */
    public function withName(string $name): self
    {
        $clone = clone $this;
        $clone->name = $name;

        return $clone;
    }

    /**
     * Object representing address of the user, field is optional.
     */
    public function getAddress(): ?Address
    {
        return $this->address;
    }

    /**
     * Object representing address of the user, field is optional.
     */
    public function withAddress(Address $address): self
    {
        $clone = clone $this;
        $clone->address = $address;

        return $clone;
    }

    public function withoutAddress(): self
    {
        $clone = clone $this;
        unset($clone->address);

        return $clone;
    }

    /**
     * User status. Field is obligatory, but nullable.
     *
     * If target PHP is 8.1+ the type will be an `enum` with cases `CUSTOMER = 'customer'` and `MANAGER = 'manager'`
     *
     * @return 'customer'|'manager'|null
     */
    public function getStatus(): ?string
    {
        return $this->status;
    }

    /**
     * User status. Field is obligatory, but nullable.
     *
     * If target PHP is 8.1+ the type will be an `enum` with cases `CUSTOMER = 'customer'` and `MANAGER = 'manager'`
     *
     * @param 'customer'|'manager'|null $status
     */
    public function withStatus(?string $status, bool $validate = true): self
    {
        if ($validate) {
            $validator = new \JsonSchema\Validator();
            $validator->validate($status, self::$_schema['properties']['status']);
            if (!$validator->isValid()) {
                throw new \InvalidArgumentException($validator->getErrors()[0]['message']);
            }
        }

        $clone = clone $this;
        $clone->status = $status;

        return $clone;
    }

    /**
     * Builds a new instance from an input array or object
     *
     * @param array|object $input Input data
     * @param bool $validate If `false`, validation against the schema will be skipped.
     * @return User Created instance
     * @throws \InvalidArgumentException
     */
    public static function fromInput($input, bool $validate = true): User
    {
        if (!is_array($input) && !is_object($input)) {
            throw new \InvalidArgumentException(
                'Input to fromInput must be array or object, got ' . gettype($input)
            );
        }

        $input = is_array($input) ? \JsonSchema\Validator::arrayToObjectRecursive($input) : $input;
        if ($validate) {
            static::validateInput($input);
        }

        $name = $input->{'name'};
        $status = ($input->{'status'} !== null ? $input->{'status'} : null);
        $address = isset($input->{'address'}) ? Address::fromInput($input->{'address'}, $validate) : null;

        $obj = new self($name, $status, $address);
        return $obj;
    }

    /**
     * Converts this object back to a simple array that can be JSON-serialized
     *
     * @return array Converted array
     */
    public function toArray(): array
    {
        $output = [];
        $output['name'] = $this->name;
        if (isset($this->address)) {
            $output['address'] = $this->address->toArray();
        }
        $output['status'] = $this->status;

        return $output;
    }

    /**
     * Converts this object to a stdClass that can be JSON-serialized
     *
     * @return \stdClass Converted object
     */
    public function toStdClass(): \stdClass
    {
        $output = new \stdClass();
        $output->{'name'} = $this->name;
        if (isset($this->address)) {
            $output->{'address'} = $this->address->toStdClass();
        }
        $output->{'status'} = $this->status;

        return $output;
    }

    /**
     * Validates an input array
     *
     * @param array|object $input Input data
     * @param bool $return Return instead of throwing errors
     * @return bool Validation result
     * @throws \InvalidArgumentException
     */
    public static function validateInput($input, bool $return = false): bool
    {
        $validator = new \JsonSchema\Validator();
        $input = is_array($input) ? \JsonSchema\Validator::arrayToObjectRecursive($input) : $input;
        $validator->validate($input, self::$_schema);

        if (!$validator->isValid() && !$return) {
            $errors = array_map(function(array $e): string {
                return ($e["property"] ? $e["property"] . ": " : "") . $e["message"];
            }, $validator->getErrors());
            throw new \InvalidArgumentException(join(".\n", $errors));
        }

        return $validator->isValid();
    }
}