20250622#1

src/AbstractDTO.php

@@ -0,0 +1,39 @@
+<?php
+
+namespace Rmphp\ODM;
+
+use Exception;
+use ReflectionClass;
+
+abstract class AbstractDTO extends AbstractObjectData {
+
+	/**
+	 * @param array|object ...$data
+	 * @return static
+	 * @throws Exception
+	 */
+	final public static function fromData(array|object ...$data) : static {
+		$array = array_map(function($item) {
+			return (is_object($item)) ? get_object_vars($item) : $item;
+		}, $data);
+		return self::fromArray(array_merge(...$array));
+	}
+
+	/**
+	 * @param object $data
+	 * @return static
+	 * @throws Exception
+	 */
+	final public static function fromObject(object $data) : static {
+		return self::fromArray(get_object_vars($data));
+	}
+
+	/**
+	 * @param array $data
+	 * @return static
+	 * @throws Exception
+	 */
+	final public static function fromArray(array $data) : static {
+		return self::fillObject(new ReflectionClass(static::class), new static(), $data);
+	}
+}

src/AbstractObjectData.php

@@ -0,0 +1,134 @@
+<?php
+
+namespace Rmphp\ODM;
+
+use Exception;
+use ReflectionClass;
+use ReflectionException;
+use Rmphp\ODM\Attribute\Data;
+use Rmphp\ODM\Attribute\DataIgnorEmpty;
+
+abstract class AbstractObjectData {
+
+	private static array $stack  = [];
+	protected static array $constructorEmptyAvailableClasses = [];
+	protected static array $classes = [];
+	protected static array $attributeObjects = [];
+
+	/**
+	 * @param ReflectionClass $class
+	 * @param object $object
+	 * @param array $data
+	 * @param bool $update
+	 * @param bool $withEmpty
+	 * @return mixed
+	 * @throws Exception
+	 */
+	final protected static function fillObject(ReflectionClass $class, object $object, array $data, bool $update = false, bool $withEmpty = true) : mixed {
+		try {
+			if(!isset(self::$attributeObjects[$class->getName()][0])){
+				self::$attributeObjects[$class->getName()][0] = !empty($class->getAttributes(Data::class))
+					? $class->getAttributes(Data::class)[0]->newInstance()
+					: new Data();
+			}
+			/** @var Data $dataAttributes */
+			$dataAttributes = self::$attributeObjects[$class->getName()][0];
+			if(!empty($class->getAttributes(DataIgnorEmpty::class))) $dataAttributes->ignorEmpty = true;
+
+			$value = [];
+			foreach($class->getProperties() as $property){
+				$prop[$property->getName()] = ($property->hasType()) ? $property->getType()->getName() : "";
+
+				// значение в массиве по ключю с именем свойства
+				if(array_key_exists($property->getName(), $data)){
+					$value[$property->getName()] = $data[$property->getName()];
+				}
+				// значение в массиве по ключю с именем свойства в snake case
+				elseif(array_key_exists(strtolower(preg_replace("'([A-Z])'", "_$1", $property->getName())), $data)){
+					$value[$property->getName()] = $data[strtolower(preg_replace("'([A-Z])'", "_$1", $property->getName()))];
+				}
+				elseif($update) {
+					continue;
+				}
+
+				// если есть внутренний метод (приоритетная обработка)
+				if($class->hasMethod('set'.ucfirst($property->getName()))) {
+					$object->{'set'.ucfirst($property->getName())}($value[$property->getName()] ?? null);
+					$case[$property->getName()] = 'Method set'.ucfirst($property->getName());
+				}
+				// Если тип свойства класс (valueObject)
+				elseif($property->hasType() && class_exists($property->getType()->getName())) {
+					// значение объект
+					if(isset($value[$property->getName()]) && is_object($value[$property->getName()])){
+						$object->{$property->getName()} = $value[$property->getName()];
+						$case[$property->getName()] = 'VO: Object';
+					}
+					// значение не пустое
+					elseif(isset($value[$property->getName()]) && $value[$property->getName()] !== ""){
+						$object->{$property->getName()} = new ($property->getType()->getName())($value[$property->getName()]);
+						$case[$property->getName()] = 'VO: NewInstance';
+					}
+					// Значения нет и VO может быть без параметров
+					elseif(($withEmpty && empty($dataAttributes->ignorEmpty)) && self::isEmptyAvailable($property->getType()->getName())) {
+						$object->{$property->getName()} = new ($property->getType()->getName())();
+						$case[$property->getName()] = 'VO: Without params';
+					}
+				}
+				// Базовые типы при наличии значения
+				elseif(array_key_exists($property->getName(), $value)){
+					if(!$property->hasType()){
+						$object->{$property->getName()} = $value[$property->getName()];
+						$case[$property->getName()] = 'Base: Hasn`t type';
+					}
+					elseif(in_array($property->getType()->getName(), ['float', 'int'])){
+						if(is_numeric($value[$property->getName()])) $object->{$property->getName()} = $value[$property->getName()];
+						$case[$property->getName()] = 'Base: Number';
+					}
+					elseif($property->getType()->getName() == 'bool'){
+						$object->{$property->getName()} = (bool)$value[$property->getName()];
+						$case[$property->getName()] = 'Base: Boolean';
+					}
+					elseif(isset($value[$property->getName()])){
+						$object->{$property->getName()} = $value[$property->getName()];
+						$case[$property->getName()] = 'Base: NotNull';
+					}
+					elseif($property->getType()->allowsNull()){
+						$object->{$property->getName()} = $value[$property->getName()];
+						$case[$property->getName()] = 'Base: Null';
+					}
+				}
+			}
+			self::$stack[$object::class." #".spl_object_id($object)]['properties'] = $prop ?? [];
+			self::$stack[$object::class." #".spl_object_id($object)]['values'] = $value;
+			self::$stack[$object::class." #".spl_object_id($object)]['matchCase'] = $case ?? [];
+			self::$stack[$object::class." #".spl_object_id($object)]['object'] = $object;
+			return $object;
+		}
+		catch (ReflectionException $exception) {
+			throw new Exception($exception->getMessage());
+		}
+	}
+
+
+	/**
+	 * @throws ReflectionException
+	 */
+	private static function isEmptyAvailable(string $class) : bool {
+		if(isset(self::$constructorEmptyAvailableClasses[$class])) return self::$constructorEmptyAvailableClasses[$class];
+		if(!$constructor = (new \ReflectionClass($class))->getConstructor()) return self::$constructorEmptyAvailableClasses[$class] = false;
+		foreach($constructor->getParameters() as $param){
+			if(!$param->isDefaultValueAvailable()){
+				return self::$constructorEmptyAvailableClasses[$class] = false;
+			}
+		}
+		return self::$constructorEmptyAvailableClasses[$class] = true;
+	}
+
+	/**
+	 * @return array
+	 */
+	protected function getFillObjectStack() : array {
+		return self::$stack;
+	}
+
+}

