Allow abstract resource

Api/ResourceResolverTrait.php

@@ -67,6 +67,13 @@ public function guessResource($object, array $context = null, $strict = false)
         }
 
         if ($strict && isset($isObject) && $resource->getEntityClass() !== $type) {
+            if (is_subclass_of($type, $resource->getEntityClass())) {
+                $resource = $this->resourceCollection->getResourceForEntity($type);
+                if (null !== $resource) {
+                    return $resource;
+                }
+            }
+
             throw new InvalidArgumentException(
                 sprintf('No resource found for object of type "%s"', $type)
             );

DependencyInjection/Compiler/ResourcePass.php

@@ -42,25 +42,41 @@ public function process(ContainerBuilder $container)
                 continue;
             }
 
+            $isAbstract = $this->isAbstract($resourceDefinition->getArgument(0));
             if (!$resourceDefinition->hasMethodCall('initItemOperations')) {
-                $resourceDefinition->addMethodCall('initItemOperations', [[
-                    $this->createOperation($container, $serviceId, 'GET', false),
-                    $this->createOperation($container, $serviceId, 'PUT', false),
-                    $this->createOperation($container, $serviceId, 'DELETE', false),
-                ]]);
+                $methods = $isAbstract ? ['GET', 'DELETE'] : ['GET', 'PUT', 'DELETE'];
+                $resourceDefinition->addMethodCall('initItemOperations', [$this->createOperations($container, $serviceId, $methods, false)]);
             }
 
             if (!$resourceDefinition->hasMethodCall('initCollectionOperations')) {
-                $resourceDefinition->addMethodCall('initCollectionOperations', [[
-                    $this->createOperation($container, $serviceId, 'GET', true),
-                    $this->createOperation($container, $serviceId, 'POST', true),
-                ]]);
+                $methods = $isAbstract ? ['GET'] : ['GET', 'POST'];
+                $resourceDefinition->addMethodCall('initCollectionOperations', [$this->createOperations($container, $serviceId, $methods, true)]);
             }
         }
 
         $resourceCollectionDefinition->addMethodCall('init', [$resourceReferences]);
     }
 
+    /**
+     * Adds a list of operations.
+     *
+     * @param ContainerBuilder $container
+     * @param string           $serviceId
+     * @param array            $methods
+     * @param bool             $collection
+     *
+     * @return Reference[]
+     */
+    private function createOperations(ContainerBuilder $container, $serviceId, $methods, $collection)
+    {
+        $operations = [];
+        foreach ($methods as $method) {
+            $operations[] = $this->createOperation($container, $serviceId, $method, $collection);
+        }
+
+        return $operations;
+    }
+
     /**
      * Adds an operation.
      *
@@ -94,6 +110,20 @@ private function createOperation(ContainerBuilder $container, $serviceId, $metho
         return new Reference($operationId);
     }
 
+    /**
+     * Returns if the given class is abstract.
+     *
+     * @param string $instanceClass
+     *
+     * @return bool
+     */
+    private function isAbstract($instanceClass)
+    {
+        $reflectionClass = new \ReflectionClass($instanceClass);
+
+        return $reflectionClass->isAbstract();
+    }
+
     /**
      * Gets class of the given definition.
      *

JsonLd/Serializer/ItemNormalizer.php

@@ -199,8 +199,6 @@ public function denormalize($data, $class, $format = null, array $context = [])
             }
         }
 
-        $reflectionClass = new \ReflectionClass($class);
-
         if (isset($data['@id']) && !isset($context['object_to_populate'])) {
             $context['object_to_populate'] = $this->iriConverter->getItemFromIri($data['@id']);
 
@@ -210,9 +208,20 @@ public function denormalize($data, $class, $format = null, array $context = [])
             $overrideClass = false;
         }
 
+        $instanceClass = $overrideClass ? get_class($context['object_to_populate']) : $class;
+        $reflectionClass = new \ReflectionClass($instanceClass);
+        if ($reflectionClass->isAbstract()) {
+            throw new InvalidArgumentException(
+                sprintf(
+                    'Cannot create an instance of %s from serialized data because it is an abstract resource',
+                    $instanceClass
+                )
+            );
+        }
+
         $object = $this->instantiateObject(
             $normalizedData,
-            $overrideClass ? get_class($context['object_to_populate']) : $class,
+            $instanceClass,
             $context,
             $reflectionClass,
             $allowedAttributes

Tests/Behat/TestBundle/Entity/AbstractDummy.php

@@ -0,0 +1,61 @@
+<?php
+
+/*
+ * This file is part of the DunglasApiBundle package.
+ *
+ * (c) Kévin Dunglas <dunglas@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Dunglas\ApiBundle\Tests\Behat\TestBundle\Entity;
+
+use Doctrine\ORM\Mapping as ORM;
+use Dunglas\ApiBundle\Annotation\Iri;
+use Symfony\Component\Validator\Constraints as Assert;
+
+/**
+ * AbstractDummy.
+ *
+ * @author Jérémy Derussé <jeremy@derusse.com>
+ *
+ * @ORM\Entity
+ * @ORM\InheritanceType("SINGLE_TABLE")
+ * @ORM\DiscriminatorColumn(name="discr", type="string", length=16)
+ * @ORM\DiscriminatorMap({"concrete" = "ConcreteDummy"})
+ */
+abstract class AbstractDummy
+{
+    /**
+     * @var int The id.
+     *
+     * @ORM\Column(type="integer")
+     * @ORM\Id
+     * @ORM\GeneratedValue(strategy="AUTO")
+     */
+    private $id;
+    /**
+     * @var string The dummy name.
+     *
+     * @ORM\Column
+     * @Assert\NotBlank
+     * @Iri("http://schema.org/name")
+     */
+    private $name;
+
+    public function getId()
+    {
+        return $this->id;
+    }
+
+    public function setName($name)
+    {
+        $this->name = $name;
+    }
+
+    public function getName()
+    {
+        return $this->name;
+    }
+}

