Fix: variant selector missing on freshly-added price tier rows

The PRE_SET_DATA listener in PriceTierType added the productVariant
field only when $priceTier->getProduct() was non-null. Existing tiers
loaded from the DB had it set; brand-new tiers added via the LiveCollectionType
"Add" button did not, because Live Components builds the new row's form
*before* ProductTrait::addPriceTier() assigns the backreference.

Mirror Sylius core's product-images pattern: forward the parent product
down through entry_options.

- PriceTierType: drop the PRE_SET_DATA listener; add a `product` option
  (ProductInterface|null, default null); add the productVariant field
  unconditionally whenever the option is set.
- PriceTierCollectionType: replace the static entry_options default
  with a normalizer that always merges `label => false` with whatever
  the caller passes (so an externally-passed `product` doesn't wipe
  the label default).
- ProductTypeExtension: pass `entry_options.product => $options['data']`
  when adding the priceTiers field; falls back to null on the create
  page where the parent product hasn't been instantiated yet.

Test updates (form tests):
- PriceTierTypeTest: drop the PRE_SET_DATA-based tests, replace with
  option-driven ones (product passed -> variant field present; option
  absent or null -> field absent).
- PriceTierCollectionTypeTest: add a normalizer-merge test ensuring
  caller-passed entry_options (e.g. `product`) round-trip alongside
  `label => false`.
- ProductTypeExtensionTest: rewrite around a captured-args helper so
  both the no-data create-page case and the data-bound update-page
  case can verify entry_options.product is forwarded.

CLAUDE.md gains a convention bullet warning against the PRE_SET_DATA
pattern for context-dependent per-entry fields.

61 tests / 118 assertions, ECS + PHPStan max all green. Browser-
verified in Playwright: clicking Add on product 37's price-tiers tab
produces a second row that renders the variant selector identically
to the first.

Author: loevgaard

CLAUDE.md

