Use Case Generator

Generate Application-layer Use Cases that orchestrate domain operations.

Use Case Characteristics

• Single responsibility: One operation per use case
• Orchestration: Coordinates domain objects
• Transaction boundary: Manages atomicity
• Event dispatch: Publishes domain events
• No business logic: Delegates to domain
• Framework agnostic: No HTTP/CLI concerns

When to Use

| Scenario | Example | |----------|---------| | Create operation | CreateOrderUseCase | | State transition | ConfirmOrderUseCase | | External service integration | ProcessPaymentUseCase | | Multi-step workflow | CheckoutUseCase |

---

Generation Process

Step 1: Generate Use Case

Path: src/Application/{BoundedContext}/UseCase/

1. {Name}UseCase.php — Main orchestration class

Step 2: Generate Input DTO

Path: src/Application/{BoundedContext}/DTO/

1. {Name}Input.php — Input data container

Step 3: Generate Output DTO

Path: src/Application/{BoundedContext}/DTO/

1. {Name}Output.php — Result data container

Step 4: Generate Tests

Path: tests/Unit/Application/{BoundedContext}/UseCase/

---

File Placement

| Component | Path | |-----------|------| | Use Case | src/Application/{BoundedContext}/UseCase/ | | Input DTO | src/Application/{BoundedContext}/DTO/ | | Output DTO | src/Application/{BoundedContext}/DTO/ | | Unit Tests | tests/Unit/Application/{BoundedContext}/UseCase/ |

---

Naming Conventions

| Pattern | Example | |---------|---------| | Use Case | {Verb}{Entity}UseCase | | Input DTO | {Name}Input | | Output DTO | {Name}Output or {Entity}{Result}Output |

---

Quick Template Reference

Use Case

final readonly class {Name}UseCase
{
    public function __construct(
        private {Repository}Interface $repository,
        private EventDispatcherInterface $events,
        private TransactionManagerInterface $transaction
    ) {}

    public function execute({Name}Input $input): {Name}Output
    {
        return $this->transaction->transactional(function () use ($input) {
            $aggregate = $this->repository->findById($input->id);
            $aggregate->doSomething($input->data);
            $this->repository->save($aggregate);

            foreach ($aggregate->releaseEvents() as $event) {
                $this->events->dispatch($event);
            }

            return new {Name}Output(...);
        });
    }
}

Input DTO

final readonly class {Name}Input
{
    public function __construct(
        public {ValueObject} $id,
        {additionalProperties}
    ) {}
}

Output DTO

final readonly class {Name}Output
{
    public function __construct(
        public string $id,
        {resultProperties}
    ) {}

    public function toArray(): array
    {
        return ['id' => $this->id, ...];
    }
}

---

Anti-patterns to Avoid

| Anti-pattern | Problem | Solution | |--------------|---------|----------| | Business Logic | Decisions in use case | Delegate to domain | | Multiple Aggregates | Transaction spans aggregates | One aggregate per transaction | | Direct Repo Calls | Bypassing use case | Always use use case | | Missing Transaction | No atomicity | Wrap in transaction | | External in Transaction | Long-running transactions | External calls outside |

---

References

For complete PHP templates and examples, see:

• references/templates.md — UseCase, Input, Output, Test templates with design principles
• references/examples.md — CreateOrder, ConfirmOrder, ProcessPayment examples and tests