vendor/spatie/data-transfer-object/src/FieldValidator.php line 49

Open in your IDE?
  1. <?php
  3. declare(strict_types=1);
  5. namespace Spatie\DataTransferObject;
  7. use ReflectionClass;
  8. use ReflectionProperty;
  10. abstract class FieldValidator
  11. {
  12. public bool $isNullable;
  14. public bool $isMixed;
  16. public bool $isMixedArray;
  18. public bool $hasDefaultValue;
  20. public array $allowedTypes;
  22. public array $allowedArrayTypes;
  24. public array $allowedArrayKeyTypes;
  26. protected static array $typeMapping = [
  27. 'int' => 'integer',
  28. 'bool' => 'boolean',
  29. 'float' => 'double',
  30. ];
  32. protected bool $hasTypeDeclaration;
  34. public static function fromReflection(ReflectionProperty $property): FieldValidator
  35. {
  36. $docDefinition = null;
  38. if ($property->getDocComment()) {
  39. preg_match(
  40. DocblockFieldValidator::DOCBLOCK_REGEX,
  41. $property->getDocComment(),
  42. $matches
  43. );
  45. $docDefinition = $matches[0] ?? null;
  46. }
  48. if ($docDefinition) {
  49. return new DocblockFieldValidator($docDefinition, $property->isDefault());
  50. }
  52. return new PropertyFieldValidator($property);
  53. }
  55. public function isValidType($value): bool
  56. {
  57. if (! $this->hasTypeDeclaration) {
  58. return true;
  59. }
  61. if ($this->isMixed) {
  62. return true;
  63. }
  65. if (is_iterable($value) && $this->isMixedArray) {
  66. return true;
  67. }
  69. if ($this->isNullable && $value === null) {
  70. return true;
  71. }
  73. if (is_iterable($value)) {
  74. return $this->isValidIterable($value);
  75. }
  77. return $this->isValidValue($value);
  78. }
  80. private function isValidIterable(iterable $iterable): bool
  81. {
  82. // If the iterable matches one of the normal types, we immediately return true
  83. // For example: custom collection classes type hinted with `MyCollection`
  84. $isValidValue = $this->isValidValue($iterable);
  86. if ($isValidValue) {
  87. return true;
  88. }
  90. // If not, we'll check all individual iterable items and keys
  91. foreach ($iterable as $key => $value) {
  92. $isValidValue = false;
  94. // First we check whether the value matches the value type definition
  95. foreach ($this->allowedArrayTypes as $type) {
  96. $isValidValue = $this->assertValidType($type, $value);
  98. // No need to further check this value when a valid type is found
  99. if ($isValidValue) {
  100. break;
  101. }
  102. }
  104. // If a value is invalid, we immediately return false
  105. if (! $isValidValue) {
  106. return false;
  107. }
  109. // We'll assume keys are valid by default, since they can be omitted
  110. $isValidKey = true;
  112. // Next we check the key's value
  113. foreach ($this->allowedArrayKeyTypes as $keyType) {
  114. $isValidKey = $this->assertValidType($keyType, $key);
  116. // No need to further check this jey when a valid type is found
  117. if ($isValidKey) {
  118. break;
  119. }
  120. }
  122. // If a key type is invalid, we'll immediately return
  123. if (! $isValidKey) {
  124. return false;
  125. }
  127. // Moving on to checking the next $key => $value pair
  128. }
  130. // If value and key type checks pass, we can return true
  131. return true;
  132. }
  134. private function isValidValue($value): bool
  135. {
  136. foreach ($this->allowedTypes as $type) {
  137. // We'll check the type of this value against all allowed types, if one matches we're good
  138. $isValidType = $this->assertValidType($type, $value);
  140. if ($isValidType) {
  141. return true;
  142. }
  143. }
  145. return false;
  146. }
  148. private function assertValidType(string $type, $value): bool
  149. {
  150. return $value instanceof $type || gettype($value) === $type;
  151. }
  153. protected function resolveAllowedArrayTypesFromCollection(string $type): array
  154. {
  155. if (! is_subclass_of($type, DataTransferObjectCollection::class)) {
  156. return [];
  157. }
  159. $class = new ReflectionClass($type);
  161. $currentReturnType = $class->getMethod('current')->getReturnType();
  163. // We cast to array to support future union types in PHP 8
  164. $currentReturnTypes = [];
  165. if ($currentReturnType) {
  166. $currentReturnTypes[] = $currentReturnType->getName();
  167. }
  169. $docblockReturnTypes = $class->getDocComment()
  170. ? $this->getCurrentReturnTypesFromDocblock($class->getDocComment())
  171. : [];
  173. $types = [...$currentReturnTypes, ...$docblockReturnTypes];
  175. if (! $types) {
  176. throw DataTransferObjectError::untypedCollection($type);
  177. }
  179. return $this->normaliseTypes(...$types);
  180. }
  182. /**
  183. * @return string[]
  184. */
  185. private function getCurrentReturnTypesFromDocblock(string $definition): array
  186. {
  187. $DOCBLOCK_REGEX = '/@method ((?:(?:[\w?|\\\\<>])+(?:\[])?)+) current/';
  189. preg_match(
  190. $DOCBLOCK_REGEX,
  191. $definition,
  192. $matches
  193. );
  195. $type = $matches[1] ?? null;
  197. if (! $type) {
  198. return [];
  199. }
  201. return explode('|', $type);
  202. }
  204. protected function normaliseTypes(?string ...$types): array
  205. {
  206. return array_filter(array_map(
  207. fn (?string $type) => self::$typeMapping[$type] ?? $type,
  208. $types
  209. ));
  210. }
  211. }