Invalidate dependent elements

config/services.php

@@ -17,7 +17,9 @@
 use Neusta\Pimcore\HttpCacheBundle\Cache\ResponseTagger\RemoveDisabledTagsResponseTagger;
 use Neusta\Pimcore\HttpCacheBundle\CacheActivator;
 use Neusta\Pimcore\HttpCacheBundle\DataCollector;
+use Neusta\Pimcore\HttpCacheBundle\Element\DependencyInvalidator;
 use Neusta\Pimcore\HttpCacheBundle\Element\ElementRepository;
+use Neusta\Pimcore\HttpCacheBundle\Element\ElementsConfig;
 use Neusta\Pimcore\HttpCacheBundle\Element\InvalidateElementListener;
 use Neusta\Pimcore\HttpCacheBundle\Element\TagElementListener;
 use Symfony\Component\DependencyInjection\Loader\Configurator\ContainerConfigurator;
@@ -73,25 +75,34 @@
 
     $services->set('.neusta_pimcore_http_cache.element.repository', ElementRepository::class);
 
+    $services->set('neusta_pimcore_http_cache.elements_config', ElementsConfig::class)
+        ->factory([ElementsConfig::class, 'fromArray'])
+        ->arg('$config', []);
+
     $services->set('neusta_pimcore_http_cache.cache_tag_checker.element.asset', AssetCacheTagChecker::class)
         ->arg('$repository', service('.neusta_pimcore_http_cache.element.repository'))
-        ->arg('$config', ['enabled' => false, 'types' => []]);
+        ->arg('$config', service('neusta_pimcore_http_cache.elements_config'));
 
     $services->set('neusta_pimcore_http_cache.cache_tag_checker.element.document', DocumentCacheTagChecker::class)
         ->arg('$repository', service('.neusta_pimcore_http_cache.element.repository'))
-        ->arg('$config', ['enabled' => false, 'types' => []]);
+        ->arg('$config', service('neusta_pimcore_http_cache.elements_config'));
 
     $services->set('neusta_pimcore_http_cache.cache_tag_checker.element.object', ObjectCacheTagChecker::class)
         ->arg('$repository', service('.neusta_pimcore_http_cache.element.repository'))
-        ->arg('$config', ['enabled' => false, 'types' => [], 'classes' => []]);
+        ->arg('$config', service('neusta_pimcore_http_cache.elements_config'));
 
     $services->set('neusta_pimcore_http_cache.element.tag_listener', TagElementListener::class)
         ->arg('$responseTagger', service('neusta_pimcore_http_cache.response_tagger'))
         ->arg('$dispatcher', service('event_dispatcher'));
 
+    $services->set('neusta_pimcore_http_cache.element.dependency_invalidator', DependencyInvalidator::class)
+        ->arg('$elementRepository', service('.neusta_pimcore_http_cache.element.repository'))
+        ->arg('$config', service('neusta_pimcore_http_cache.elements_config'));
+
     $services->set('neusta_pimcore_http_cache.element.invalidate_listener', InvalidateElementListener::class)
         ->arg('$cacheInvalidator', service('neusta_pimcore_http_cache.cache_invalidator'))
-        ->arg('$dispatcher', service('event_dispatcher'));
+        ->arg('$dispatcher', service('event_dispatcher'))
+        ->arg('$dependencyInvalidator', service('neusta_pimcore_http_cache.element.dependency_invalidator'));
 
     $services->set('neusta_pimcore_http_cache.data_collector', DataCollector::class)
         ->arg('$cacheTagCollector', service('.neusta_pimcore_http_cache.collect_tags_response_tagger'))

doc/2-configuration.md

@@ -11,28 +11,52 @@ neusta_pimcore_http_cache:
             types:
                 archive: false
                 unknown: false
-
-            # Unless you disable assets completely
+
+            # Invalidate dependent elements when an asset changes (disabled by default).
+            # Note: a dependent element type must also be enabled above for invalidation to take effect.
+            invalidate_dependencies:
+                enabled: true
+                types:
+                    objects: true
+                    documents: true
+
+            # Or disable assets completely (mutually exclusive with the options above)
             enabled: false
-            
+
         documents:
             # By default, every type except "email", "folder" and "hardlink" is enabled
             types:
                 link: false
