vendor/spatie/data-transfer-object/src/DataTransferObject.php line 210

Open in your IDE?
  1. <?php
  3. declare(strict_types=1);
  5. namespace Spatie\DataTransferObject;
  7. use ReflectionClass;
  8. use ReflectionProperty;
  10. abstract class DataTransferObject
  11. {
  12. protected bool $ignoreMissing = false;
  14. protected array $exceptKeys = [];
  16. protected array $onlyKeys = [];
  18. /**
  19. * @param array $parameters
  20. *
  21. * @return \Spatie\DataTransferObject\ImmutableDataTransferObject|static
  22. */
  23. public static function immutable(array $parameters = []): ImmutableDataTransferObject
  24. {
  25. return new ImmutableDataTransferObject(new static($parameters));
  26. }
  28. /**
  29. * @param array $arrayOfParameters
  30. *
  31. * @return \Spatie\DataTransferObject\ImmutableDataTransferObject[]|static[]
  32. */
  33. public static function arrayOf(array $arrayOfParameters): array
  34. {
  35. return array_map(
  36. function ($parameters) {
  37. return new static($parameters);
  38. },
  39. $arrayOfParameters
  40. );
  41. }
  43. public function __construct(array $parameters = [])
  44. {
  45. $validators = $this->getFieldValidators();
  47. $valueCaster = $this->getValueCaster();
  49. /** string[] */
  50. $invalidTypes = [];
  52. foreach ($validators as $field => $validator) {
  53. if (
  54. ! isset($parameters[$field])
  55. && ! $validator->hasDefaultValue
  56. && ! $validator->isNullable
  57. ) {
  58. throw DataTransferObjectError::uninitialized(
  59. static::class,
  60. $field
  61. );
  62. }
  64. $value = $parameters[$field] ?? $this->{$field} ?? null;
  66. $value = $this->castValue($valueCaster, $validator, $value);
  68. if (! $validator->isValidType($value)) {
  69. $invalidTypes[] = DataTransferObjectError::invalidTypeMessage(
  70. static::class,
  71. $field,
  72. $validator->allowedTypes,
  73. $value
  74. );
  76. continue;
  77. }
  79. $this->{$field} = $value;
  81. unset($parameters[$field]);
  82. }
  84. if ($invalidTypes) {
  85. DataTransferObjectError::invalidTypes($invalidTypes);
  86. }
  88. if (! $this->ignoreMissing && count($parameters)) {
  89. throw DataTransferObjectError::unknownProperties(array_keys($parameters), static::class);
  90. }
  91. }
  93. public function all(): array
  94. {
  95. $data = [];
  97. $class = new ReflectionClass(static::class);
  99. $properties = $class->getProperties(ReflectionProperty::IS_PUBLIC);
  101. foreach ($properties as $reflectionProperty) {
  102. // Skip static properties
  103. if ($reflectionProperty->isStatic()) {
  104. continue;
  105. }
  107. $data[$reflectionProperty->getName()] = $reflectionProperty->getValue($this);
  108. }
  110. return $data;
  111. }
  113. /**
  114. * @param string ...$keys
  115. *
  116. * @return static
  117. */
  118. public function only(string ...$keys): DataTransferObject
  119. {
  120. $dataTransferObject = clone $this;
  122. $dataTransferObject->onlyKeys = [...$this->onlyKeys, ...$keys];
  124. return $dataTransferObject;
  125. }
  127. /**
  128. * @param string ...$keys
  129. *
  130. * @return static
  131. */
  132. public function except(string ...$keys): DataTransferObject
  133. {
  134. $dataTransferObject = clone $this;
  136. $dataTransferObject->exceptKeys = [...$this->exceptKeys, ...$keys];
  138. return $dataTransferObject;
  139. }
  141. public function toArray(): array
  142. {
  143. if (count($this->onlyKeys)) {
  144. $array = Arr::only($this->all(), $this->onlyKeys);
  145. } else {
  146. $array = Arr::except($this->all(), $this->exceptKeys);
  147. }
  149. $array = $this->parseArray($array);
  151. return $array;
  152. }
  154. protected function parseArray(array $array): array
  155. {
  156. foreach ($array as $key => $value) {
  157. if (
  158. $value instanceof DataTransferObject
  159. || $value instanceof DataTransferObjectCollection
  160. ) {
  161. $array[$key] = $value->toArray();
  163. continue;
  164. }
  166. if (! is_array($value)) {
  167. continue;
  168. }
  170. $array[$key] = $this->parseArray($value);
  171. }
  173. return $array;
  174. }
  176. /**
  177. * @param \ReflectionClass $class
  178. *
  179. * @return \Spatie\DataTransferObject\FieldValidator[]
  180. */
  181. protected function getFieldValidators(): array
  182. {
  183. return DTOCache::resolve(static::class, function () {
  184. $class = new ReflectionClass(static::class);
  186. $properties = [];
  188. foreach ($class->getProperties(ReflectionProperty::IS_PUBLIC) as $reflectionProperty) {
  189. // Skip static properties
  190. if ($reflectionProperty->isStatic()) {
  191. continue;
  192. }
  194. $field = $reflectionProperty->getName();
  196. $properties[$field] = FieldValidator::fromReflection($reflectionProperty);
  197. }
  199. return $properties;
  200. });
  201. }
  203. /**
  204. * @param \Spatie\DataTransferObject\ValueCaster $valueCaster
  205. * @param \Spatie\DataTransferObject\FieldValidator $fieldValidator
  206. * @param mixed $value
  207. *
  208. * @return mixed
  209. */
  210. protected function castValue(ValueCaster $valueCaster, FieldValidator $fieldValidator, $value)
  211. {
  212. if (is_array($value)) {
  213. return $valueCaster->cast($value, $fieldValidator);
  214. }
  216. return $value;
  217. }
  219. protected function getValueCaster(): ValueCaster
  220. {
  221. return new ValueCaster();
  222. }
  223. }