src/Attribute/Data.php

@@ -0,0 +1,14 @@
+<?php
+
+namespace Rmphp\ODM\Attribute;
+
+use Attribute;
+
+#[Attribute(Attribute::TARGET_CLASS)]
+class Data {
+
+	public function __construct(
+		public bool $ignorEmpty = false,
+	) {}
+
+}

src/Attribute/DataIgnorEmpty.php

@@ -0,0 +1,8 @@
+<?php
+
+namespace Rmphp\ODM\Attribute;
+
+use Attribute;
+
+#[Attribute(Attribute::TARGET_CLASS)]
+class DataIgnorEmpty {}

src/Attribute/Entity.php

@@ -0,0 +1,14 @@
+<?php
+
+namespace Rmphp\ODM\Attribute;
+
+use Attribute;
+
+#[Attribute(Attribute::TARGET_CLASS)]
+class Entity {
+
+	public function __construct(
+		public bool $noReturnIfNull = false,
+	) {}
+
+}

src/Attribute/EntityNoReturnIfNull.php

@@ -0,0 +1,8 @@
+<?php
+
+namespace Rmphp\ODM\Attribute;
+
+use Attribute;
+
+#[Attribute(Attribute::TARGET_CLASS)]
+class EntityNoReturnIfNull {}

src/Attribute/Property.php

@@ -0,0 +1,16 @@
+<?php
+
+namespace Rmphp\ODM\Attribute;
+
+use Attribute;
+
+#[Attribute(Attribute::TARGET_PROPERTY)]
+class Property {
+
+	public function __construct(
+		public ?string $keyName = null,
+		public bool $noReturn = false,
+		public bool $noReturnIfNull = false,
+	) {}
+
+}

src/Attribute/PropertyNoReturn.php

@@ -0,0 +1,8 @@
+<?php
+
+namespace Rmphp\ODM\Attribute;
+
+use Attribute;
+
+#[Attribute(Attribute::TARGET_PROPERTY)]
+class PropertyNoReturn {}

src/Attribute/PropertyNoReturnIfNull.php

@@ -0,0 +1,8 @@
+<?php
+
+namespace Rmphp\ODM\Attribute;
+
+use Attribute;
+
+#[Attribute(Attribute::TARGET_PROPERTY)]
+class PropertyNoReturnIfNull {}

src/Attribute/ValueObject.php