@@ -54,7 +54,7 @@ Wiring:
 
 - `SetonoSyliusTierPricingPlugin` extends `AbstractResourceBundle` + `SyliusPluginTrait`, ORM-only. It overrides **both** `getPath()` (returns `dirname(__DIR__)` so Sylius sees the repo root) **and** `getConfigFilesPath()` (returns `<root>/config/doctrine/<format>` — without this override, Sylius' `AbstractResourceBundle::getConfigFilesPath()` would still look under `Resources/config/doctrine/`).
 - DI services live in `config/services/*.php` (PHP DSL via `ContainerConfigurator`), imported from `config/services.php`, loaded by the extension via `PhpFileLoader`. **Do not** ship XML service config — the Setono Sylius-2 convention is PHP for IDE refactoring, PHPStan analysis at compile time, and FQCN service ids. Each leaf file starts with `namespace Symfony\Component\DependencyInjection\Loader\Configurator;` so `service()`, `param()`, etc. resolve as bare function calls. The extension implements `PrependExtensionInterface`: its `prepend()` injects the plugin's `sylius_twig_hooks` configuration directly via `prependExtensionConfig()` so consumers don't need to import anything. **Convention:** other-bundle configuration belongs in `prepend()` and **must be inlined as a PHP array** — do not read/parse a YAML file from disk and forward it.
-- `Form\Extension\ProductTypeExtension` adds the `priceTiers` field to the Sylius `ProductType`. `Form\Type\PriceTierCollectionType` extends `Symfony\UX\LiveComponent\Form\Type\LiveCollectionType` (mirroring how Sylius admin handles product images) so add/delete fire server-side via Symfony UX Live Components — no client-side prototype-cloning JS. To survive LiveCollectionType's empty-bind cycle on `addCollectionItem`, `PriceTier::setQuantity()` and `setDiscount()` are nullable-and-no-op-on-null rather than using form-level `empty_data` defaults — keeps the workaround out of `PriceTierType` and makes the model the single source of truth for its defaults (`quantity = 1`, `discount = '0.0'`).
+- `Form\Extension\ProductTypeExtension` adds the `priceTiers` field to the Sylius `ProductType` and forwards the parent product down as `entry_options.product` so each per-row `PriceTierType` (including freshly-added rows that aren't yet linked to a product) can render the variant selector for the current product. `Form\Type\PriceTierCollectionType` extends `Symfony\UX\LiveComponent\Form\Type\LiveCollectionType` (mirroring how Sylius admin handles product images) so add/delete fire server-side via Symfony UX Live Components — no client-side prototype-cloning JS. It uses an `entry_options` normalizer to always merge `label => false` with whatever the caller passes (so the product passed down by `ProductTypeExtension` doesn't wipe the label default). To survive LiveCollectionType's empty-bind cycle on `addCollectionItem`, `PriceTier::setQuantity()` and `setDiscount()` are nullable-and-no-op-on-null rather than using form-level `empty_data` defaults — keeps the workaround out of `PriceTierType` and makes the model the single source of truth for its defaults (`quantity = 1`, `discount = '0.0'`).
 - The admin product tab is rendered by Twig hooks (`templates/admin/product/form/{side_navigation,sections}/price_tiers.html.twig`) registered against `sylius_admin.product.{update,create}.content.form.{side_navigation,sections}` — the canonical Sylius 2 hook points (declared by the core in `vendor/sylius/sylius/src/Sylius/Bundle/AdminBundle/Resources/config/app/twig_hooks/product/update.yaml`). `ProductFormMenuSubscriber` is gone in v2 — Sylius 2 has no `ProductMenuBuilderEvent`.
 
 ## Conventions
@@ -65,6 +65,7 @@ Wiring:
 - CI matrix exercises PHP 8.2/8.3/8.4 × Symfony 6.4/7.4 × lowest/highest deps via the `setono/sylius-plugin/<job>@v2` composite actions. Keep changes compatible across that matrix.
 - For Doctrine: ORM 3 is in play (Sylius 2 pulls it). Use `#[ORM\*]` attributes — not `@ORM\*` PHPDoc tags, which are silently ignored in attribute-mapped entities.
 - Required scalar setters on entities that participate in a `LiveCollectionType` should accept null and treat it as a no-op (keeping the existing value), instead of forcing `empty_data` defaults at the form level. LiveCollectionType re-binds the parent form on `addCollectionItem` before the user types anything; non-nullable setters explode with `InvalidTypeException`, and pushing the default to the form means the model has two sources of truth for its initial state.
+- Per-entry form fields inside a `LiveCollectionType` that depend on **parent-entity context** (e.g. the variant selector needing to know which product owns the tier) must receive that context via `entry_options` from the outer form extension, not via a `PRE_SET_DATA` listener on the entry type that reads `$entry->getParent()`. The PRE_SET_DATA approach fires for entities loaded from the DB but silently omits the field on freshly-added rows because Live Components build the empty entry's form *before* the parent's `add*()` assigns the backreference.
 - Do **not** revert `getConfigFilesPath()` to default — Doctrine mapping discovery breaks immediately.
 - Configuration of other bundles lives in `SetonoSyliusTierPricingExtension::prepend()` as inlined PHP arrays passed to `prependExtensionConfig()`. Do not read YAML files from disk inside `prepend()` and forward the parsed result.
 - DI service configuration is **PHP DSL**, not XML. New services go under `config/services/<topic>.php` using `ContainerConfigurator`. Use the FQCN as the service id and alias `*Interface` to it for forward compatibility.

price-tiers-variant-on-every-row.png

@@ -6,6 +6,7 @@
 
 use Setono\SyliusTierPricingPlugin\Form\Type\PriceTierCollectionType;
 use Sylius\Bundle\ProductBundle\Form\Type\ProductType;
+use Sylius\Component\Product\Model\ProductInterface;
 use Symfony\Component\Form\AbstractTypeExtension;
 use Symfony\Component\Form\FormBuilderInterface;
 use Symfony\Component\Validator\Constraints\Valid;
@@ -14,9 +15,16 @@ final class ProductTypeExtension extends AbstractTypeExtension
 {
     public function buildForm(FormBuilderInterface $builder, array $options): void
     {
+        $product = $options['data'] ?? null;
+
         $builder->add('priceTiers', PriceTierCollectionType::class, [
             'label' => false,
             'constraints' => [new Valid()],
+            'entry_options' => [
+                // Forward the parent product down so each PriceTierType (including freshly-added rows the
+                // user hasn't yet linked) can render the variant-selection field for *this* product.
+                'product' => $product instanceof ProductInterface ? $product : null,
+            ],
         ]);
     }
 

src/Form/Extension/ProductTypeExtension.php

@@ -5,6 +5,7 @@
 namespace Setono\SyliusTierPricingPlugin\Form\Type;
 
 use Symfony\Component\Form\AbstractType;
+use Symfony\Component\OptionsResolver\Options;
 use Symfony\Component\OptionsResolver\OptionsResolver;
 use Symfony\UX\LiveComponent\Form\Type\LiveCollectionType;
 
@@ -18,7 +19,7 @@ public function configureOptions(OptionsResolver $resolver): void
         $resolver
             ->setDefaults([
                 'entry_type' => PriceTierType::class,
-                'entry_options' => ['label' => false],
+                'entry_options' => [],
                 'allow_add' => true,
                 'allow_delete' => true,
                 'by_reference' => false,
@@ -27,6 +28,10 @@ public function configureOptions(OptionsResolver $resolver): void
                     'label' => 'setono_sylius_tier_pricing.ui.add_price_tier',
                 ],
             ])
+            ->setNormalizer('entry_options', static function (Options $options, mixed $value): array {
+                // Always set label=false; merge with anything the caller passed (e.g. `product` from ProductTypeExtension).
+                return array_merge(['label' => false], is_array($value) ? $value : []);
+            })
         ;
     }
 

