Exploite les nouvelles infos de PropertyMetadata pour les entités liées.

src/Models/Types/Objects/AnonymousObject.php

@@ -161,20 +161,6 @@ class AnonymousObject extends AbstractType implements Object
         return [];
     }
 
-    /**
-     * {@inheritdoc}
-     */
-    public function hasNonIdentifierProperty(): bool
-    {
-        foreach ($this->getProperties() as $prop) {
-            if (!$prop->isIdentifier()) {
-                return true;
-            }
-        }
-
-        return false;
-    }
-
     /**
      * {@inheritdoc}
      */

src/Models/Types/Objects/Object.php

@@ -30,9 +30,4 @@ interface Object extends Type
      * @return Property[]
      */
     public function getProperties(): array;
-
-    /**
-     * @return bool
-     */
-    public function hasNonIdentifierProperty(): bool;
 }

src/ResourceTypeFactory.php

@@ -200,85 +200,91 @@ final class ResourceTypeFactory implements TypeFactoryInterface
     private function mapProperties(array $propertiesMeta): array
     {
         $properties = [];
-        $hasIdentifier = false;
+        $identifierCount = 0;
 
         foreach ($propertiesMeta as $propertyMeta) {
             if (!$this->acceptProperty($propertyMeta)) {
                 continue;
             }
-            $property = $this->mapProperty($propertyMeta);
-            if ($property->isIdentifier()) {
-                if ($hasIdentifier) {
-                    throw new DomainException('Cannot handle resource with composite identifier');
-                }
-                $hasIdentifier = true;
+
+            if ($propertyMeta->isIdentifier()) {
+                ++$identifierCount;
             }
+
+            $property = $this->mapProperty($propertyMeta);
             $properties[$property->getName()] = $property;
         }
 
+        if ($identifierCount > 1) {
+            throw new DomainException('Cannot handle resource with composite identifier');
+        }
+
         return $properties;
     }
 
     /**
      * @param PropertyMetadata $propertyMeta
      *
-     * @return Property
+     * @return bool
      */
-    private function mapProperty(PropertyMetadata $propertyMeta): Property
+    public function acceptProperty(PropertyMetadata $propertyMeta): bool
     {
-        $typeMeta = $propertyMeta->getType();
+        if (!$propertyMeta->getType()) {
+            return false;
+        }
+        if ($this->context->isNormalization()) {
+            return $propertyMeta->isReadable();
+        }
 
-        return new Property(
-            $propertyMeta->getName(),
-            $propertyMeta->getDescription() ?: '',
-            $this->mapPropertyType($typeMeta),
-            $propertyMeta->isIdentifier(),
-            $typeMeta ? $typeMeta->isNullable() : false,
-            !$propertyMeta->isWritable()
-        );
+        return ($propertyMeta->getClassName() !== $this->context->getRootClass() && $propertyMeta->isIdentifier())
+            || $propertyMeta->isWritable()
+            || $propertyMeta->isInitializable();
     }
 
     /**
      * @param PropertyMetadata $propertyMeta
      *
-     * @return bool
+     * @return Property
      */
-    private function acceptProperty(PropertyMetadata $propertyMeta): bool
+    private function mapProperty(PropertyMetadata $propertyMeta): Property
     {
-        return $this->context->isNormalization() ? $propertyMeta->isReadable() : $propertyMeta->isWritable();
-    }
+        $typeMeta = $propertyMeta->getType();
+        \assert($typeMeta !== null);
 
-    /**
-     * @param null|\Symfony\Component\PropertyInfo\Type $typeMeta
-     *
-     * @return Type
-     */
-    private function mapPropertyType(?\Symfony\Component\PropertyInfo\Type $typeMeta): Type
-    {
-        if (!$typeMeta) {
-            return $this->typeFactory->get('any');
+        $collections = [];
+        $leafType = $typeMeta;
+        while ($leafType->getCollectionValueType()) {
+            $collections[] = $leafType->getCollectionKeyType();
+            $leafType = $leafType->getCollectionValueType();
         }
 
-        if ($typeMeta->isCollection()) {
-            $type = $this->mapPropertyType($typeMeta->getCollectionValueType());
-        } else {
-            $type = $this->get($typeMeta->getClassName() ?: $typeMeta->getBuiltinType());
-        }
+        if ($propertyMeta->isLink()) {
+            $linkedClassName = $leafType->getClassName();
+            $type = $this->typeFactory->getGenericRef('IRI<T>', [Placeholder::get(FQCN::baseName($linkedClassName))]);
 
-        $deref = $type->dereference();
-        if ($deref instanceof Representation) {
-            $iri = $this->typeFactory->getGenericRef('IRI<T>', [Placeholder::get($deref->getShortName())]);
-            if (!$deref->hasNonIdentifierProperty()) {
-                $type = $iri;
-            } elseif (!$this->context->isNormalization()) {
-                $type = Union::create([$type, $iri]);
+            if ($propertyMeta->isEmbedded()) {
+                $linkedType = $this->get($linkedClassName);
+                if ($this->context->isNormalization()) {
+                    $type = $linkedType;
+                } else {
+                    $type = Union::create([$type, $linkedType]);
+                }
             }
+        } else {
+            $type = $this->get($leafType->getClassName() ?: $leafType->getBuiltinType());
         }
 
-        if ($typeMeta->isCollection()) {
+        foreach (\array_reverse($collections) as $indexType) {
             $type = new Collection($type);
         }
 
-        return $type;
+        return new Property(
+            $propertyMeta->getName(),
+            $propertyMeta->getDescription() ?: '',
+            $type,
+            $propertyMeta->isIdentifier(),
+            $propertyMeta->isNullable() || ($propertyMeta->isIdentifier() && !$this->context->isNormalization()),
+            !$propertyMeta->isWritable()
+        );
     }
 }