@@ -0,0 +1,15 @@
+<?php
+
+namespace Rmphp\ODM\Attribute;
+
+use Attribute;
+
+#[Attribute(Attribute::TARGET_CLASS)]
+class ValueObject {
+
+	public function __construct(
+		public ?string $propertyName = null,
+		public bool $firstProperty = false
+	) {}
+
+}

src/Attribute/ValueObjectFirstProperty.php

@@ -0,0 +1,8 @@
+<?php
+
+namespace Rmphp\ODM\Attribute;
+
+use Attribute;
+
+#[Attribute(Attribute::TARGET_CLASS)]
+class ValueObjectFirstProperty {}

src/Attribute/ValueObjectPropertyName.php

@@ -0,0 +1,14 @@
+<?php
+
+namespace Rmphp\ODM\Attribute;
+
+use Attribute;
+
+#[Attribute(Attribute::TARGET_CLASS)]
+class ValueObjectPropertyName {
+
+	public function __construct(
+		public ?string $name = null,
+	) {}
+
+}

src/ODMException.php

@@ -0,0 +1,16 @@
+<?php
+
+namespace Rmphp\ODM;
+
+use Throwable;
+
+class ODMException extends \Exception {
+
+	public array $data;
+
+	public function __construct($message="", $code=0, array $data = [], Throwable $previous=null) {
+		parent::__construct($message, $code, $previous);
+		$this->data = $data;
+	}
+
+}

src/ObjectDataMapper.php

