How to abstract Symfony 3 Entity logic?

Question

Repository is the correct place for it?

As it says in the Symfony documentation, methods containing your query logic can then be stored in Repository class (https://symfony.com/doc/current/doctrine/repository.html).

So, where you should stored Entity methods like create, update or delete to reuse it in other parts of the code?

For exemple, I want to reuse Product create logic:

$em = $this->getDoctrine()->getManager();

$product = new Product();
$product->setName('Keyboard');

$em->persist($product);
$em->flush();

My questions are:

• Should I create a new service or just add this in my ProductRepository if it just contains query logic (e.g. INSERT new entity in the exemple)?

• Should I create a service (ProductManager) that contains all three methods (create, update, delete)? Or should I create three different services (ProductCreate, ProductUpdate, ProductDelete) to comply the Single Responsibility Principle?

• Should I create a service for each Entity (ProductService, ItemService, etc.) or should I create a common service (EntityManager)?
• Is there any other better solution?

My solution (updated 5 Oct 2017):

Entity:

interface Entity
{
    public function getId();
}

class Product implements Entity
{
    private $id;

    public function getId()
    {
        return $this->id;
    }

    // ...
}

Repository:

interface Repository
{
    public function create(Entity $entity);

     // ...
}

interface ProductRepository extends Repository
{
    // ...
}

abstract class BaseDoctrineRepository extends Doctrine\ORM\EntityRepository
{
    public function create(Entity $entity)
    {
        $this->_em->persist($entity);
        $this->_em->flush();
    }

    // ...
}

class ProductDoctrineRepository extends BaseDoctrineRepository implements ProductRepository
{
    // ...
}

Service:

class ProductService
{    
    private $productRepository;

    public function __construct(ProductRepository $productRepository)
    {
        $this->productRepository = $productRepository;
    }

    public function create($name)
    {
        $product = new Product();
        $product->setName($name);

        $this->productRepository->create($product);

        return $product;
    }
}

How to create new Product:

$productService = new ProductService();
$productService->create('product name');

How to create new Product using Dependency Injection:

public function foo(ProductService $productService)
{
    $productService->create('product name');
}

Answer 1

create a common service implementing interface that contains create, update, delete, merge ... methods for each entityManager connection. For example, if you are some like configuration you need to create two common services DefaultManager (for entities in AppBundle and AcmeStoreBundle) and customerManager (for entities in AcmeCustomerBundle) services implementing the same interface:

orm:
        default_entity_manager: default
        entity_managers:
            default:
                connection: default
                mappings:
                    AppBundle:  ~
                    AcmeStoreBundle: ~
            customer:
                connection: customer
                mappings:
                    AcmeCustomerBundle: ~ 

Or you can add abstract class Manager implementing an interface and two Common manager extending abstract class and redefine methods as needed.

Answer 2

According to SRP, code in your question should be split.

These parts belong to domain layer, service layer, and persistence layer accordingly:

//Entity constructor
public function __construct()
{
    $this->name = ('Keyboard');
}
//service for product creation
public function createNewProduct()
{
    $product = new Product();
    $repository->save($product);  
}
//repository
public function save(Product $product) 
{
    $this->em->persist($product);
    $this->em->flush();
}

Should I create a new service or just add this in my ProductRepository if it just contains query logic?

This is not quite clear to me, since you have no query logic in your question. You might want to update your question to clarify this point.

Or should I create three different services (ProductCreate, ProductUpdate, ProductDelete) to comply the Single Responsibility Principle?

You definitely should. Even if these services will share some boilerplate code(like injecting Repository or Logger service, logging itself), they will not share business logic.

Should I create a service for each Entity (ProductService, ItemService, etc.) or should I create a common service (EntityManager)?

Common service might work depending on your domain, but I wouldn't advice for it.