Policy Pattern Generator

Creates Policy pattern infrastructure for encapsulating business rules and authorization logic.

When to Use

Component Characteristics

PolicyInterface

• Single responsibility rule
• Returns authorization result
• Provides denial reasons

Policy Implementation

• Encapsulates one business rule
• Stateless evaluation
• Composable with other policies

PolicyResult

• Success/failure status
• Denial reasons
• Metadata for logging

Generation Process

Step 1: Generate Shared Components

Path:

src/Domain/Shared/Policy/

1. PolicyResult.php

   — Result value object with and/or composition

2. CompositionMode.php

   — Enum for AllMustPass/AnyMustPass

Step 2: Generate Policy Interface

Path:

src/Domain/{BoundedContext}/Policy/

1. {Name}PolicyInterface.php

   — Policy contract

Step 3: Generate Concrete Policies

Path:

src/Domain/{BoundedContext}/Policy/

1. {Rule1}Policy.php

   — First rule implementation

2. {Rule2}Policy.php

   — Second rule implementation

3. {Name}Policy.php

   — Composite policy combining rules

Step 4: Generate Exception

Path:

src/Domain/Shared/Exception/

1. PolicyViolationException.php

   — Exception with policy context

Step 5: Generate Tests

1. {Rule}PolicyTest.php

   — Individual rule tests

2. {Name}PolicyTest.php

   — Composite policy tests

3. PolicyResultTest.php

   — Result composition tests

File Placement

src/Domain/{BoundedContext}/Policy/

src/Domain/{BoundedContext}/Policy/

src/Domain/Shared/Policy/

src/Domain/Shared/Exception/

tests/Unit/Domain/{BoundedContext}/Policy/

Naming Conventions

{Name}PolicyInterface

OrderCancellationPolicyInterface

{Rule}Policy

OrderOwnershipPolicy

{Name}Policy

OrderCancellationPolicy

PolicyResult

PolicyResult

PolicyViolationException

PolicyViolationException

{ClassName}Test

OrderOwnershipPolicyTest

Quick Template Reference

PolicyInterface

interface {Name}PolicyInterface
{
    public function evaluate({SubjectType} $subject, {ResourceType} $resource): PolicyResult;
    public function getRuleName(): string;
}

PolicyResult

final readonly class PolicyResult
{
    public static function allow(): self;
    public static function deny(string $reason, array $metadata = []): self;
    public function isAllowed(): bool;
    public function isDenied(): bool;
    public function and(self $other): self; // Both must pass
    public function or(self $other): self;  // Either can pass
}

Policy Implementation

final readonly class {Rule}Policy implements {Name}PolicyInterface
{
    public function evaluate({Subject} $subject, {Resource} $resource): PolicyResult
    {
        if ({condition}) {
            return PolicyResult::allow();
        }
        return PolicyResult::deny('{reason}', ['context' => 'data']);
    }

    public function getRuleName(): string
    {
        return '{rule_name}';
    }
}

Composite Policy

final readonly class {Name}Policy implements {Name}PolicyInterface
{
    public function evaluate({Subject} $subject, {Resource} $resource): PolicyResult
    {
        return $this->rule1Policy->evaluate($subject, $resource)
            ->and($this->rule2Policy->evaluate($subject, $resource))
            ->and($this->rule3Policy->evaluate($subject, $resource));
    }
}

Usage Example

// In UseCase
$result = $this->cancellationPolicy->evaluate($user, $order);

if ($result->isDenied()) {
    throw new PolicyViolationException(
        $this->cancellationPolicy->getRuleName(),
        $result->getReason(),
        $result->metadata
    );
}

$order->cancel($reason);

Anti-patterns to Avoid

References

For complete PHP templates and examples, see:

• references/templates.md

  — Policy, composite, result templates

• references/examples.md

  — Order cancellation policies and tests