-
-            # Unless you disable documents completely
+
+            # Invalidate dependent elements when a document changes (disabled by default).
+            # Note: a dependent element type must also be enabled above for invalidation to take effect.
+            invalidate_dependencies:
+                enabled: true
+                types:
+                    objects: true
+
+            # Or disable documents completely (mutually exclusive with the options above)
             enabled: false
-            
+
         objects:
             # By default, every type except "folder" is enabled
             types:
                 variant: false
-            
+
             # By default, every data object class is enabled
             classes:
                 MyDataObjectClass: false
 
-            # Unless you disable data objects completely
+            # Invalidate dependent elements when an object changes (disabled by default).
+            # Note: a dependent element type must also be enabled above for invalidation to take effect.
+            invalidate_dependencies:
+                enabled: true
+                types:
+                    objects: true
+                    documents: true
+                    assets: true
+
+            # Or disable data objects completely (mutually exclusive with the options above)
             enabled: false
 
     # Enable/disable cache handling for custom cache types

doc/3-pimcore-elements.md

@@ -81,3 +81,67 @@ neusta_pimcore_http_cache:
             classes:
                 MyDataObjectClass: false
 ```
+
+## Dependent Element Invalidation
+
+When a Pimcore element is updated or deleted, other elements that reference it may also serve stale content.
+For example, a document that embeds a data object will be outdated as soon as that object changes.
+
+By default, the bundle only invalidates the cache tag of the element that was directly changed.
+Dependent element invalidation — traversing Pimcore's dependency graph to also purge referencing elements — is **disabled by default** and must be opted in via configuration.
+
+The dependency graph is one level deep: only elements that directly reference the changed element are invalidated, not transitive dependencies.
+
+> **Note:** For a dependent element type to actually be invalidated, it must also be enabled in the main `elements` configuration. For example, setting `objects.invalidate_dependencies.types.documents: true` has no effect if `documents` is disabled — the cache tag will be silently dropped.
+
+### Enable dependent invalidation for objects
+
+The most common use case is invalidating documents and other objects that reference a changed data object.
+The listed dependent types (`documents`, `objects`) must also be enabled in the `elements` configuration:
+
+```yaml
+neusta_pimcore_http_cache:
+    elements:
+        objects:
+            invalidate_dependencies:
+                enabled: true
+                types:
+                    documents: true  # invalidate documents that reference the object
+                    objects: true    # invalidate objects that reference the object
+                    assets: false    # leave assets out (default)
+        documents: true  # must be enabled for document invalidation to take effect
+```
+
+### Enable dependent invalidation for assets
+
+If an asset (e.g. an image) is referenced by objects or documents, those can be invalidated when the asset changes.
+The listed dependent types must also be enabled in the `elements` configuration:
+
+```yaml
+neusta_pimcore_http_cache:
+    elements:
+        assets:
+            invalidate_dependencies:
+                enabled: true
+                types:
+                    objects: true    # invalidate objects that reference the asset
+                    documents: true  # invalidate documents that reference the asset
+        objects: true    # must be enabled for object invalidation to take effect
+        documents: true  # must be enabled for document invalidation to take effect
+```
+
+### Enable dependent invalidation for documents
+
+If a document is referenced by other elements (e.g. an object with a document relation field), those elements can be invalidated when the document changes.
+The listed dependent types must also be enabled in the `elements` configuration:
+
+```yaml
+neusta_pimcore_http_cache:
+    elements:
+        documents:
+            invalidate_dependencies:
+                enabled: true
+                types:
+                    objects: true  # invalidate objects that reference the document
+        objects: true  # must be enabled for object invalidation to take effect
+```

src/Cache/CacheTagChecker/Element/AssetCacheTagChecker.php

@@ -7,15 +7,13 @@
 use Neusta\Pimcore\HttpCacheBundle\Cache\CacheType\ElementCacheType;
 use Neusta\Pimcore\HttpCacheBundle\Element\ElementRepository;
 use Neusta\Pimcore\HttpCacheBundle\Element\ElementType;
+use Neusta\Pimcore\HttpCacheBundle\Element\ElementsConfig;
 
 final class AssetCacheTagChecker implements CacheTagChecker
 {
-    /**
-     * @param array{enabled: bool, types: array<string, bool>} $config
-     */
     public function __construct(
         private readonly ElementRepository $repository,
-        private readonly array $config,
+        private readonly ElementsConfig $config,
     ) {
     }
 
@@ -24,14 +22,14 @@ public function isEnabled(CacheTag $tag): bool
         \assert($tag->type instanceof ElementCacheType, \sprintf('Cache type must be an instance of %s', ElementCacheType::class));
         \assert(ElementType::Asset === $tag->type->type, \sprintf('Cache type must be "%s"', ElementType::Asset->value));
 
-        if (!$this->config['enabled']) {
+        if (!$this->config->isEnabled(ElementType::Asset)) {
             return false;
         }
 
         if (!$asset = $this->repository->findAsset((int) $tag->tag)) {
             return false;
         }
 
-        return $this->config['types'][$asset->getType()] ?? true;
+        return $this->config->isTypeEnabled(ElementType::Asset, $asset->getType());
     }
 }

src/Cache/CacheTagChecker/Element/DocumentCacheTagChecker.php

@@ -7,15 +7,13 @@
 use Neusta\Pimcore\HttpCacheBundle\Cache\CacheType\ElementCacheType;
 use Neusta\Pimcore\HttpCacheBundle\Element\ElementRepository;
 use Neusta\Pimcore\HttpCacheBundle\Element\ElementType;
+use Neusta\Pimcore\HttpCacheBundle\Element\ElementsConfig;
 
 final class DocumentCacheTagChecker implements CacheTagChecker
 {
-    /**
-     * @param array{enabled: bool, types: array<string, bool>} $config
-     */
     public function __construct(
         private readonly ElementRepository $repository,
-        private readonly array $config,
+        private readonly ElementsConfig $config,
     ) {
     }
 
@@ -24,14 +22,14 @@ public function isEnabled(CacheTag $tag): bool
         \assert($tag->type instanceof ElementCacheType, \sprintf('Cache type must be an instance of %s', ElementCacheType::class));
         \assert(ElementType::Document === $tag->type->type, \sprintf('Cache type must be "%s"', ElementType::Document->value));
 
-        if (!$this->config['enabled']) {
+        if (!$this->config->isEnabled(ElementType::Document)) {
             return false;
         }
 
         if (!$document = $this->repository->findDocument((int) $tag->tag)) {
             return false;
         }
 
-        return $this->config['types'][$document->getType()] ?? true;
+        return $this->config->isTypeEnabled(ElementType::Document, $document->getType());
     }
 }

src/Cache/CacheTagChecker/Element/ObjectCacheTagChecker.php

@@ -7,16 +7,14 @@
 use Neusta\Pimcore\HttpCacheBundle\Cache\CacheType\ElementCacheType;
 use Neusta\Pimcore\HttpCacheBundle\Element\ElementRepository;
 use Neusta\Pimcore\HttpCacheBundle\Element\ElementType;
+use Neusta\Pimcore\HttpCacheBundle\Element\ElementsConfig;
 use Pimcore\Model\DataObject\Concrete;
 
 final class ObjectCacheTagChecker implements CacheTagChecker
 {
-    /**
-     * @param array{enabled: bool, types: array<string, bool>, classes: array<string, bool>} $config
-     */
     public function __construct(
         private readonly ElementRepository $repository,
-        private readonly array $config,
+        private readonly ElementsConfig $config,
     ) {
     }
 
@@ -25,22 +23,22 @@ public function isEnabled(CacheTag $tag): bool
         \assert($tag->type instanceof ElementCacheType, \sprintf('Cache type must be an instance of %s', ElementCacheType::class));
         \assert(ElementType::Object === $tag->type->type, \sprintf('Cache type must be "%s"', ElementType::Object->value));
 
-        if (!$this->config['enabled']) {
+        if (!$this->config->isEnabled(ElementType::Object)) {
             return false;
         }
 
         if (!$object = $this->repository->findObject((int) $tag->tag)) {
             return false;
         }
 
-        if (!($this->config['types'][$object->getType()] ?? true)) {
+        if (!$this->config->isTypeEnabled(ElementType::Object, $object->getType())) {
             return false;
         }
 
         if (!$object instanceof Concrete) {
             return true;
         }
 
-        return $this->config['classes'][$object->getClassName()] ?? true;
+        return $this->config->isClassEnabled($object->getClassName());
     }
 }

src/DependencyInjection/Configuration.php

@@ -37,6 +37,22 @@ public function getConfigTreeBuilder(): TreeBuilder
                                     ->defaultValue(['folder' => false])
                                     ->booleanPrototype()->end()
                                 ->end()
+                                ->arrayNode('invalidate_dependencies')
+                                    ->info('Enable/disable invalidation of dependent elements when an asset is updated or deleted.')
+                                    ->canBeEnabled()
+                                    ->addDefaultsIfNotSet()
+                                    ->children()
+                                        ->arrayNode('types')
+                                            ->info('Enable/disable invalidation of dependent element types.')
+                                            ->addDefaultsIfNotSet()
+                                            ->children()
+                                                ->booleanNode('assets')->defaultFalse()->end()
+                                                ->booleanNode('documents')->defaultFalse()->end()
+                                                ->booleanNode('objects')->defaultFalse()->end()
+                                            ->end()
+                                        ->end()
+                                    ->end()
+                                ->end()
                             ->end()
                         ->end()
                         ->arrayNode('documents')
@@ -54,6 +70,22 @@ public function getConfigTreeBuilder(): TreeBuilder
                                     ->defaultValue(['email' => false, 'folder' => false, 'hardlink' => false])
                                     ->booleanPrototype()->end()
                                 ->end()
+                                ->arrayNode('invalidate_dependencies')
+                                    ->info('Enable/disable invalidation of dependent elements when a document is updated or deleted.')
+                                    ->canBeEnabled()
+                                    ->addDefaultsIfNotSet()
+                                    ->children()
+                                        ->arrayNode('types')
+                                            ->info('Enable/disable invalidation of dependent element types.')
+                                            ->addDefaultsIfNotSet()
+                                            ->children()
+                                                ->booleanNode('assets')->defaultFalse()->end()
+                                                ->booleanNode('documents')->defaultFalse()->end()
+                                                ->booleanNode('objects')->defaultFalse()->end()
+                                            ->end()
+                                        ->end()
+                                    ->end()
+                                ->end()
                             ->end()
                         ->end()
                         ->arrayNode('objects')
@@ -79,6 +111,22 @@ public function getConfigTreeBuilder(): TreeBuilder
                                     ->defaultValue([])
                                     ->booleanPrototype()->end()
                                 ->end()
+                                ->arrayNode('invalidate_dependencies')
+                                    ->info('Enable/disable invalidation of dependent elements when an object is updated or deleted.')
+                                    ->canBeEnabled()
+                                    ->addDefaultsIfNotSet()
+                                    ->children()
+                                        ->arrayNode('types')
+                                            ->info('Enable/disable invalidation of dependent element types.')
+                                            ->addDefaultsIfNotSet()
+                                            ->children()
+                                                ->booleanNode('assets')->defaultFalse()->end()
+                                                ->booleanNode('documents')->defaultFalse()->end()
+                                                ->booleanNode('objects')->defaultFalse()->end()
+                                            ->end()
+                                        ->end()
+                                    ->end()
+                                ->end()
                             ->end()
                         ->end()
                     ->end()

src/DependencyInjection/NeustaPimcoreHttpCacheExtension.php

@@ -35,10 +35,10 @@ private function registerElements(ContainerBuilder $container, array $config): v
         $tagListener = $container->getDefinition('neusta_pimcore_http_cache.element.tag_listener');
         $invalidateListener = $container->getDefinition('neusta_pimcore_http_cache.element.invalidate_listener');
 
-        if ($config['assets']['enabled']) {
-            $container->getDefinition('neusta_pimcore_http_cache.cache_tag_checker.element.asset')
-                ->setArgument('$config', $config['assets']);
+        $container->getDefinition('neusta_pimcore_http_cache.elements_config')
+            ->setArgument('$config', $config);
 
+        if ($config['assets']['enabled']) {
             $tagListener
                 ->addTag('kernel.event_listener', ['event' => AssetEvents::POST_LOAD]);
 
@@ -48,9 +48,6 @@ private function registerElements(ContainerBuilder $container, array $config): v
         }
 
         if ($config['documents']['enabled']) {
-            $container->getDefinition('neusta_pimcore_http_cache.cache_tag_checker.element.document')
-                ->setArgument('$config', $config['documents']);
-
             $tagListener
                 ->addTag('kernel.event_listener', ['event' => DocumentEvents::POST_LOAD]);
 
@@ -60,9 +57,6 @@ private function registerElements(ContainerBuilder $container, array $config): v
         }
 
         if ($config['objects']['enabled']) {
-            $container->getDefinition('neusta_pimcore_http_cache.cache_tag_checker.element.object')
-                ->setArgument('$config', $config['objects']);
-
             $tagListener
                 ->addTag('kernel.event_listener', ['event' => DataObjectEvents::POST_LOAD]);