How to do optional cross-bundle associations in Symfony 2?

I have finally managed to rig up a solution to this problem which would be suited for my project. As an introduction, I should say that the bundles in my architecture are laid out "star-like". By that I mean that I have one core or base bundle which serves as the base dependency module and is present in all the projects. All other bundles can rely on it and only it. There are no direct dependencies between my other bundles. I'm quite certain that this proposed solution would work in this case because of the simplicity in the architecture. I should also say that I fear there could be debugging issues involved with this method, but it could be made so that it is easily switched on or off, depending on a configuration setting, for instance.

The basic idea is to rig up my own ResolveTargetEntityListener, which would skip relating the entities if the related entity is missing. This would allow the process of execution to continue if there is a class bound to the interface missing. There's probably no need to emphasize the implication of the typo in the configuration - the class won't be found and this can produce a hard-to-debug error. That's why I'd advise to turn it off during the development phase and then turn it back on in the production. This way, all the possible errors will be pointed out by the Doctrine.

Implementation

The implementation consists of reusing the ResolveTargetEntityListener's code and putting some additional code inside the remapAssociation method. This is my final implementation:

<?phpnamespace Name\MyBundle\Core;use Doctrine\ORM\Event\LoadClassMetadataEventArgs;use Doctrine\ORM\Mapping\ClassMetadata;class ResolveTargetEntityListener{    /**     * @var array     */    private $resolveTargetEntities = array();    /**     * Add a target-entity class name to resolve to a new class name.     *     * @param string $originalEntity     * @param string $newEntity     * @param array $mapping     * @return void     */    public function addResolveTargetEntity($originalEntity, $newEntity, array $mapping)    {        $mapping['targetEntity'] = ltrim($newEntity, "\\");        $this->resolveTargetEntities[ltrim($originalEntity, "\\")] = $mapping;    }    /**     * Process event and resolve new target entity names.     *     * @param LoadClassMetadataEventArgs $args     * @return void     */    public function loadClassMetadata(LoadClassMetadataEventArgs $args)    {        $cm = $args->getClassMetadata();        foreach ($cm->associationMappings as $mapping) {            if (isset($this->resolveTargetEntities[$mapping['targetEntity']])) {                $this->remapAssociation($cm, $mapping);            }        }    }    private function remapAssociation($classMetadata, $mapping)    {        $newMapping = $this->resolveTargetEntities[$mapping['targetEntity']];        $newMapping = array_replace_recursive($mapping, $newMapping);        $newMapping['fieldName'] = $mapping['fieldName'];        unset($classMetadata->associationMappings[$mapping['fieldName']]);        // Silently skip mapping the association if the related entity is missing        if (class_exists($newMapping['targetEntity']) === false)        {            return;        }        switch ($mapping['type'])        {            case ClassMetadata::MANY_TO_MANY:                $classMetadata->mapManyToMany($newMapping);                break;            case ClassMetadata::MANY_TO_ONE:                $classMetadata->mapManyToOne($newMapping);                break;            case ClassMetadata::ONE_TO_MANY:                $classMetadata->mapOneToMany($newMapping);                break;            case ClassMetadata::ONE_TO_ONE:                $classMetadata->mapOneToOne($newMapping);                break;        }    }}

Note the silent return before the switch statement which is used to map the entity relations. If the related entity's class does not exist, the method just returns, rather than executing faulty mapping and producing the error. This also has the implication of a field missing (if it's not a many-to-many relation). The foreign key in that case will just be missing inside the database, but as it exists in the entity class, all the code is still valid (you won't get a missing method error if accidentally calling the foreign key's getter or setter).

Putting it to use

To be able to use this code, you just have to change one parameter. You should put this updated parameter to a services file which will always be loaded or some other similar place. The goal is to have it at a place that will always be used, no matter what bundles you are going to use. I've put it in my base bundle services file:

doctrine.orm.listeners.resolve_target_entity.class: Name\MyBundle\Core\ResolveTargetEntityListener

This will redirect the original ResolveTargetEntityListener to your version. You should also clear and warm your cache after putting it in place, just in case.

Testing

I have done only a couple of simple tests which have proven that this approach might work as expected. I intend to use this method frequently in the next couple of weeks and will be following up on it if the need arises. I also hope to get some useful feedback from other people who decide to give it a go.

You could create loose dependencies between ContactInfo and any other entities by having an extra field in ContactInfo to differentiate entities (e.g. $entityName). Another required field would be $objectId to point to objects of specific entities. So in order to link User with ContactInfo, you don't need any actual relational mappings.

If you want to create a ContactInfo for a $user object, you need to manually instantiate it and simply setEntityName(get_class($user)), setObjectId($user->getId()). To retrieve user ContactInfo, or that of any object, you can create a generic function that accepts $object. It could simply just return ...findBy(array('entityName' => get_class($user), 'objectId' => $object->getId());

With this approach, you could still create User form with ContactInfo (embed ContactInfo into User). Though after you process the form, you will need to persist User first and flush, and then persist ContactInfo. Of course this is only necessary for newly created User objects, just so to get user id. Put all persist/flush in a transaction if you're concerned about data integrity.