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

Naming Conventions

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