vendor/shopware/core/Framework/Adapter/Cache/CacheInvalidationSubscriber.php line 433

  1. <?php declare(strict_types=1);
  3. namespace Shopware\Core\Framework\Adapter\Cache;
  5. use Doctrine\DBAL\ArrayParameterType;
  6. use Doctrine\DBAL\Connection;
  7. use Shopware\Core\Checkout\Cart\CachedRuleLoader;
  8. use Shopware\Core\Checkout\Customer\Aggregate\CustomerGroup\CustomerGroupDefinition;
  9. use Shopware\Core\Checkout\Payment\PaymentMethodDefinition;
  10. use Shopware\Core\Checkout\Payment\SalesChannel\CachedPaymentMethodRoute;
  11. use Shopware\Core\Checkout\Shipping\SalesChannel\CachedShippingMethodRoute;
  12. use Shopware\Core\Checkout\Shipping\ShippingMethodDefinition;
  13. use Shopware\Core\Content\Category\CategoryDefinition;
  14. use Shopware\Core\Content\Category\Event\CategoryIndexerEvent;
  15. use Shopware\Core\Content\Category\SalesChannel\CachedCategoryRoute;
  16. use Shopware\Core\Content\Category\SalesChannel\CachedNavigationRoute;
  17. use Shopware\Core\Content\Cms\CmsPageDefinition;
  18. use Shopware\Core\Content\LandingPage\Event\LandingPageIndexerEvent;
  19. use Shopware\Core\Content\LandingPage\SalesChannel\CachedLandingPageRoute;
  20. use Shopware\Core\Content\Product\Aggregate\ProductCategory\ProductCategoryDefinition;
  21. use Shopware\Core\Content\Product\Aggregate\ProductCrossSelling\ProductCrossSellingDefinition;
  22. use Shopware\Core\Content\Product\Aggregate\ProductManufacturer\ProductManufacturerDefinition;
  23. use Shopware\Core\Content\Product\Aggregate\ProductProperty\ProductPropertyDefinition;
  24. use Shopware\Core\Content\Product\Events\ProductChangedEventInterface;
  25. use Shopware\Core\Content\Product\Events\ProductIndexerEvent;
  26. use Shopware\Core\Content\Product\Events\ProductNoLongerAvailableEvent;
  27. use Shopware\Core\Content\Product\ProductDefinition;
  28. use Shopware\Core\Content\Product\SalesChannel\CrossSelling\CachedProductCrossSellingRoute;
  29. use Shopware\Core\Content\Product\SalesChannel\Detail\CachedProductDetailRoute;
  30. use Shopware\Core\Content\Product\SalesChannel\Listing\CachedProductListingRoute;
  31. use Shopware\Core\Content\Product\SalesChannel\Review\CachedProductReviewRoute;
  32. use Shopware\Core\Content\ProductStream\ProductStreamDefinition;
  33. use Shopware\Core\Content\Property\Aggregate\PropertyGroupOption\PropertyGroupOptionDefinition;
  34. use Shopware\Core\Content\Property\Aggregate\PropertyGroupOptionTranslation\PropertyGroupOptionTranslationDefinition;
  35. use Shopware\Core\Content\Property\Aggregate\PropertyGroupTranslation\PropertyGroupTranslationDefinition;
  36. use Shopware\Core\Content\Property\PropertyGroupDefinition;
  37. use Shopware\Core\Content\Rule\Event\RuleIndexerEvent;
  38. use Shopware\Core\Content\Seo\CachedSeoResolver;
  39. use Shopware\Core\Content\Seo\Event\SeoUrlUpdateEvent;
  40. use Shopware\Core\Content\Sitemap\Event\SitemapGeneratedEvent;
  41. use Shopware\Core\Content\Sitemap\SalesChannel\CachedSitemapRoute;
  42. use Shopware\Core\Defaults;
  43. use Shopware\Core\Framework\Adapter\Translation\Translator;
  44. use Shopware\Core\Framework\DataAbstractionLayer\Cache\EntityCacheKeyGenerator;
  45. use Shopware\Core\Framework\DataAbstractionLayer\Event\EntityWrittenContainerEvent;
  46. use Shopware\Core\Framework\Log\Package;
  47. use Shopware\Core\Framework\Plugin\Event\PluginPostActivateEvent;
  48. use Shopware\Core\Framework\Plugin\Event\PluginPostDeactivateEvent;
  49. use Shopware\Core\Framework\Plugin\Event\PluginPostInstallEvent;
  50. use Shopware\Core\Framework\Plugin\Event\PluginPostUninstallEvent;
  51. use Shopware\Core\Framework\Plugin\Event\PluginPostUpdateEvent;
  52. use Shopware\Core\Framework\Uuid\Uuid;
  53. use Shopware\Core\System\Country\Aggregate\CountryState\CountryStateDefinition;
  54. use Shopware\Core\System\Country\CountryDefinition;
  55. use Shopware\Core\System\Country\SalesChannel\CachedCountryRoute;
  56. use Shopware\Core\System\Country\SalesChannel\CachedCountryStateRoute;
  57. use Shopware\Core\System\Currency\CurrencyDefinition;
  58. use Shopware\Core\System\Currency\SalesChannel\CachedCurrencyRoute;
  59. use Shopware\Core\System\Language\LanguageDefinition;
  60. use Shopware\Core\System\Language\SalesChannel\CachedLanguageRoute;
  61. use Shopware\Core\System\SalesChannel\Aggregate\SalesChannelCountry\SalesChannelCountryDefinition;
  62. use Shopware\Core\System\SalesChannel\Aggregate\SalesChannelCurrency\SalesChannelCurrencyDefinition;
  63. use Shopware\Core\System\SalesChannel\Aggregate\SalesChannelLanguage\SalesChannelLanguageDefinition;
  64. use Shopware\Core\System\SalesChannel\Aggregate\SalesChannelPaymentMethod\SalesChannelPaymentMethodDefinition;
  65. use Shopware\Core\System\SalesChannel\Aggregate\SalesChannelShippingMethod\SalesChannelShippingMethodDefinition;
  66. use Shopware\Core\System\SalesChannel\Context\CachedBaseContextFactory;
  67. use Shopware\Core\System\SalesChannel\Context\CachedSalesChannelContextFactory;
  68. use Shopware\Core\System\SalesChannel\SalesChannelDefinition;
  69. use Shopware\Core\System\Salutation\SalesChannel\CachedSalutationRoute;
  70. use Shopware\Core\System\Salutation\SalutationDefinition;
  71. use Shopware\Core\System\Snippet\SnippetDefinition;
  72. use Shopware\Core\System\StateMachine\Loader\InitialStateIdLoader;
  73. use Shopware\Core\System\StateMachine\StateMachineDefinition;
  74. use Shopware\Core\System\SystemConfig\CachedSystemConfigLoader;
  75. use Shopware\Core\System\SystemConfig\Event\SystemConfigChangedEvent;
  76. use Shopware\Core\System\SystemConfig\SystemConfigService;
  77. use Shopware\Core\System\Tax\TaxDefinition;
  78. use Symfony\Component\EventDispatcher\EventSubscriberInterface;
  80. /**
  81.  * @internal - The functions inside this class are no public-api and can be changed without previous deprecation
  82.  */
  83. #[Package('core')]
  84. class CacheInvalidationSubscriber implements EventSubscriberInterface
  85. {
  86.     public function __construct(
  87.         private readonly CacheInvalidator $cacheInvalidator,
  88.         private readonly Connection $connection
  89.     ) {
  90.     }
  92.     /**
  93.      * @return array<string, string|array{0: string, 1: int}|list<array{0: string, 1?: int}>>
  94.      */
  95.     public static function getSubscribedEvents(): array
  96.     {
  97.         return [
  98.             CategoryIndexerEvent::class => [
  99.                 ['invalidateCategoryRouteByCategoryIds', 2000],
  100.                 ['invalidateListingRouteByCategoryIds', 2001],
  101.             ],
  102.             LandingPageIndexerEvent::class => [
  103.                 ['invalidateIndexedLandingPages', 2000],
  104.             ],
  105.             ProductIndexerEvent::class => [
  106.                 ['invalidateSearch', 2000],
  107.                 ['invalidateListings', 2001],
  108.                 ['invalidateProductIds', 2002],
  109.                 ['invalidateDetailRoute', 2004],
  110.                 ['invalidateStreamsAfterIndexing', 2005],
  111.                 ['invalidateReviewRoute', 2006],
  112.             ],
  113.             ProductNoLongerAvailableEvent::class => [
  114.                 ['invalidateSearch', 2000],
  115.                 ['invalidateListings', 2001],
  116.                 ['invalidateProductIds', 2002],
  117.                 ['invalidateDetailRoute', 2004],
  118.                 ['invalidateStreamsAfterIndexing', 2005],
  119.                 ['invalidateReviewRoute', 2006],
  120.             ],
  121.             EntityWrittenContainerEvent::class => [
  122.                 ['invalidateCmsPageIds', 2001],
  123.                 ['invalidateCurrencyRoute', 2002],
  124.                 ['invalidateLanguageRoute', 2003],
  125.                 ['invalidateNavigationRoute', 2004],
  126.                 ['invalidatePaymentMethodRoute', 2005],
  127.                 ['invalidateProductAssignment', 2006],
  128.                 ['invalidateManufacturerFilters', 2007],
  129.                 ['invalidatePropertyFilters', 2008],
  130.                 ['invalidateCrossSellingRoute', 2009],
  131.                 ['invalidateContext', 2010],
  132.                 ['invalidateShippingMethodRoute', 2011],
  133.                 ['invalidateSnippets', 2012],
  134.                 ['invalidateStreamsBeforeIndexing', 2013],
  135.                 ['invalidateStreamIds', 2014],
  136.                 ['invalidateCountryRoute', 2015],
  137.                 ['invalidateSalutationRoute', 2016],
  138.                 ['invalidateInitialStateIdLoader', 2017],
  139.                 ['invalidateCountryStateRoute', 2018],
  140.             ],
  141.             SeoUrlUpdateEvent::class => [
  142.                 ['invalidateSeoUrls', 2000],
  143.             ],
  144.             RuleIndexerEvent::class => [
  145.                 ['invalidateRules', 2000],
  146.             ],
  147.             PluginPostInstallEvent::class => [
  148.                 ['invalidateRules', 2000],
  149.                 ['invalidateConfig', 2001],
  150.             ],
  151.             PluginPostActivateEvent::class => [
  152.                 ['invalidateRules', 2000],
  153.                 ['invalidateConfig', 2001],
  154.             ],
  155.             PluginPostUpdateEvent::class => [
  156.                 ['invalidateRules', 2000],
  157.                 ['invalidateConfig', 2001],
  158.             ],
  159.             PluginPostDeactivateEvent::class => [
  160.                 ['invalidateRules', 2000],
  161.                 ['invalidateConfig', 2001],
  162.             ],
  163.             PluginPostUninstallEvent::class => [
  164.                 ['invalidateRules', 2000],
  165.                 ['invalidateConfig', 2001],
  166.             ],
  167.             SystemConfigChangedEvent::class => [
  168.                 ['invalidateConfigKey', 2000],
  169.             ],
  170.             SitemapGeneratedEvent::class => [
  171.                 ['invalidateSitemap', 2000],
  172.             ],
  173.         ];
  174.     }
  176.     public function invalidateInitialStateIdLoader(EntityWrittenContainerEvent $event): void
  177.     {
  178.         if (!$event->getPrimaryKeys(StateMachineDefinition::ENTITY_NAME)) {
  179.             return;
  180.         }
  182.         $this->cacheInvalidator->invalidate([InitialStateIdLoader::CACHE_KEY]);
  183.     }
  185.     public function invalidateSitemap(SitemapGeneratedEvent $event): void
  186.     {
  187.         $this->cacheInvalidator->invalidate([
  188.             CachedSitemapRoute::buildName($event->getSalesChannelContext()->getSalesChannelId()),
  189.         ]);
  190.     }
  192.     public function invalidateConfig(): void
  193.     {
  194.         // invalidates the complete cached config
  195.         $this->cacheInvalidator->invalidate([
  196.             CachedSystemConfigLoader::CACHE_TAG,
  197.         ]);
  198.     }
  200.     public function invalidateConfigKey(SystemConfigChangedEvent $event): void
  201.     {
  202.         // invalidates the complete cached config and routes which access a specific key
  203.         $this->cacheInvalidator->invalidate([
  204.             SystemConfigService::buildName($event->getKey()),
  205.             CachedSystemConfigLoader::CACHE_TAG,
  206.         ]);
  207.     }
  209.     public function invalidateSnippets(EntityWrittenContainerEvent $event): void
  210.     {
  211.         // invalidates all http cache items where the snippets used
  212.         $snippets = $event->getEventByEntityName(SnippetDefinition::ENTITY_NAME);
  214.         if (!$snippets) {
  215.             return;
  216.         }
  218.         $tags = [];
  219.         foreach ($snippets->getPayloads() as $payload) {
  220.             if (isset($payload['translationKey'])) {
  221.                 $tags[] = Translator::buildName($payload['translationKey']);
  222.             }
  223.         }
  224.         $this->cacheInvalidator->invalidate($tags);
  225.     }
  227.     public function invalidateShippingMethodRoute(EntityWrittenContainerEvent $event): void
  228.     {
  229.         // checks if a shipping method changed or the assignment between shipping method and sales channel
  230.         $logs = [...$this->getChangedShippingMethods($event), ...$this->getChangedShippingAssignments($event)];
  232.         $this->cacheInvalidator->invalidate($logs);
  233.     }
  235.     public function invalidateSeoUrls(SeoUrlUpdateEvent $event): void
  236.     {
  237.         // invalidates the cache for the seo url resolver based on the path infos which used for the new seo urls
  238.         $urls = $event->getSeoUrls();
  240.         $pathInfo = array_column($urls, 'pathInfo');
  242.         $this->cacheInvalidator->invalidate(array_map([CachedSeoResolver::class, 'buildName'], $pathInfo));
  243.     }
  245.     public function invalidateRules(): void
  246.     {
  247.         // invalidates the rule loader each time a rule changed or a plugin install state changed
  248.         $this->cacheInvalidator->invalidate([CachedRuleLoader::CACHE_KEY]);
  249.     }
  251.     public function invalidateCmsPageIds(EntityWrittenContainerEvent $event): void
  252.     {
  253.         // invalidates all routes and http cache pages where a cms page was loaded, the id is assigned as tag
  254.         $this->cacheInvalidator->invalidate(
  255.             array_map(EntityCacheKeyGenerator::buildCmsTag(...), $event->getPrimaryKeys(CmsPageDefinition::ENTITY_NAME))
  256.         );
  257.     }
  259.     public function invalidateProductIds(ProductChangedEventInterface $event): void
  260.     {
  261.         // invalidates all routes which loads products in nested unknown objects, like cms listing elements or cross selling elements
  262.         $this->cacheInvalidator->invalidate(
  263.             array_map(EntityCacheKeyGenerator::buildProductTag(...), $event->getIds())
  264.         );
  265.     }
  267.     public function invalidateStreamIds(EntityWrittenContainerEvent $event): void
  268.     {
  269.         // invalidates all routes which are loaded based on a stream (e.G. category listing and cross selling)
  270.         $this->cacheInvalidator->invalidate(
  271.             array_map(EntityCacheKeyGenerator::buildStreamTag(...), $event->getPrimaryKeys(ProductStreamDefinition::ENTITY_NAME))
  272.         );
  273.     }
  275.     public function invalidateCategoryRouteByCategoryIds(CategoryIndexerEvent $event): void
  276.     {
  277.         // invalidates the category route cache when a category changed
  278.         $this->cacheInvalidator->invalidate(
  279.             array_map([CachedCategoryRoute::class, 'buildName'], $event->getIds())
  280.         );
  281.     }
  283.     public function invalidateListingRouteByCategoryIds(CategoryIndexerEvent $event): void
  284.     {
  285.         // invalidates the product listing route each time a category changed
  286.         $this->cacheInvalidator->invalidate(
  287.             array_map([CachedProductListingRoute::class, 'buildName'], $event->getIds())
  288.         );
  289.     }
  291.     public function invalidateIndexedLandingPages(LandingPageIndexerEvent $event): void
  292.     {
  293.         // invalidates the landing page route, if the corresponding landing page changed
  294.         $this->cacheInvalidator->invalidate(
  295.             array_map([CachedLandingPageRoute::class, 'buildName'], $event->getIds())
  296.         );
  297.     }
  299.     public function invalidateCurrencyRoute(EntityWrittenContainerEvent $event): void
  300.     {
  301.         // invalidates the currency route when a currency changed or an assignment between the sales channel and currency changed
  302.         $this->cacheInvalidator->invalidate([...$this->getChangedCurrencyAssignments($event), ...$this->getChangedCurrencies($event)]);
  303.     }
  305.     public function invalidateLanguageRoute(EntityWrittenContainerEvent $event): void
  306.     {
  307.         // invalidates the language route when a language changed or an assignment between the sales channel and language changed
  308.         $this->cacheInvalidator->invalidate([...$this->getChangedLanguageAssignments($event), ...$this->getChangedLanguages($event)]);
  309.     }
  311.     public function invalidateCountryRoute(EntityWrittenContainerEvent $event): void
  312.     {
  313.         // invalidates the country route when a country changed or an assignment between the sales channel and country changed
  314.         $this->cacheInvalidator->invalidate([...$this->getChangedCountryAssignments($event), ...$this->getChangedCountries($event)]);
  315.     }
  317.     public function invalidateCountryStateRoute(EntityWrittenContainerEvent $event): void
  318.     {
  319.         $tags = [];
  320.         if (
  321.             $event->getDeletedPrimaryKeys(CountryStateDefinition::ENTITY_NAME)
  322.             || $event->getPrimaryKeysWithPropertyChange(CountryStateDefinition::ENTITY_NAME, ['countryId'])
  323.         ) {
  324.             $tags[] = CachedCountryStateRoute::ALL_TAG;
  325.         }
  327.         if (empty($tags)) {
  328.             // invalidates the country-state route when a state changed or an assignment between the state and country changed
  329.             $tags = array_map(
  330.                 [CachedCountryStateRoute::class, 'buildName'],
  331.                 $event->getPrimaryKeys(CountryDefinition::ENTITY_NAME)
  332.             );
  333.         }
  335.         $this->cacheInvalidator->invalidate($tags);
  336.     }
  338.     public function invalidateSalutationRoute(EntityWrittenContainerEvent $event): void
  339.     {
  340.         // invalidates the salutation route when a salutation changed
  341.         $this->cacheInvalidator->invalidate([...$this->getChangedSalutations($event)]);
  342.     }
  344.     public function invalidateNavigationRoute(EntityWrittenContainerEvent $event): void
  345.     {
  346.         // invalidates the navigation route when a category changed or the entry point configuration of an sales channel changed
  347.         $logs = [...$this->getChangedCategories($event), ...$this->getChangedEntryPoints($event)];
  349.         $this->cacheInvalidator->invalidate($logs);
  350.     }
  352.     public function invalidatePaymentMethodRoute(EntityWrittenContainerEvent $event): void
  353.     {
  354.         // invalidates the payment method route when a payment method changed or an assignment between the sales channel and payment method changed
  355.         $logs = [...$this->getChangedPaymentMethods($event), ...$this->getChangedPaymentAssignments($event)];
  357.         $this->cacheInvalidator->invalidate($logs);
  358.     }
  360.     public function invalidateSearch(): void
  361.     {
  362.         // invalidates the search and suggest route each time a product changed
  363.         $this->cacheInvalidator->invalidate([
  364.             'product-suggest-route',
  365.             'product-search-route',
  366.         ]);
  367.     }
  369.     public function invalidateDetailRoute(ProductChangedEventInterface $event): void
  370.     {
  371.         //invalidates the product detail route each time a product changed or if the product is no longer available (because out of stock)
  372.         $this->cacheInvalidator->invalidate(
  373.             array_map([CachedProductDetailRoute::class, 'buildName'], $event->getIds())
  374.         );
  375.     }
  377.     public function invalidateProductAssignment(EntityWrittenContainerEvent $event): void
  378.     {
  379.         //invalidates the product listing route, each time a product - category assignment changed
  380.         $ids = $event->getPrimaryKeys(ProductCategoryDefinition::ENTITY_NAME);
  382.         $ids = array_column($ids, 'categoryId');
  384.         $this->cacheInvalidator->invalidate(
  385.             array_map([CachedProductListingRoute::class, 'buildName'], $ids)
  386.         );
  387.     }
  389.     public function invalidateContext(EntityWrittenContainerEvent $event): void
  390.     {
  391.         //invalidates the context cache - each time one of the entities which are considered inside the context factory changed
  392.         $ids = $event->getPrimaryKeys(SalesChannelDefinition::ENTITY_NAME);
  393.         $keys = array_map([CachedSalesChannelContextFactory::class, 'buildName'], $ids);
  394.         $keys = array_merge($keys, array_map([CachedBaseContextFactory::class, 'buildName'], $ids));
  396.         if ($event->getEventByEntityName(CurrencyDefinition::ENTITY_NAME)) {
  397.             $keys[] = CachedSalesChannelContextFactory::ALL_TAG;
  398.         }
  400.         if ($event->getEventByEntityName(PaymentMethodDefinition::ENTITY_NAME)) {
  401.             $keys[] = CachedSalesChannelContextFactory::ALL_TAG;
  402.         }
  404.         if ($event->getEventByEntityName(ShippingMethodDefinition::ENTITY_NAME)) {
  405.             $keys[] = CachedSalesChannelContextFactory::ALL_TAG;
  406.         }
  408.         if ($event->getEventByEntityName(TaxDefinition::ENTITY_NAME)) {
  409.             $keys[] = CachedSalesChannelContextFactory::ALL_TAG;
  410.         }
  412.         if ($event->getEventByEntityName(CountryDefinition::ENTITY_NAME)) {
  413.             $keys[] = CachedSalesChannelContextFactory::ALL_TAG;
  414.         }
  416.         if ($event->getEventByEntityName(CustomerGroupDefinition::ENTITY_NAME)) {
  417.             $keys[] = CachedSalesChannelContextFactory::ALL_TAG;
  418.         }
  420.         if ($event->getEventByEntityName(LanguageDefinition::ENTITY_NAME)) {
  421.             $keys[] = CachedSalesChannelContextFactory::ALL_TAG;
  422.         }
  424.         $keys = array_filter(array_unique($keys));
  426.         if (empty($keys)) {
  427.             return;
  428.         }
  430.         $this->cacheInvalidator->invalidate($keys);
  431.     }
  433.     public function invalidateManufacturerFilters(EntityWrittenContainerEvent $event): void
  434.     {
  435.         // invalidates the product listing route, each time a manufacturer changed
  436.         $ids = $event->getPrimaryKeys(ProductManufacturerDefinition::ENTITY_NAME);
  438.         if (empty($ids)) {
  439.             return;
  440.         }
  442.         $ids = $this->connection->fetchFirstColumn(
  443.             'SELECT DISTINCT LOWER(HEX(category_id)) as category_id
  444.              FROM product_category_tree
  445.                 INNER JOIN product ON product.id = product_category_tree.product_id AND product_category_tree.product_version_id = product.version_id
  446.              WHERE product.product_manufacturer_id IN (:ids)
  447.              AND product.version_id = :version',
  448.             ['ids' => Uuid::fromHexToBytesList($ids), 'version' => Uuid::fromHexToBytes(Defaults::LIVE_VERSION)],
  449.             ['ids' => ArrayParameterType::STRING]
  450.         );
  452.         $this->cacheInvalidator->invalidate(
  453.             array_map([CachedProductListingRoute::class, 'buildName'], $ids)
  454.         );
  455.     }
  457.     public function invalidatePropertyFilters(EntityWrittenContainerEvent $event): void
  458.     {
  459.         $this->cacheInvalidator->invalidate([...$this->getChangedPropertyFilterTags($event), ...$this->getDeletedPropertyFilterTags($event)]);
  460.     }
  462.     public function invalidateReviewRoute(ProductChangedEventInterface $event): void
  463.     {
  464.         $this->cacheInvalidator->invalidate(
  465.             array_map([CachedProductReviewRoute::class, 'buildName'], $event->getIds())
  466.         );
  467.     }
  469.     public function invalidateListings(ProductChangedEventInterface $event): void
  470.     {
  471.         // invalidates product listings which are based on the product category assignment
  472.         $this->cacheInvalidator->invalidate(
  473.             array_map([CachedProductListingRoute::class, 'buildName'], $this->getProductCategoryIds($event->getIds()))
  474.         );
  475.     }
  477.     public function invalidateStreamsBeforeIndexing(EntityWrittenContainerEvent $event): void
  478.     {
  479.         // invalidates all stream based pages and routes before the product indexer changes product_stream_mapping
  480.         $ids = $event->getPrimaryKeys(ProductDefinition::ENTITY_NAME);
  482.         if (empty($ids)) {
  483.             return;
  484.         }
  486.         // invalidates product listings which are based on a product stream
  487.         $ids = $this->connection->fetchFirstColumn(
  488.             'SELECT DISTINCT LOWER(HEX(product_stream_id))
  489.              FROM product_stream_mapping
  490.              WHERE product_stream_mapping.product_id IN (:ids)
  491.              AND product_stream_mapping.product_version_id = :version',
  492.             ['ids' => Uuid::fromHexToBytesList($ids), 'version' => Uuid::fromHexToBytes(Defaults::LIVE_VERSION)],
  493.             ['ids' => ArrayParameterType::STRING]
  494.         );
  496.         $this->cacheInvalidator->invalidate(
  497.             array_map(EntityCacheKeyGenerator::buildStreamTag(...), $ids)
  498.         );
  499.     }
  501.     public function invalidateStreamsAfterIndexing(ProductChangedEventInterface $event): void
  502.     {
  503.         // invalidates all stream based pages and routes after the product indexer changes product_stream_mapping
  504.         $ids = $this->connection->fetchFirstColumn(
  505.             'SELECT DISTINCT LOWER(HEX(product_stream_id))
  506.              FROM product_stream_mapping
  507.              WHERE product_stream_mapping.product_id IN (:ids)
  508.              AND product_stream_mapping.product_version_id = :version',
  509.             ['ids' => Uuid::fromHexToBytesList($event->getIds()), 'version' => Uuid::fromHexToBytes(Defaults::LIVE_VERSION)],
  510.             ['ids' => ArrayParameterType::STRING]
  511.         );
  513.         $this->cacheInvalidator->invalidate(
  514.             array_map(EntityCacheKeyGenerator::buildStreamTag(...), $ids)
  515.         );
  516.     }
  518.     public function invalidateCrossSellingRoute(EntityWrittenContainerEvent $event): void
  519.     {
  520.         // invalidates the product detail route for the changed cross selling definitions
  521.         $ids = $event->getPrimaryKeys(ProductCrossSellingDefinition::ENTITY_NAME);
  523.         if (empty($ids)) {
  524.             return;
  525.         }
  527.         $ids = $this->connection->fetchFirstColumn(
  528.             'SELECT DISTINCT LOWER(HEX(product_id)) FROM product_cross_selling WHERE id IN (:ids)',
  529.             ['ids' => Uuid::fromHexToBytesList($ids)],
  530.             ['ids' => ArrayParameterType::STRING]
  531.         );
  533.         $this->cacheInvalidator->invalidate(
  534.             array_map([CachedProductCrossSellingRoute::class, 'buildName'], $ids)
  535.         );
  536.     }
  538.     /**
  539.      * @return list<string>
  540.      */
  541.     private function getDeletedPropertyFilterTags(EntityWrittenContainerEvent $event): array
  542.     {
  543.         // invalidates the product listing route, each time a property changed
  544.         $ids = $event->getDeletedPrimaryKeys(ProductPropertyDefinition::ENTITY_NAME);
  546.         if (empty($ids)) {
  547.             return [];
  548.         }
  550.         $productIds = array_column($ids, 'productId');
  552.         return array_merge(
  553.             array_map([CachedProductDetailRoute::class, 'buildName'], array_unique($productIds)),
  554.             array_map([CachedProductListingRoute::class, 'buildName'], $this->getProductCategoryIds($productIds))
  555.         );
  556.     }
  558.     /**
  559.      * @return list<string>
  560.      */
  561.     private function getChangedPropertyFilterTags(EntityWrittenContainerEvent $event): array
  562.     {
  563.         // invalidates the product listing route and detail rule, each time a property group changed
  564.         $propertyGroupIds = array_unique(array_merge(
  565.             $event->getPrimaryKeysWithPayloadIgnoringFields(PropertyGroupDefinition::ENTITY_NAME, ['id', 'updatedAt']),
  566.             array_column($event->getPrimaryKeysWithPayloadIgnoringFields(PropertyGroupTranslationDefinition::ENTITY_NAME, ['propertyGroupId', 'languageId', 'updatedAt']), 'propertyGroupId')
  567.         ));
  569.         // invalidates the product listing route and detail rule, each time a property option changed
  570.         $propertyOptionIds = array_unique(array_merge(
  571.             $event->getPrimaryKeysWithPayloadIgnoringFields(PropertyGroupOptionDefinition::ENTITY_NAME, ['id', 'updatedAt']),
  572.             array_column($event->getPrimaryKeysWithPayloadIgnoringFields(PropertyGroupOptionTranslationDefinition::ENTITY_NAME, ['propertyGroupOptionId', 'languageId', 'updatedAt']), 'propertyGroupOptionId')
  573.         ));
  575.         if (empty($propertyGroupIds) && empty($propertyOptionIds)) {
  576.             return [];
  577.         }
  579.         $productIds = $this->connection->fetchFirstColumn(
  580.             'SELECT product_property.product_id
  581.              FROM product_property
  582.                 LEFT JOIN property_group_option productProperties ON productProperties.id = product_property.property_group_option_id
  583.              WHERE productProperties.property_group_id IN (:ids) OR productProperties.id IN (:optionIds)
  584.              AND product_property.product_version_id = :version',
  585.             ['ids' => Uuid::fromHexToBytesList($propertyGroupIds), 'optionIds' => Uuid::fromHexToBytesList($propertyOptionIds), 'version' => Uuid::fromHexToBytes(Defaults::LIVE_VERSION)],
  586.             ['ids' => ArrayParameterType::STRING, 'optionIds' => ArrayParameterType::STRING]
  587.         );
  588.         $productIds = array_unique([...$productIds, ...$this->connection->fetchFirstColumn(
  589.             'SELECT product_option.product_id
  590.                  FROM product_option
  591.                     LEFT JOIN property_group_option productOptions ON productOptions.id = product_option.property_group_option_id
  592.                  WHERE productOptions.property_group_id IN (:ids) OR productOptions.id IN (:optionIds)
  593.                  AND product_option.product_version_id = :version',
  594.             ['ids' => Uuid::fromHexToBytesList($propertyGroupIds), 'optionIds' => Uuid::fromHexToBytesList($propertyOptionIds), 'version' => Uuid::fromHexToBytes(Defaults::LIVE_VERSION)],
  595.             ['ids' => ArrayParameterType::STRING, 'optionIds' => ArrayParameterType::STRING]
  596.         )]);
  598.         if (empty($productIds)) {
  599.             return [];
  600.         }
  602.         $parentIds = $this->connection->fetchFirstColumn(
  603.             'SELECT DISTINCT LOWER(HEX(COALESCE(parent_id, id)))
  604.             FROM product
  605.             WHERE id in (:productIds) AND version_id = :version',
  606.             ['productIds' => $productIds, 'version' => Uuid::fromHexToBytes(Defaults::LIVE_VERSION)],
  607.             ['productIds' => ArrayParameterType::STRING]
  608.         );
  610.         $categoryIds = $this->connection->fetchFirstColumn(
  611.             'SELECT DISTINCT LOWER(HEX(category_id))
  612.             FROM product_category_tree
  613.             WHERE product_id in (:productIds) AND product_version_id = :version',
  614.             ['productIds' => $productIds, 'version' => Uuid::fromHexToBytes(Defaults::LIVE_VERSION)],
  615.             ['productIds' => ArrayParameterType::STRING]
  616.         );
  618.         return [...array_map([CachedProductDetailRoute::class, 'buildName'], array_filter($parentIds)), ...array_map([CachedProductListingRoute::class, 'buildName'], array_filter($categoryIds))];
  619.     }
  621.     /**
  622.      * @param list<string> $ids
  623.      *
  624.      * @return list<string>
  625.      */
  626.     private function getProductCategoryIds(array $ids): array
  627.     {
  628.         return $this->connection->fetchFirstColumn(
  629.             'SELECT DISTINCT LOWER(HEX(category_id)) as category_id
  630.              FROM product_category_tree
  631.              WHERE product_id IN (:ids)
  632.              AND product_version_id = :version
  633.              AND category_version_id = :version',
  634.             ['ids' => Uuid::fromHexToBytesList($ids), 'version' => Uuid::fromHexToBytes(Defaults::LIVE_VERSION)],
  635.             ['ids' => ArrayParameterType::STRING]
  636.         );
  637.     }
  639.     /**
  640.      * @return list<string>
  641.      */
  642.     private function getChangedShippingMethods(EntityWrittenContainerEvent $event): array
  643.     {
  644.         $ids = $event->getPrimaryKeys(ShippingMethodDefinition::ENTITY_NAME);
  645.         if (empty($ids)) {
  646.             return [];
  647.         }
  649.         $ids = $this->connection->fetchFirstColumn(
  650.             'SELECT DISTINCT LOWER(HEX(sales_channel_id)) as id FROM sales_channel_shipping_method WHERE shipping_method_id IN (:ids)',
  651.             ['ids' => Uuid::fromHexToBytesList($ids)],
  652.             ['ids' => ArrayParameterType::STRING]
  653.         );
  655.         $tags = [];
  656.         if ($event->getDeletedPrimaryKeys(ShippingMethodDefinition::ENTITY_NAME)) {
  657.             $tags[] = CachedShippingMethodRoute::ALL_TAG;
  658.         }
  660.         return array_merge($tags, array_map([CachedShippingMethodRoute::class, 'buildName'], $ids));
  661.     }
  663.     /**
  664.      * @return list<string>
  665.      */
  666.     private function getChangedShippingAssignments(EntityWrittenContainerEvent $event): array
  667.     {
  668.         //Used to detect changes to the shipping assignment of a sales channel
  669.         $ids = $event->getPrimaryKeys(SalesChannelShippingMethodDefinition::ENTITY_NAME);
  671.         $ids = array_column($ids, 'salesChannelId');
  673.         return array_map([CachedShippingMethodRoute::class, 'buildName'], $ids);
  674.     }
  676.     /**
  677.      * @return list<string>
  678.      */
  679.     private function getChangedPaymentMethods(EntityWrittenContainerEvent $event): array
  680.     {
  681.         $ids = $event->getPrimaryKeys(PaymentMethodDefinition::ENTITY_NAME);
  682.         if (empty($ids)) {
  683.             return [];
  684.         }
  686.         $ids = $this->connection->fetchFirstColumn(
  687.             'SELECT DISTINCT LOWER(HEX(sales_channel_id)) as id FROM sales_channel_payment_method WHERE payment_method_id IN (:ids)',
  688.             ['ids' => Uuid::fromHexToBytesList($ids)],
  689.             ['ids' => ArrayParameterType::STRING]
  690.         );
  692.         $tags = [];
  693.         if ($event->getDeletedPrimaryKeys(PaymentMethodDefinition::ENTITY_NAME)) {
  694.             $tags[] = CachedPaymentMethodRoute::ALL_TAG;
  695.         }
  697.         return array_merge($tags, array_map([CachedPaymentMethodRoute::class, 'buildName'], $ids));
  698.     }
  700.     /**
  701.      * @return list<string>
  702.      */
  703.     private function getChangedPaymentAssignments(EntityWrittenContainerEvent $event): array
  704.     {
  705.         //Used to detect changes to the language assignment of a sales channel
  706.         $ids = $event->getPrimaryKeys(SalesChannelPaymentMethodDefinition::ENTITY_NAME);
  708.         $ids = array_column($ids, 'salesChannelId');
  710.         return array_map([CachedPaymentMethodRoute::class, 'buildName'], $ids);
  711.     }
  713.     /**
  714.      * @return list<string>
  715.      */
  716.     private function getChangedCategories(EntityWrittenContainerEvent $event): array
  717.     {
  718.         $ids = $event->getPrimaryKeysWithPayload(CategoryDefinition::ENTITY_NAME);
  720.         if (empty($ids)) {
  721.             return [];
  722.         }
  724.         $ids = array_map([CachedNavigationRoute::class, 'buildName'], $ids);
  725.         $ids[] = CachedNavigationRoute::BASE_NAVIGATION_TAG;
  727.         return $ids;
  728.     }
  730.     /**
  731.      * @return list<string>
  732.      */
  733.     private function getChangedEntryPoints(EntityWrittenContainerEvent $event): array
  734.     {
  735.         $ids = $event->getPrimaryKeysWithPropertyChange(
  736.             SalesChannelDefinition::ENTITY_NAME,
  737.             ['navigationCategoryId', 'navigationCategoryDepth', 'serviceCategoryId', 'footerCategoryId']
  738.         );
  740.         if (empty($ids)) {
  741.             return [];
  742.         }
  744.         return [CachedNavigationRoute::ALL_TAG];
  745.     }
  747.     /**
  748.      * @return list<string>
  749.      */
  750.     private function getChangedCountries(EntityWrittenContainerEvent $event): array
  751.     {
  752.         $ids = $event->getPrimaryKeys(CountryDefinition::ENTITY_NAME);
  753.         if (empty($ids)) {
  754.             return [];
  755.         }
  757.         //Used to detect changes to the country itself and invalidate the route for all sales channels in which the country is assigned.
  758.         $ids = $this->connection->fetchFirstColumn(
  759.             'SELECT DISTINCT LOWER(HEX(sales_channel_id)) as id FROM sales_channel_country WHERE country_id IN (:ids)',
  760.             ['ids' => Uuid::fromHexToBytesList($ids)],
  761.             ['ids' => ArrayParameterType::STRING]
  762.         );
  764.         $tags = [];
  765.         if ($event->getDeletedPrimaryKeys(CountryDefinition::ENTITY_NAME)) {
  766.             $tags[] = CachedCountryRoute::ALL_TAG;
  767.         }
  769.         return array_merge($tags, array_map([CachedCountryRoute::class, 'buildName'], $ids));
  770.     }
  772.     /**
  773.      * @return list<string>
  774.      */
  775.     private function getChangedCountryAssignments(EntityWrittenContainerEvent $event): array
  776.     {
  777.         //Used to detect changes to the country assignment of a sales channel
  778.         $ids = $event->getPrimaryKeys(SalesChannelCountryDefinition::ENTITY_NAME);
  780.         $ids = array_column($ids, 'salesChannelId');
  782.         return array_map([CachedCountryRoute::class, 'buildName'], $ids);
  783.     }
  785.     /**
  786.      * @return list<string>
  787.      */
  788.     private function getChangedSalutations(EntityWrittenContainerEvent $event): array
  789.     {
  790.         $ids = $event->getPrimaryKeys(SalutationDefinition::ENTITY_NAME);
  791.         if (empty($ids)) {
  792.             return [];
  793.         }
  795.         return [CachedSalutationRoute::ALL_TAG];
  796.     }
  798.     /**
  799.      * @return list<string>
  800.      */
  801.     private function getChangedLanguages(EntityWrittenContainerEvent $event): array
  802.     {
  803.         $ids = $event->getPrimaryKeys(LanguageDefinition::ENTITY_NAME);
  804.         if (empty($ids)) {
  805.             return [];
  806.         }
  808.         //Used to detect changes to the language itself and invalidate the route for all sales channels in which the language is assigned.
  809.         $ids = $this->connection->fetchFirstColumn(
  810.             'SELECT DISTINCT LOWER(HEX(sales_channel_id)) as id FROM sales_channel_language WHERE language_id IN (:ids)',
  811.             ['ids' => Uuid::fromHexToBytesList($ids)],
  812.             ['ids' => ArrayParameterType::STRING]
  813.         );
  815.         $tags = [];
  816.         if ($event->getDeletedPrimaryKeys(LanguageDefinition::ENTITY_NAME)) {
  817.             $tags[] = CachedLanguageRoute::ALL_TAG;
  818.         }
  820.         return array_merge($tags, array_map([CachedLanguageRoute::class, 'buildName'], $ids));
  821.     }
  823.     /**
  824.      * @return list<string>
  825.      */
  826.     private function getChangedLanguageAssignments(EntityWrittenContainerEvent $event): array
  827.     {
  828.         //Used to detect changes to the language assignment of a sales channel
  829.         $ids = $event->getPrimaryKeys(SalesChannelLanguageDefinition::ENTITY_NAME);
  831.         $ids = array_column($ids, 'salesChannelId');
  833.         return array_map([CachedLanguageRoute::class, 'buildName'], $ids);
  834.     }
  836.     /**
  837.      * @return list<string>
  838.      */
  839.     private function getChangedCurrencies(EntityWrittenContainerEvent $event): array
  840.     {
  841.         $ids = $event->getPrimaryKeys(CurrencyDefinition::ENTITY_NAME);
  843.         if (empty($ids)) {
  844.             return [];
  845.         }
  847.         //Used to detect changes to the currency itself and invalidate the route for all sales channels in which the currency is assigned.
  848.         $ids = $this->connection->fetchFirstColumn(
  849.             'SELECT DISTINCT LOWER(HEX(sales_channel_id)) as id FROM sales_channel_currency WHERE currency_id IN (:ids)',
  850.             ['ids' => Uuid::fromHexToBytesList($ids)],
  851.             ['ids' => ArrayParameterType::STRING]
  852.         );
  854.         $tags = [];
  855.         if ($event->getDeletedPrimaryKeys(CurrencyDefinition::ENTITY_NAME)) {
  856.             $tags[] = CachedCurrencyRoute::ALL_TAG;
  857.         }
  859.         return array_merge($tags, array_map([CachedCurrencyRoute::class, 'buildName'], $ids));
  860.     }
  862.     /**
  863.      * @return list<string>
  864.      */
  865.     private function getChangedCurrencyAssignments(EntityWrittenContainerEvent $event): array
  866.     {
  867.         //Used to detect changes to the currency assignment of a sales channel
  868.         $ids = $event->getPrimaryKeys(SalesChannelCurrencyDefinition::ENTITY_NAME);
  870.         $ids = array_column($ids, 'salesChannelId');
  872.         return array_map([CachedCurrencyRoute::class, 'buildName'], $ids);
  873.     }
  874. }