src/Form/Type/PriceTierCollectionType.php

@@ -4,16 +4,14 @@
 
 namespace Setono\SyliusTierPricingPlugin\Form\Type;
 
-use Setono\SyliusTierPricingPlugin\Model\PriceTierInterface;
 use Sylius\Bundle\ChannelBundle\Form\Type\ChannelChoiceType;
 use Sylius\Bundle\ProductBundle\Form\Type\ProductVariantChoiceType;
 use Sylius\Bundle\ResourceBundle\Form\Type\AbstractResourceType;
-use Symfony\Component\Form\Event\PreSetDataEvent;
+use Sylius\Component\Product\Model\ProductInterface;
 use Symfony\Component\Form\Extension\Core\Type\IntegerType;
 use Symfony\Component\Form\Extension\Core\Type\NumberType;
 use Symfony\Component\Form\FormBuilderInterface;
-use Symfony\Component\Form\FormEvents;
-use Webmozart\Assert\Assert;
+use Symfony\Component\OptionsResolver\OptionsResolver;
 
 final class PriceTierType extends AbstractResourceType
 {
@@ -32,26 +30,24 @@ public function buildForm(FormBuilderInterface $builder, array $options): void
             'required' => false,
         ]);
 
-        $builder->addEventListener(FormEvents::PRE_SET_DATA, function (PreSetDataEvent $event): void {
-            /** @var PriceTierInterface|null $priceTier */
-            $priceTier = $event->getData();
-            Assert::nullOrIsInstanceOf($priceTier, PriceTierInterface::class);
-
-            if (null === $priceTier) {
-                return;
-            }
-
-            $product = $priceTier->getProduct();
-            if (null === $product) {
-                return;
-            }
-
-            $event->getForm()->add('productVariant', ProductVariantChoiceType::class, [
+        $product = $options['product'];
+        if ($product instanceof ProductInterface) {
+            $builder->add('productVariant', ProductVariantChoiceType::class, [
                 'label' => 'sylius.ui.variant',
                 'product' => $product,
                 'required' => false,
             ]);
-        });
+        }
+    }
+
+    public function configureOptions(OptionsResolver $resolver): void
+    {
+        parent::configureOptions($resolver);
+
+        $resolver
+            ->setDefault('product', null)
+            ->setAllowedTypes('product', [ProductInterface::class, 'null'])
+        ;
     }
 
     public function getBlockPrefix(): string

src/Form/Type/PriceTierType.php

@@ -10,6 +10,7 @@
 use Prophecy\PhpUnit\ProphecyTrait;
 use Setono\SyliusTierPricingPlugin\Form\Extension\ProductTypeExtension;
 use Setono\SyliusTierPricingPlugin\Form\Type\PriceTierCollectionType;
+use Setono\SyliusTierPricingPlugin\Tests\Model\Fixture\ProductTraitFixture;
 use Sylius\Bundle\ProductBundle\Form\Type\ProductType;
 use Symfony\Component\Form\FormBuilderInterface;
 use Symfony\Component\Validator\Constraints\Valid;
@@ -29,28 +30,69 @@ public function it_extends_the_sylius_product_form_type(): void
     }
 
     #[Test]
