Strategy Pattern Generator

Creates Strategy pattern infrastructure for interchangeable algorithm families.

When to Use

Component Characteristics

StrategyInterface

• Defines algorithm contract
• Single method for execution
• Supports method for selection

Strategy Resolver

• Resolves appropriate strategy
• Based on input criteria
• Falls back to default

Concrete Strategies

• Implement specific algorithms
• Interchangeable via interface
• Encapsulate algorithm details

Generation Process

Step 1: Generate Strategy Interface

Path:

src/Domain/{BoundedContext}/Strategy/

1. {Name}StrategyInterface.php

   — Algorithm contract with supports method

Step 2: Generate Concrete Strategies

Path:

src/Domain/{BoundedContext}/Strategy/

1. {Variant1}{Name}Strategy.php

   — First algorithm implementation

2. {Variant2}{Name}Strategy.php

   — Second algorithm implementation

3. Default{Name}Strategy.php

   — Fallback implementation

Step 3: Generate Resolver

Path:

src/Domain/{BoundedContext}/Strategy/

1. {Name}StrategyResolver.php

   — Strategy selection logic

Step 4: Generate Service (Optional)

Path:

src/Domain/{BoundedContext}/Strategy/

1. {Name}Service.php

   — Facade using resolver

Step 5: Generate Tests

1. {Variant}{Name}StrategyTest.php

   — Individual strategy tests

2. {Name}StrategyResolverTest.php

   — Resolver tests

File Placement

src/Domain/{BoundedContext}/Strategy/

src/Domain/{BoundedContext}/Strategy/

src/Domain/{BoundedContext}/Strategy/

tests/Unit/Domain/{BoundedContext}/Strategy/

Naming Conventions

{Name}StrategyInterface

PricingStrategyInterface

{Variant}{Name}Strategy

BulkPricingStrategy

{Name}Context

PricingContext

{Name}StrategyResolver

PricingStrategyResolver

{ClassName}Test

BulkPricingStrategyTest

Quick Template Reference

Strategy Interface

interface {Name}StrategyInterface
{
    public function execute({InputType} $input): {OutputType};
    public function supports({InputType} $input): bool;
}

Concrete Strategy

final readonly class {Variant}{Name}Strategy implements {Name}StrategyInterface
{
    public function execute({InputType} $input): {OutputType}
    {
        {algorithmImplementation}
    }

    public function supports({InputType} $input): bool
    {
        return {condition};
    }
}

Strategy Resolver

final readonly class {Name}StrategyResolver
{
    public function __construct(
        private iterable $strategies,
        private {Name}StrategyInterface $defaultStrategy
    ) {}

    public function resolve({InputType} $input): {Name}StrategyInterface
    {
        foreach ($this->strategies as $strategy) {
            if ($strategy->supports($input)) {
                return $strategy;
            }
        }
        return $this->defaultStrategy;
    }
}

Usage Example

// Configure strategies
$resolver = new PricingStrategyResolver(
    strategies: [
        new BulkPricingStrategy(),      // 15% off for 100+ items
        new PromotionalPricingStrategy(), // Active promotion discount
        new VipPricingStrategy(),        // VIP customer discount
    ],
    defaultStrategy: new RegularPricingStrategy()
);

// Use in service
$strategy = $resolver->resolve($pricingContext);
$price = $strategy->calculatePrice($pricingContext);

Common Strategy Examples

Anti-patterns to Avoid

References

For complete PHP templates and examples, see:

• references/templates.md

  — Strategy Interface, Concrete Strategy, Resolver, Context templates

• references/examples.md

  — Pricing, Shipping, Tax strategies and tests