devsam/core
3
6
Fork 1
Code Issues 60 Pull Requests Releases 1 Wiki Activity

feat: 직접 작성한 DTO

Browse Source
This commit was merged in pull request #220.
This commit is contained in:
Hide_D
2022-05-22 16:53:56 +09:00
parent cb5cb68bf4
commit 43a5162a15
11 changed files with 800 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/sammo/DTO/Attr/Convert.php
+30
View File
@@ -0,0 +1,30 @@
<?php
namespace sammo\DTO\Attr;
use sammo\DTO\Converter\Converter;
#[\Attribute(\Attribute::TARGET_PROPERTY | \Attribute::TARGET_CLASS)]
class Convert
{
public Converter $converter;
public function __construct(
public readonly array $targetTypes,
public readonly string $converterType,
array ...$args
) {
if(!is_subclass_of($converterType, \sammo\DTO\Converter\Converter::class)){
throw new \Exception("$converterType is not a subclass of \sammo\DTO\Converter\Converter");
}
$this->converter = new $converterType($targetTypes, ...$args);
}
public function convertFrom(string|array|int|float|bool|null $raw): mixed
{
return $this->converter->convertFrom($raw);
}
public function convertTo(mixed $target): string|array|int|float|bool|null {
return $this->converter->convertTo($target);
}
}
src/sammo/DTO/Attr/JsonString.php
+11
View File
@@ -0,0 +1,11 @@
<?php
namespace sammo\DTO\Attr;
#[\Attribute(\Attribute::TARGET_PROPERTY)]
class JsonString
{
public function __construct(public readonly bool $emptyItemIsArray = false)
{
}
}
src/sammo/DTO/Attr/NullIsUndefined.php
+11
View File
@@ -0,0 +1,11 @@
<?php
namespace sammo\DTO\Attr;
#[\Attribute(\Attribute::TARGET_PROPERTY)]
class NullIsUndefined
{
public function __construct()
{
}
}
src/sammo/DTO/Attr/RawName.php
+11
View File
@@ -0,0 +1,11 @@
<?php
namespace sammo\DTO\Attr;
#[\Attribute(\Attribute::TARGET_PROPERTY)]
class RawName
{
public function __construct(public readonly string $rawName)
{
}
}
src/sammo/DTO/Converter/ArrayConverter.php
+45
View File
@@ -0,0 +1,45 @@
<?php
namespace sammo\DTO\Converter;
class ArrayConverter implements Converter
{
private Converter $itemConverter;
public function __construct(private array $types, ...$args)
{
$itemTypes = array_shift($args);
if(!is_array($itemTypes)){
throw new \Exception('itemTypes is not a array');
}
$itemConverterType = array_shift($args);
if($itemConverterType === null){
$itemConverterType = DefaultConverter::class;
}
else if(!is_subclass_of($itemConverterType, Converter::class)){
throw new \Exception("$itemConverterType is not a subclass of \sammo\DTO\Converter\Converter");
}
$this->itemConverter = new $itemConverterType($itemTypes, ...$args);
}
public function convertFrom(string|array|int|float|bool|null $raw): mixed
{
if ($raw === null && array_search('null', $this->types, true) !== false) {
return null;
}
if (!is_array($raw) || !array_is_list($raw)) {
throw new \Exception('value is not a array');
}
return array_map(fn ($v) => $this->itemConverter->convertFrom($v), $raw);
}
public function convertTo(mixed $data): string|array|int|float|bool|null
{
if ($data === null && array_search('null', $this->types) !== false) {
return null;
}
if (!is_array($data) || !array_is_list($data)) {
throw new \Exception('value is not a array');
}
return array_map(fn ($v) => $this->itemConverter->convertTo($v), $data);
}
}
src/sammo/DTO/Converter/Converter.php
+8
View File
@@ -0,0 +1,8 @@
<?php
namespace sammo\DTO\Converter;
interface Converter{
public function __construct(array $types, ...$args);
public function convertFrom(string|array|int|float|bool|null $raw): mixed;
public function convertTo(mixed $data): string|array|int|float|bool|null;
}
src/sammo/DTO/Converter/DefaultConverter.php
+140
View File
@@ -0,0 +1,140 @@
<?php
namespace sammo\DTO\Converter;
use sammo\DTO\DTO;
class DefaultConverter implements Converter
{
public function __construct(private array $types, ...$args)
{
}
public static function convertFromItem(string $type, $raw, bool &$success): mixed
{
$success = false;
if (is_subclass_of($type, \UnitEnum::class)) {
$enumType = new \ReflectionEnum($type);
if ($enumType->isBacked()) {
$enum = $enumType->getMethod('tryFrom')->invoke(null, $raw);
if ($enum === null) {
return null;
}
$success = true;
return $enum;
}
if (!$enumType->hasCase($raw)) {
return null;
}
$success = true;
return $enumType->getCase($raw)->getValue();
}
if (is_subclass_of($type, DTO::class)) {
try {
$class = new \ReflectionClass($type);
$obj = $class->getMethod('fromArray')->invoke(null, $raw);
$success = true;
return $obj;
} catch (\Throwable) {
}
return null;
}
if ($type === 'array') {
if (!is_array($raw)) {
return null;
}
if (!array_is_list($raw)) {
throw new \Exception('value is not a array');
}
foreach ($raw as $value) {
if (is_int($value) || is_float($value) || is_string($value)) {
continue;
}
if (is_bool($value) || is_null($value)) {
continue;
}
throw new \Exception('DefaultConverter can not convert array');
}
$success = true;
return $raw;
}
if($type === 'int' && is_int($raw)){
$success = true;
return $raw;
}
if($type === 'float' && is_float($raw)){
$success = true;
return $raw;
}
if($type === 'string' && is_string($raw)){
$success = true;
return $raw;
}
if($type === 'bool' && is_bool($raw)){
$success = true;
return $raw;
}
return null;
}
public function convertFrom(string|array|int|float|bool|null $raw): mixed
{
if ($raw === null && array_search('null', $this->types, true) !== false) {
return null;
}
foreach ($this->types as $type) {
$success = false;
$value = self::convertFromItem($type, $raw, $success);
if ($success) {
return $value;
}
}
throw new \Exception('DefaultConverter can not convert');
}
public function convertTo(mixed $data): string|array|int|float|bool|null
{
if ($data === null) {
return $data;
}
if ($data instanceof \UnitEnum) {
if ($data instanceof \BackedEnum) {
return $data->value;
}
return $data->name;
}
if ($data instanceof DTO) {
return $data->toArray();
}
if (is_array($data)) {
if (!array_is_list($data)) {
throw new \Exception('value is not a array');
}
foreach ($data as $value) {
if (is_int($value) || is_float($value) || is_string($value)) {
continue;
}
if (is_bool($value) || is_null($value)) {
continue;
}
throw new \Exception('DefaultConverter can not convert array');
}
}
return $data;
}
}
src/sammo/DTO/Converter/MapConverter.php
+54
View File
@@ -0,0 +1,54 @@
<?php
namespace sammo\DTO\Converter;
class MapConverter implements Converter
{
private Converter $itemConverter;
public function __construct(private array $types, ...$args)
{
$itemTypes = array_shift($args);
if(!is_array($itemTypes)){
throw new \Exception('itemTypes is not a array');
}
$itemConverterType = array_shift($args);
if($itemConverterType === null){
$itemConverterType = DefaultConverter::class;
}
else if (!is_subclass_of($itemConverterType, Converter::class)) {
throw new \Exception("$itemConverterType is not a subclass of \sammo\DTO\Converter\Converter");
}
$this->itemConverter = new $itemConverterType($itemTypes, ...$args);
}
public function convertFrom(string|array|int|float|bool|null $raw): mixed
{
if ($raw === null && array_search('null', $this->types, true) !== false) {
return null;
}
if (!is_array($raw)) {
throw new \Exception('value is not a array');
}
$result = [];
foreach ($raw as $key => $value) {
$result[$key] = $this->itemConverter->convertFrom($value);
}
return $result;
}
public function convertTo(mixed $data): string|array|int|float|bool|null
{
if ($data === null && array_search('null', $this->types, true) !== false) {
return null;
}
if (!is_array($data) && !($data instanceof \Traversable)) {
throw new \Exception('value is not a array');
}
$result = [];
foreach ($data as $key => $value) {
$result[$key] = $this->itemConverter->convertTo($value);
}
return $result;
}
}
src/sammo/DTO/DTO.php
+106
View File
@@ -0,0 +1,106 @@
<?php
namespace sammo\DTO;
use sammo\DTO\Attr\Convert;
use sammo\DTO\Converter\DefaultConverter;
use sammo\Json;
abstract class DTO
{
public static function fromArray(\ArrayAccess|array $array): static
{
$reflection = new \ReflectionClass(static::class);
$args = [];
if ($array instanceof \ArrayAccess) {
$keyExists = fn (string|int $key) => $array->offsetExists($key);
} else {
$keyExists = fn (string|int $key) => array_key_exists($key, $array);
}
foreach ($reflection->getProperties(
\ReflectionProperty::IS_PUBLIC
) as $property) {
$attrs = Util\Util::getAttrs($property);
$name = $property->getName();
$rawName = $name;
if (key_exists(Attr\RawName::class, $attrs)) {
$rawAttr = $attrs[Attr\RawName::class];
$attr = new Attr\RawName(...$rawAttr->getArguments());
$rawName = $attr->rawName;
}
if (!$keyExists($rawName)) {
if ($property->hasDefaultValue()) {
$args[$name] = $property->getDefaultValue();
} else if ($property->getType()->allowsNull()) {
$args[$name] = null;
} else {
throw new \Exception("Missing property: {$name}");
}
continue;
}
$value = $array[$rawName];
if (key_exists(Attr\JsonString::class, $attrs)) {
$rawAttr = $attrs[Attr\JsonString::class];
$attr = new Attr\JsonString(...$rawAttr->getArguments());
$value = Json::decode($value);
}
$propTypes = Util\Util::getPropTypes($property);
if (key_exists(Attr\Convert::class, $attrs)) {
$rawAttr = $attrs[Attr\Convert::class];
$converter = new Convert($propTypes, ...$rawAttr->getArguments());
} else {
$converter = new Convert($propTypes, DefaultConverter::class);
}
$value = $converter->convertFrom($value);
$args[$name] = $value;
}
$object = $reflection->newInstanceArgs($args);
return $object;
}
public function toArray(): array
{
$reflection = new \ReflectionClass($this::class);
$result = [];
foreach ($reflection->getProperties(\ReflectionProperty::IS_PUBLIC) as $property) {
$value = $property->getValue($this);
$attrs = Util\Util::getAttrs($property);
$name = $property->getName();
if (key_exists(Attr\RawName::class, $attrs)) {
$rawAttr = $attrs[Attr\RawName::class];
$attr = new Attr\RawName(...$rawAttr->getArguments());
$name = $attr->rawName;
}
$propTypes = Util\Util::getPropTypes($property);
if (key_exists(Attr\Convert::class, $attrs)) {
$converter = new Convert($propTypes, ...$attrs[Attr\Convert::class]->getArguments());
} else {
$converter = new Convert($propTypes, DefaultConverter::class);
}
$value = $converter->convertTo($value);
if (key_exists(Attr\JsonString::class, $attrs)) {
$rawAttr = $attrs[Attr\JsonString::class];
$attr = new Attr\JsonString(...$rawAttr->getArguments());
$value = Json::encode($value, $attr->emptyItemIsArray ? JSON::EMPTY_ARRAY_IS_DICT : 0);
}
if ($value === null && key_exists(Attr\NullIsUndefined::class, $attrs)) {
continue;
}
$result[$name] = $value;
}
return $result;
}
}
src/sammo/DTO/Util/Util.php
+55
View File
@@ -0,0 +1,55 @@
<?php
namespace sammo\DTO\Util;
use Ds\Map;
class Util{
private function __construct()
{
}
/**
* @return array<string,\ReflectionAttribute>
*/
public static function getAttrs(\ReflectionProperty $prop): array{
$result = [];
foreach($prop->getAttributes() as $attr){
$result[$attr->getName()] = $attr;
}
return $result;
}
/**
* @return array<string>
*/
public static function getPropTypes(\ReflectionProperty $prop): array{
$result = [];
$type = $prop->getType();
if($type === null){
throw new \Exception("Property {$prop->getName()} has no type");
}
if($type->allowsNull()){
$result[] = 'null';
}
if($type instanceof \ReflectionIntersectionType){
throw new \Exception("Intersection types are not supported");
}
if($type instanceof \ReflectionNamedType){
$result[] = $type->getName();
return $result;
}
if($type instanceof \ReflectionUnionType){
foreach($type->getTypes() as $type){
$result[] = $type->getName();
}
return $result;
}
throw new \sammo\MustNotBeReachedException;
}
}