@@ -0,0 +1,176 @@
+<?php
+
+namespace Rmphp\ODM;
+
+use Exception;
+use ReflectionClass;
+use Rmphp\ODM\Attribute\Entity;
+use Rmphp\ODM\Attribute\EntityNoReturnIfNull;
+use Rmphp\ODM\Attribute\Property;
+use Rmphp\ODM\Attribute\PropertyNoReturn;
+use Rmphp\ODM\Attribute\PropertyNoReturnIfNull;
+use Rmphp\ODM\Attribute\ValueObject;
+use Rmphp\ODM\Attribute\ValueObjectFirstProperty;
+use Rmphp\ODM\Attribute\ValueObjectPropertyName;
+
+abstract class ObjectDataMapper extends AbstractObjectData {
+
+	/**
+	 * @param object $object
+	 * @param callable|null $method
+	 * @return array
+	 * @throws ODMException
+	 */
+	public function getDataFromObject(object $object, callable $method = null) : array {
+		try{
+			$class = get_class($object);
+			if(!isset(self::$classes[$class])) self::$classes[$class] = new ReflectionClass($class);
+
+			if(!isset(self::$attributeObjects[$class][0])){
+				self::$attributeObjects[$class][0] = !empty(self::$classes[$class]->getAttributes(Entity::class))
+					? self::$classes[$class]->getAttributes(Entity::class)[0]->newInstance()
+					: new Entity();
+			}
+			/** @var Entity $entityAttributes */
+			$entityAttributes = self::$attributeObjects[$class][0];
+			if(!empty(self::$classes[$class]->getAttributes(EntityNoReturnIfNull::class))) $entityAttributes->noReturnIfNull = true;
+
+			$fieldValue = [];
+			foreach(self::$classes[$class]->getProperties() as $property){
+
+				if(!isset(self::$attributeObjects[$class][$property->getName()])){
+					self::$attributeObjects[$class][$property->getName()] = !empty($property->getAttributes(Property::class))
+						? $property->getAttributes(Property::class)[0]->newInstance()
+						: new Property();
+				}
+				/** @var Property $propertyAttributes */
+				$propertyAttributes = self::$attributeObjects[$class][$property->getName()];
+				if(!empty($property->getAttributes(PropertyNoReturnIfNull::class))) $propertyAttributes->noReturnIfNull = true;
+
+				if(!empty($property->getAttributes(PropertyNoReturn::class)) || !empty($propertyAttributes->noReturn)) continue;
+
+				if($property->isInitialized($object)) {
+
+					if(is_array($property->getValue($object))) continue;
+
+					if(self::$classes[$class]->hasMethod('get'.ucfirst($property->getName()))){
+						$fieldValue[$property->getName()] = $object->{'get'.ucfirst($property->getName())}($property->getValue($object));
+					}
+					elseif($property->hasType() && class_exists($property->getType()->getName())){
+						$valueObjectClass = get_class($property->getValue($object));
+						if(!isset(self::$classes[$valueObjectClass])) self::$classes[$valueObjectClass] = new ReflectionClass($valueObjectClass);
+
+						if(!isset(self::$attributeObjects[$valueObjectClass])){
+							self::$attributeObjects[$valueObjectClass] = !empty(self::$classes[$valueObjectClass]->getAttributes(ValueObject::class))
+								? self::$classes[$valueObjectClass]->getAttributes(ValueObject::class)[0]->newInstance()
+								: new ValueObject();
+							if(!empty(self::$classes[$valueObjectClass]->getAttributes(ValueObjectFirstProperty::class))) {
+								self::$attributeObjects[$valueObjectClass]->firstProperty = true;
+							}
+							if(!empty(self::$classes[$valueObjectClass]->getAttributes(ValueObjectPropertyName::class))) {
+								$propertyName = self::$classes[$valueObjectClass]->getAttributes(ValueObjectPropertyName::class)[0]->newInstance();
+								if(isset($propertyName->name)) self::$attributeObjects[$valueObjectClass]->propertyName = $propertyName->name;
+							}
+						}
+						$valueObjectAttributes = self::$attributeObjects[$valueObjectClass];
+
+						if(!empty($valueObjectAttributes->propertyName) && self::$classes[$valueObjectClass]->hasProperty($valueObjectAttributes->propertyName)){
+							if(self::$classes[$valueObjectClass]->getProperty($valueObjectAttributes->propertyName)->isInitialized($property->getValue($object))){
+								$fieldValue[$property->getName()] = self::$classes[$valueObjectClass]->getProperty($valueObjectAttributes->propertyName)->getValue($property->getValue($object));
+							}
+						}
+						elseif(!empty($valueObjectAttributes->firstProperty) && count(self::$classes[$valueObjectClass]->getProperties()) > 0){
+							if(self::$classes[$valueObjectClass]->getProperties()[0]->isInitialized($property->getValue($object))){
+								$fieldValue[$property->getName()] = self::$classes[$valueObjectClass]->getProperties()[0]->getValue($property->getValue($object));
+							}
+						}
+						elseif(self::$classes[$valueObjectClass]->hasMethod('getValue')){
+							$fieldValue[$property->getName()] = $property->getValue($object)->getValue();
+						}
+					}
+					elseif(is_bool($property->getValue($object))){
+						$fieldValue[$property->getName()] = (int)$property->getValue($object);
+					}
+					else{
+						$fieldValue[$property->getName()] = $property->getValue($object);
+					}
+
+					if(!isset($fieldValue[$property->getName()]) && (!empty($propertyAttributes->noReturnIfNull) || !empty($entityAttributes->noReturnIfNull))) continue;
+
+					if(array_key_exists($property->getName(), $fieldValue) && false !== $fieldValue[$property->getName()]) {
+						$columnName = !empty($propertyAttributes->keyName) ? $propertyAttributes->keyName : strtolower(preg_replace("'([A-Z])'", "_$1", $property->getName()));
+						$out[$columnName] = $fieldValue[$property->getName()];
+					}
+				}
+			}
+			return (isset($method)) ? array_map($method, $out ?? []) : $out ?? [];
+		}
+		catch (\ReflectionException $exception) {
+			throw new ODMException($exception->getMessage());
+		}
+	}
+
+	/**
+	 * @param string $class
+	 * @param array|object $data
+	 * @param bool $withEmpty
+	 * @return object
+	 * @throws ODMException
+	 */
+	public function createObjectFromData(string $class, array|object $data, bool $withEmpty = true) : object {
+		try {
+			if(!isset(self::$classes[$class])) self::$classes[$class] = new ReflectionClass($class);
+			return self::fillObject(self::$classes[$class], new $class, (is_object($data)) ? get_object_vars($data) : $data, false, $withEmpty);
+		}
+		catch (Exception $exception) {
+			throw new ODMException($exception->getMessage());
+		}
+	}
+
+	/**
+	 * @param object $object
+	 * @param array|object $data
+	 * @param bool $withEmpty
+	 * @return object
+	 * @throws ODMException
+	 */
+	public function updateObjectFromData(object $object, array|object $data, bool $withEmpty = true) : object {
+		try {
+			$class = get_class($object);
+			if(!isset(self::$classes[$class])) self::$classes[$class] = new ReflectionClass($class);
+			return self::fillObject(self::$classes[$class], clone $object, (is_object($data)) ? get_object_vars($data) : $data, true, $withEmpty);
+		}
+		catch (Exception $exception) {
+			throw new ODMException($exception->getMessage());
+		}
+	}
+
+	/**
+	 * @return array
+	 */
+	public function getRepositoryStack() : array {
+		return $this->getFillObjectStack();
+	}
+
+	/**
+	 * @return array
+	 */
+	public function getClassesCache() : array {
+		return self::$classes;
+	}
+
+	/**
+	 * @return array
+	 */
+	public function getAttributesObjectsCache() : array {
+		return self::$attributeObjects;
+	}
+
+	/**
+	 * @return array
+	 */
+	public function getConstructorEmptyAvailableClassesCache() : array {
+		return self::$constructorEmptyAvailableClasses;
+	}
+
+}