Tests/Behat/TestBundle/Entity/ConcreteDummy.php

@@ -0,0 +1,43 @@
+<?php
+
+/*
+ * This file is part of the DunglasApiBundle package.
+ *
+ * (c) Kévin Dunglas <dunglas@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Dunglas\ApiBundle\Tests\Behat\TestBundle\Entity;
+
+use Doctrine\ORM\Mapping as ORM;
+use Symfony\Component\Validator\Constraints as Assert;
+
+/**
+ * ConcreteDummy.
+ *
+ * @author Jérémy Derusse <jeremy@derusse.com>
+ *
+ * @ORM\Entity
+ */
+class ConcreteDummy extends AbstractDummy
+{
+    /**
+     * @var string a concrete thing
+     *
+     * @ORM\Column
+     * @Assert\NotBlank
+     */
+    private $instance;
+
+    public function setInstance($instance)
+    {
+        $this->instance = $instance;
+    }
+
+    public function getInstance()
+    {
+        return $this->instance;
+    }
+}

Tests/DependencyInjection/Compiler/ResourcePassTest.php

@@ -37,6 +37,7 @@ public function testProcess()
 
         $builtinResourceDefinitionProphecy = $this->prophesize('Symfony\Component\DependencyInjection\Definition');
         $builtinResourceDefinitionProphecy->getClass()->willReturn('Dunglas\ApiBundle\Api\Resource')->shouldBeCalled();
+        $builtinResourceDefinitionProphecy->getArgument(0)->willReturn('stdClass')->shouldBeCalled();
         $builtinResourceDefinitionProphecy->hasMethodCall('initItemOperations')->willReturn(true)->shouldBeCalled();
         $builtinResourceDefinitionProphecy->addMethodCall('initItemOperations')->shouldNotBeCalled();
         $builtinResourceDefinitionProphecy->hasMethodCall('initCollectionOperations', Argument::any())->willReturn(true)->shouldBeCalled();
@@ -50,6 +51,7 @@ public function testProcess()
         $decoratedResourceDefinitionProphecy = $this->prophesize('Symfony\Component\DependencyInjection\DefinitionDecorator');
         $decoratedResourceDefinitionProphecy->getClass()->willReturn(false)->shouldBeCalled();
         $decoratedResourceDefinitionProphecy->getParent()->willReturn('inner_resource')->shouldBeCalled();
+        $decoratedResourceDefinitionProphecy->getArgument(0)->willReturn('stdClass')->shouldBeCalled();
         $decoratedResourceDefinitionProphecy->hasMethodCall('initItemOperations')->willReturn(false)->shouldBeCalled();
         $decoratedResourceDefinitionProphecy->addMethodCall('initItemOperations', Argument::type('array'))->shouldBeCalled();
         $decoratedResourceDefinitionProphecy->hasMethodCall('initCollectionOperations')->willReturn(false)->shouldBeCalled();

features/crud_abstract.feature

