create-strategy

Strategy Pattern Generator

Creates Strategy pattern infrastructure for interchangeable algorithm families.

When to Use

Scenario	Example
Multiple algorithms	Pricing, tax, shipping calculation
Runtime selection	Payment processing based on amount
Avoiding conditionals	Replace switch/if-else chains
Algorithm families	Sorting, compression, encryption

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

Component	Path
Strategy Interface	src/Domain/{BoundedContext}/Strategy/
Concrete Strategies	src/Domain/{BoundedContext}/Strategy/
Resolver	src/Domain/{BoundedContext}/Strategy/
Unit Tests	tests/Unit/Domain/{BoundedContext}/Strategy/

---

Naming Conventions

Component	Pattern	Example
Interface	{Name}StrategyInterface	PricingStrategyInterface
Concrete	{Variant}{Name}Strategy	BulkPricingStrategy
Context	{Name}Context	PricingContext
Resolver	{Name}StrategyResolver	PricingStrategyResolver
Test	{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

Domain	Strategies
Pricing	Regular, Bulk, Promotional, VIP
Shipping	Standard, Express, Free, International
Tax	US, EU, Exempt, Zero-rated
Payment	Credit Card, PayPal, Bank Transfer
Discount	Percentage, Fixed, Buy-One-Get-One

---

Anti-patterns to Avoid

Anti-pattern	Problem	Solution
Stateful Strategies	Side effects	Make strategies readonly
Fat Context	Too much coupling	Minimal context interface
Missing Resolver	Manual strategy selection	Use resolver pattern
Over-engineering	Single algorithm	Don't use pattern
Leaky Abstraction	Strategy-specific types	Use shared interfaces

---

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