Awesome-claude-code create-use-case

Generates Application Use Cases for PHP 8.4. Creates orchestration services that coordinate domain objects, handle transactions, and dispatch events. Includes unit tests.

install

source · Clone the upstream repo

git clone https://github.com/dykyi-roman/awesome-claude-code

Claude Code · Install into ~/.claude/skills/

T=$(mktemp -d) && git clone --depth=1 https://github.com/dykyi-roman/awesome-claude-code "$T" && mkdir -p ~/.claude/skills && cp -r "$T/skills/create-use-case" ~/.claude/skills/dykyi-roman-awesome-claude-code-create-use-case && rm -rf "$T"

manifest: skills/create-use-case/SKILL.md

source content

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/

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

Step 2: Generate Input DTO

Path:

src/Application/{BoundedContext}/DTO/

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

Step 3: Generate Output DTO

Path:

src/Application/{BoundedContext}/DTO/

```
{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

{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