@@ -0,0 +1,129 @@
+Feature: Create-Retrieve-Update-Delete on abstract resource
+  In order to use an hypermedia API
+  As a client software developer
+  I need to be able to retrieve, create, update and delete JSON-LD encoded resources even if they are abstract.
+
+  @createSchema
+  Scenario: Create a concrete resource
+    When I send a "POST" request to "/concrete_dummies" with body:
+    """
+    {
+      "instance": "Concrete",
+      "name": "My Dummy"
+    }
+    """
+    Then the response status code should be 201
+    And the response should be in JSON
+    And the header "Content-Type" should be equal to "application/ld+json"
+    And the JSON should be equal to:
+    """
+    {
+      "@context": "/contexts/ConcreteDummy",
+      "@id": "/concrete_dummies/1",
+      "@type": "ConcreteDummy",
+      "instance": "Concrete",
+      "name": "My Dummy"
+    }
+    """
+
+  Scenario: Get a resource
+    When I send a "GET" request to "/abstract_dummies/1"
+    Then the response status code should be 200
+    And the response should be in JSON
+    And the header "Content-Type" should be equal to "application/ld+json"
+    And the JSON should be equal to:
+    """
+    {
+      "@context": "/contexts/ConcreteDummy",
+      "@id": "/concrete_dummies/1",
+      "@type": "ConcreteDummy",
+      "instance": "Concrete",
+      "name": "My Dummy"
+    }
+    """
+
+  Scenario: Get a collection
+    When I send a "GET" request to "/abstract_dummies"
+    Then the response status code should be 200
+    And the response should be in JSON
+    And the header "Content-Type" should be equal to "application/ld+json"
+    And the JSON should be equal to:
+    """
+    {
+      "@context": "/contexts/AbstractDummy",
+      "@id": "/abstract_dummies",
+      "@type": "hydra:PagedCollection",
+      "hydra:totalItems": 1,
+      "hydra:itemsPerPage": 3,
+      "hydra:firstPage": "/abstract_dummies",
+      "hydra:lastPage": "/abstract_dummies",
+      "hydra:member": [
+        {
+          "@id":"/concrete_dummies/1",
+          "@type":"ConcreteDummy",
+          "instance": "Concrete",
+          "name": "My Dummy"
+        }
+      ],
+      "hydra:search": {
+              "@type": "hydra:IriTemplate",
+              "hydra:template": "\/abstract_dummies{?id,name,order[id],order[name]}",
+              "hydra:variableRepresentation": "BasicRepresentation",
+              "hydra:mapping": [
+                  {
+                      "@type": "IriTemplateMapping",
+                      "variable": "id",
+                      "property": "id",
+                      "required": false
+                  },
+                  {
+                      "@type": "IriTemplateMapping",
+                      "variable": "name",
+                      "property": "name",
+                      "required": false
+                  },
+                  {
+                      "@type": "IriTemplateMapping",
+                      "variable": "order[id]",
+                      "property": "id",
+                      "required": false
+                  },
+                  {
+                      "@type": "IriTemplateMapping",
+                      "variable": "order[name]",
+                      "property": "name",
+                      "required": false
+                  }
+              ]
+      }
+    }
+    """
+
+  Scenario: Update a concrete resource
+      When I send a "PUT" request to "/concrete_dummies/1" with body:
+      """
+      {
+        "@id": "/concrete_dummies/1",
+        "instance": "Become real",
+        "name": "A nice dummy"
+      }
+      """
+      Then the response status code should be 200
+      And the response should be in JSON
+      And the header "Content-Type" should be equal to "application/ld+json"
+      And the JSON should be equal to:
+      """
+      {
+        "@context": "/contexts/ConcreteDummy",
+        "@id": "/concrete_dummies/1",
+        "@type": "ConcreteDummy",
+        "instance": "Become real",
+        "name": "A nice dummy"
+      }
+      """
+
+  @dropSchema
+  Scenario: Delete a resource
+    When I send a "DELETE" request to "/abstract_dummies/1"
+    Then the response status code should be 204
+    And the response should be empty

features/fixtures/TestApp/config/config.yml

@@ -112,6 +112,19 @@ services:
                                               -      "@my_relation_embedder_resource.item_operation.custom_get"
         tags:                       [ { name: "api.resource" } ]
 
+    my_abstract_dummy_resource:
+        parent:                      "api.resource"
+        arguments:                   [ "Dunglas\ApiBundle\Tests\Behat\TestBundle\Entity\AbstractDummy" ]
+        calls:
+                                     - method:    "initFilters"
+                                       arguments: [ [ "@my_dummy_resource.search_filter", "@my_dummy_resource.order_filter", "@my_dummy_resource.date_filter" ] ]
+        tags:                        [ { name: "api.resource" } ]
+
+    my_concrete_dummy_resource:
+        parent:                      "api.resource"
+        arguments:                   [ "Dunglas\ApiBundle\Tests\Behat\TestBundle\Entity\ConcreteDummy" ]
+        tags:                        [ { name: "api.resource" } ]
+
     custom_resource:
         parent:                     "api.resource"
         class:                      "Dunglas\ApiBundle\Tests\Behat\TestBundle\Api\CustomResource"