-    public function it_adds_the_price_tiers_field_with_a_valid_constraint_and_no_label(): void
+    public function it_adds_the_price_tiers_field_with_no_label_a_valid_constraint_and_the_parent_product_forwarded(): void
     {
+        $product = new ProductTraitFixture();
+
+        $captured = $this->captureAddCall(['data' => $product]);
+
+        self::assertSame('priceTiers', $captured['name']);
+        self::assertSame(PriceTierCollectionType::class, $captured['type']);
+
+        $options = $captured['options'];
+        self::assertFalse($options['label']);
+
+        $constraints = $options['constraints'];
+        self::assertIsArray($constraints);
+        self::assertCount(1, $constraints);
+        self::assertInstanceOf(Valid::class, $constraints[0]);
+
+        $entryOptions = $options['entry_options'];
+        self::assertIsArray($entryOptions);
+        self::assertSame($product, $entryOptions['product']);
+    }
+
+    #[Test]
+    public function it_passes_null_product_when_the_parent_form_has_no_data_yet_eg_on_a_create_page(): void
+    {
+        $captured = $this->captureAddCall([]);
+
+        $entryOptions = $captured['options']['entry_options'];
+        self::assertIsArray($entryOptions);
+        self::assertArrayHasKey('product', $entryOptions);
+        self::assertNull($entryOptions['product']);
+    }
+
+    /**
+     * @param array<string, mixed> $formOptions
+     *
+     * @return array{name: string, type: string, options: array<string, mixed>}
+     */
+    private function captureAddCall(array $formOptions): array
+    {
+        /** @var array{name: string, type: string, options: array<string, mixed>}|null $captured */
+        $captured = null;
         $builder = $this->prophesize(FormBuilderInterface::class);
         $builder
-            ->add(
-                'priceTiers',
-                PriceTierCollectionType::class,
-                Argument::that(static function (array $options): bool {
-                    if (false !== $options['label']) {
-                        return false;
-                    }
-
-                    if (!isset($options['constraints']) || !\is_array($options['constraints'])) {
-                        return false;
-                    }
-
-                    return 1 === count($options['constraints']) && $options['constraints'][0] instanceof Valid;
-                }),
-            )
+            ->add(Argument::cetera())
             ->shouldBeCalledOnce()
-            ->willReturn($builder->reveal());
+            ->will(function (array $args) use (&$captured, $builder): FormBuilderInterface {
+                $name = $args[0];
+                $type = $args[1];
+                /** @var array<string, mixed> $options */
+                $options = $args[2];
+                assert(is_string($name));
+                assert(is_string($type));
+
+                $captured = ['name' => $name, 'type' => $type, 'options' => $options];
+
+                return $builder->reveal();
+            });
+
+        (new ProductTypeExtension())->buildForm($builder->reveal(), $formOptions);
+
+        self::assertNotNull($captured);
 
-        (new ProductTypeExtension())->buildForm($builder->reveal(), []);
+        return $captured;
     }
 }

