Add EntityValidationSubscriber, ColumnValidator and inherited attributes

Author: WinterSilence

README.md

@@ -1,15 +1,19 @@
 ## Entity validator for Doctrine ORM 3
 
-By default, entity validation based on attached `\Doctrine\ORM\Mapping\Column` attributes.
+[![Latest Stable Version](https://img.shields.io/packagist/v/ensostudio/doctrine-entity-validator.svg)](https://packagist.org/packages/ensostudio/doctrine-entity-validator)
+[![Total Downloads](https://img.shields.io/packagist/dt/ensostudio/doctrine-entity-validator.svg)](https://packagist.org/packages/ensostudio/doctrine-entity-validator)
 
-Also, you can add custom validators by `EntityValidator::addValidator()`.
+By default, entity validation based on attached `\Doctrine\ORM\Mapping\Column` attributes and attributes inherited
+[ColumnValidator](src/ColumnValidators/ColumnValidator.php) interface.
+
+Also, you can add custom validators by `EntityValidator::addValidator()` or create instance of [ColumnValidator](src/ColumnValidators/ColumnValidator.php) interface.
 
 Validator skip validation:
 - If `Column` attribute declared as not `updatable` and/or `insertable`
 - Validation on persist/insert and property have `\Doctrine\ORM\Mapping\Id` attribute
 
-Validator checks:
-- If property value is null (or not defined), but `Column` attribute not declared as `nullable` or don't have default value (`options: ['default' => '...']`)
+Validator checks by column type:
+- If property value is null (or not defined), but `Column` attribute not declared as `nullable` or/and don't have default value (`options: ['default' => '...']`)
 - If `Column` attribute have **numeric** type (integer, float, decimal and etc.):
   - If defined `unsigned` option, then property value must be more than zero
   - If type `decimal` and defined `precision`, then check size of value
@@ -19,13 +23,25 @@ Validator checks:
 - If `Column` attribute have **enum** type:
   - If defined `enumType`, then check is proprerty value is declared in enum class
 
-## Example
+`ColumnValidator` attributes:
+- [MinLength](src/ColumnValidators/MinLength.php)
+- [Greater](src/ColumnValidators/Greater.php)
+- [Number](src/ColumnValidators/Number.php)
+- [Regexp](src/ColumnValidators/Regexp.php)
+- [Filter](src/ColumnValidators/Filter.php)
+- [Slug](src/ColumnValidators/Slug.php)
+- [Ip](src/ColumnValidators/Ip.php)
+- [Url](src/ColumnValidators/Url.php)
+- [Email](src/ColumnValidators/Email.php)
+
+## Examples
 
 Validates `Product` entity before insert/update data:
 
 ```php
 use Doctrine\DBAL\Types\Types;
 use Doctrine\ORM\Mapping as ORM;
+use \EnsoStudio\Doctrine\ORM\ColumnValidators;
 use EnsoStudio\Doctrine\ORM\EntityValidator;
 use EnsoStudio\Doctrine\ORM\EntityValidationException;
 
@@ -36,19 +52,25 @@ class Product
 {
     ...
 
-    #[ORM\Column(type: Types::STRING, length: 255)]
+    #[ORM\Column(type: Types::STRING, length: 200)]
+    #[ColumnValidators\MinLength(2)]
+    #[ColumnValidators\Slug]
+    private string $slug;
+
+    #[ORM\Column(type: Types::STRING, length: 150)]
     private string $name;
 
     #[ORM\PrePersist]
     public function beforeInsert(): void
     {
         $validator = new EntityValidator($this);
+        // Callback same to ColumnValidators\MinLength(3)
         $validator->addValidator(
             'name', 
-            static function (mixed $propertyValue, string $propertyName, object $entity) {
+            static function (string $propertyValue, string $propertyName, object $entity) {
                 if (mb_strlen($propertyValue) < 3) {
                     throw new EntityValidationException(
-                        ['% less than 3 chars', $propertyName],
+                        ['% less than 3 characters', $propertyName],
                         $propertyName,
                         $entity
                     );
@@ -66,4 +88,32 @@ class Product
         $validator->validate(true);
     }
 }
+```
+
+Or you can use `EntityValidationSubscriber` to validates all entities:
+
+```php
+use Doctrine\ORM\EntityManager;
+use EnsoStudio\Doctrine\ORM\EntityValidationSubscriber;
+
+...
+$entityManager = new EntityManager($connection, $config);
+$entityManager->getEventManager()
+    ->addEventSubscriber(new EntityValidationSubscriber(true));
+```
+
+## Requirements
+
+- PHP >= 8.1 (with `mbstring` extension)
+- doctrine/orm >= 3.3
+
+## Installation
+
+If you do not have Composer, you may install it by following the instructions at
+[getcomposer.org](https://getcomposer.org/doc/00-intro.md#introduction).
+
+You can then install this library using the following command:
+
+```shell
+composer require ensostudio/doctrine-entity-validator
 ```

composer.json

@@ -14,6 +14,7 @@
   ],
   "require": {
     "php": ">=8.1",
+    "ext-mbstring": "*",
     "doctrine/orm": "^3.3.2"
   },
   "require-dev": {

src/ColumnValidators/ColumnValidator.php

@@ -0,0 +1,25 @@
+<?php
+
+namespace EnsoStudio\Doctrine\ORM\ColumnValidators;
+
+use Attribute;
+
+/**
+ * Attribute to validate property/column value of entity.
+ *
+ * @property-read bool $onPersist If true, validates column on persist/insert entity
+ * @property-read bool $onUpdate If true, validates column on update entity
+ */
+#[Attribute(Attribute::TARGET_PROPERTY | Attribute::IS_REPEATABLE)]
+interface ColumnValidator
+{
+    /**
+     * Validates property value.
+     *
+     * @param mixed $propertyValue The property value
+     * @param string $propertyName The property name
+     * @param object $entity The target entity
+     * @throws \EnsoStudio\Doctrine\ORM\EntityValidationException If validation failed
+     */
+    public function validate(mixed $propertyValue, string $propertyName, object $entity): void;
+}

src/ColumnValidators/Email.php

@@ -0,0 +1,37 @@
+<?php
+
+namespace EnsoStudio\Doctrine\ORM\ColumnValidators;
+
+use EnsoStudio\Doctrine\ORM\EntityValidationException;
+
+/**
+ * Validates whether the column value is a "valid" e-mail address.
+ *
+ * The validation is performed against the addr-spec syntax in RFC 822. However, comments, whitespace folding, and
+ * dotless domain names are not supported, and thus will be rejected.
+ */
+class Email implements ColumnValidator
+{
+    /**
+     * @param bool $unicode Accepts Unicode characters in the local part
+     * @param string $message The template of error message in format `sprintf()`
+     * @param bool $onPersist If true, validates column on persist entity
+     * @param bool $onUpdate If true, validates column on update entity
+     */
+    public function __construct(
+        public readonly bool $unicode = false,
+        public readonly string $message = '%s: is invalid e-mail address',
+        public readonly bool $onPersist = true,
+        public readonly bool $onUpdate = true
+    ) {
+    }
+
+    public function validate(mixed $propertyValue, string $propertyName, object $entity): void
+    {
+        $options = $this->unicode ? FILTER_FLAG_EMAIL_UNICODE : 0;
+
+        if (filter_var($propertyValue, FILTER_VALIDATE_EMAIL, $options) === false) {
+            throw new EntityValidationException([$this->message, $propertyName], $propertyName, $entity);
+        }
+    }
+}

src/ColumnValidators/Filter.php

@@ -0,0 +1,50 @@
+<?php
+
+namespace EnsoStudio\Doctrine\ORM\ColumnValidators;
+
+use EnsoStudio\Doctrine\ORM\EntityValidationException;
+
+/**
+ * Validates column value using `filter_var()`.
+ */
+class Filter implements ColumnValidator
+{
+    public const FILTERS = [
+        'int' => FILTER_VALIDATE_INT,
+        'float' => FILTER_VALIDATE_FLOAT,
+        'regexp' => FILTER_VALIDATE_REGEXP,
+        'url' => FILTER_VALIDATE_URL,
+        'domain' => FILTER_VALIDATE_DOMAIN,
+        'email' => FILTER_VALIDATE_EMAIL,
+        'ip' => FILTER_VALIDATE_IP,
+        'mac' => FILTER_VALIDATE_MAC
+    ];
+
+    /**
+     * @param int $filter The ID of the validation filter to use, `FILTER_VALIDATE_...` constant
+     * @param array<string, mixed> $options The options of validation filter
+     * @param int $flags The bitwise disjunction of filter flags
+     * @param string $message The template of error message in format `sprintf()`
+     * @param bool $onPersist If true, validates column on persist entity
+     * @param bool $onUpdate If true, validates column on update entity
+     * @see self::FILTERS Get filter ID by short name
+     */
+    public function __construct(
+        public readonly int $filter,
+        public readonly array $options = [],
+        public readonly int $flags = 0,
+        public readonly string $message = '%s: is invalid value',
+        public readonly bool $onPersist = true,
+        public readonly bool $onUpdate = true
+    ) {
+    }
+
+    public function validate(mixed $propertyValue, string $propertyName, object $entity): void
+    {
+        $options = ['options' => $this->options, 'flags' => $this->flags];
+
+        if (filter_var($propertyValue, $this->filter, $options) === false) {
+            throw new EntityValidationException([$this->message, $propertyName], $propertyName, $entity);
+        }
+    }
+}

src/ColumnValidators/Greater.php

@@ -0,0 +1,41 @@
+<?php
+
+namespace EnsoStudio\Doctrine\ORM\ColumnValidators;
+
+use EnsoStudio\Doctrine\ORM\EntityValidationException;
+
+/**
+ * Validates whether the column value is greater than (or equal to) range value.
+ */
+class Greater implements ColumnValidator
+{
+    /**
+     * @param float|int $minRange The minimum value
+     * @param bool $strict If true, exclude `$minRange` value at check
+     * @param string $message The template of error message in format `sprintf()`
+     * @param bool $onPersist If true, validates column on persist entity
+     * @param bool $onUpdate If true, validates column on update entity
+     */
+    public function __construct(
+        public readonly float|int $minRange,
+        public readonly bool $strict = false,
+        public readonly string $message = '%s: is less than %d',
+        public readonly bool $onPersist = true,
+        public readonly bool $onUpdate = true
+    ) {
+    }
+
+    /**
+     * @inheritDoc
+     */
+    public function validate(mixed $propertyValue, string $propertyName, object $entity): void
+    {
+        if ($this->strict ? $this->minRange >= $propertyValue : $this->minRange > $propertyValue) {
+            throw new EntityValidationException(
+                [$this->message, $propertyName, $this->minRange],
+                $propertyName,
+                $entity
+            );
+        }
+    }
+}

src/ColumnValidators/Ip.php

@@ -0,0 +1,56 @@
+<?php
+
+namespace EnsoStudio\Doctrine\ORM\ColumnValidators;
+
+use EnsoStudio\Doctrine\ORM\EntityValidationException;
+
+/**
+ * Validates column value as IP address.
+ */
+class Ip implements ColumnValidator
+{
+    /**
+     * @param bool $ipv4 Allow IPv4 address
+     * @param bool $ipv6 Allow IPv6 address
+     * @param bool $noResRange Deny reserved addresses. These are the ranges that are marked as Reserved-By-Protocol in
+     *     RFC 6890. Which for IPv4 corresponds to the following ranges: `0.0.0.0/8`, `169.254.0.0/16`, `127.0.0.0/8`,
+     *     `240.0.0.0/4`. And for IPv6 corresponds to the following ranges: `::1/128`, `::/128`, `::FFFF:0:0/96`,
+     *     `FE80::/10`.
+     * @param bool $noPrivRange Deny private addresses. These are IPv4 addresses which are in the following ranges:
+     *     `10.0.0.0/8`, `172.16.0.0/12`, `192.168.0.0/16`. These are IPv6 addresses starting with FD or FC.
+     * @param string $message The template of error message in format `sprintf()`
+     * @param bool $onPersist If true, validates column on persist entity
+     * @param bool $onUpdate If true, validates column on update entity
+     */
+    public function __construct(
+        public readonly bool $ipv4 = false,
+        public readonly bool $ipv6 = false,
+        public readonly bool $noResRange = false,
+        public readonly bool $noPrivRange = false,
+        public readonly string $message = '%s: is invalid IP address',
+        public readonly bool $onPersist = true,
+        public readonly bool $onUpdate = true
+    ) {
+    }
+
+    public function validate(mixed $propertyValue, string $propertyName, object $entity): void
+    {
+        $options = 0;
+        if ($this->ipv4) {
+            $options = $options| FILTER_FLAG_IPV4;
+        }
+        if ($this->ipv6) {
+            $options = $options | FILTER_FLAG_IPV6;
+        }
+        if ($this->noResRange) {
+            $options = $options | FILTER_FLAG_NO_RES_RANGE;
+        }
+        if ($this->noPrivRange) {
+            $options = $options | FILTER_FLAG_NO_PRIV_RANGE;
+        }
+
+        if (filter_var($propertyValue, FILTER_VALIDATE_IP, $options) === false) {
+            throw new EntityValidationException([$this->message, $propertyName], $propertyName, $entity);
+        }
+    }
+}

src/ColumnValidators/MinLength.php

@@ -0,0 +1,35 @@
+<?php
+
+namespace EnsoStudio\Doctrine\ORM\ColumnValidators;
+
+use EnsoStudio\Doctrine\ORM\EntityValidationException;
+
+/**
+ * Validates column value is long enough.
+ */
+class MinLength implements ColumnValidator
+{
+    /**
+     * @param int $length The minimum length required
+     * @param string|null $encoding The character encoding. If it's null, the internal character encoding value will be
+     *     used.
+     * @param string $message The template of error message in format `sprintf()`
+     * @param bool $onPersist If true, validates column on persist entity
+     * @param bool $onUpdate If true, validates column on update entity
+     */
+    public function __construct(
+        public readonly int $length,
+        public readonly ?string $encoding = null,
+        public readonly string $message = '%s: is less than %d characters',
+        public readonly bool $onPersist = true,
+        public readonly bool $onUpdate = true
+    ) {
+    }
+
+    public function validate(mixed $propertyValue, string $propertyName, object $entity): void
+    {
+        if ($this->length > mb_strlen($propertyValue, $this->encoding)) {
+            throw new EntityValidationException([$this->message, $propertyName, $this->length], $propertyName, $entity);
+        }
+    }
+}