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

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