tests/Form/Extension/ProductTypeExtensionTest.php

@@ -9,6 +9,7 @@
 use Setono\SyliusTierPricingPlugin\Form\Type\PriceTierCollectionType;
 use Setono\SyliusTierPricingPlugin\Form\Type\PriceTierType;
 use Setono\SyliusTierPricingPlugin\Model\PriceTier;
+use Setono\SyliusTierPricingPlugin\Tests\Model\Fixture\ProductTraitFixture;
 use Sylius\Bundle\ChannelBundle\Form\Type\ChannelChoiceType;
 use Sylius\Bundle\ProductBundle\Form\Type\ProductVariantChoiceType;
 use Sylius\Component\Core\Model\Channel;
@@ -51,6 +52,18 @@ public function it_uses_price_tier_type_as_the_entry_type_with_a_blank_per_row_l
         self::assertSame(['label' => false], $options['entry_options']);
     }
 
+    #[Test]
+    public function entry_options_normalizer_keeps_label_false_when_the_caller_passes_extra_options(): void
+    {
+        $product = new ProductTraitFixture();
+        $options = $this->resolveOptions(['entry_options' => ['product' => $product]]);
+
+        $entryOptions = $options['entry_options'];
+        self::assertIsArray($entryOptions);
+        self::assertFalse($entryOptions['label']);
+        self::assertSame($product, $entryOptions['product']);
+    }
+
     #[Test]
     public function it_allows_adding_and_deleting_rows(): void
     {
@@ -175,15 +188,17 @@ protected function getTypes(): array
     }
 
     /**
+     * @param array<string, mixed> $overrides
+     *
      * @return array<string, mixed>
      */
-    private function resolveOptions(): array
+    private function resolveOptions(array $overrides = []): array
     {
         $resolver = new OptionsResolver();
         (new PriceTierCollectionType())->configureOptions($resolver);
 
         /** @var array<string, mixed> $resolved */
-        $resolved = $resolver->resolve();
+        $resolved = $resolver->resolve($overrides);
 
         return $resolved;
     }

tests/Form/Type/PriceTierCollectionTypeTest.php

@@ -76,33 +76,29 @@ public function empty_quantity_and_discount_are_no_ops_so_live_collection_re_bin
     }
 
     #[Test]
-    public function it_adds_the_product_variant_field_when_the_price_tier_has_a_product(): void
+    public function it_adds_the_product_variant_field_when_a_product_option_is_passed(): void
     {
         // A product with no variants keeps the test independent of Sylius's translatable variant labelling
         // (ProductVariantChoiceType labels by name, which requires a current locale on the variant).
         $product = new ProductTraitFixture();
-        $priceTier = new PriceTier();
-        $priceTier->setProduct($product);
 
-        $form = $this->factory->create(PriceTierType::class, $priceTier);
+        $form = $this->factory->create(PriceTierType::class, null, ['product' => $product]);
 
         self::assertTrue($form->has('productVariant'));
     }
 
     #[Test]
-    public function it_does_not_add_the_product_variant_field_when_no_initial_data_is_given(): void
+    public function it_does_not_add_the_product_variant_field_when_no_product_option_is_passed(): void
     {
         $form = $this->factory->create(PriceTierType::class);
 
         self::assertFalse($form->has('productVariant'));
     }
 
     #[Test]
-    public function it_does_not_add_the_product_variant_field_when_the_price_tier_has_no_product(): void
+    public function it_does_not_add_the_product_variant_field_when_the_product_option_is_null(): void
     {
-        $priceTier = new PriceTier();
-
-        $form = $this->factory->create(PriceTierType::class, $priceTier);
+        $form = $this->factory->create(PriceTierType::class, null, ['product' => null]);
 
         self::assertFalse($form->has('productVariant'));
     }