ddd-cola

## When to use this skill

Use this skill whenever the user wants to:
- Structure a project using COLA architecture (Adapter, Application, Domain, Infrastructure)
- Apply COLA's layered architecture with clear responsibilities per layer
- Implement domain-driven design with COLA while keeping the domain layer pure and dependency-inverted
- Organize Java/Spring Boot projects following COLA V5 conventions

## How to use this skill

### Workflow

1. **Understand the layer responsibilities**: Adapter handles I/O; Application orchestrates use cases; Domain holds business logic; Infrastructure implements persistence and external services
2. **Set up the package structure** following COLA conventions
3. **Enforce dependency direction**: Domain depends on nothing; Application depends on Domain; Adapter and Infrastructure depend on Application and Domain
4. **Define ports in Domain or Application**, implement them in Infrastructure

### Layer Structure

```
com.example.app/
├── adapter/
│   ├── controller/        # HTTP/RPC/message inbound handlers
│   └── scheduler/         # Scheduled tasks
├── app/
│   ├── executor/          # Use case executors (command handlers)
│   └── service/           # Application services (orchestration, transactions)
├── domain/
│   ├── model/             # Entities, Value Objects, Aggregates
│   │   ├── entity/
│   │   └── valueobject/
│   ├── service/           # Domain services
│   └── gateway/           # Repository and external service interfaces (ports)
└── infrastructure/
    ├── persistence/       # Repository implementations (JPA, MyBatis)
    ├── external/          # External API clients
    └── config/            # Spring configuration and bean wiring
```

### Dependency Direction

```
Adapter → Application → Domain ← Infrastructure
```

### Example: Use Case Executor

```java
// Domain gateway (port)
public interface OrderGateway {
    void save(Order order);
    Optional<Order> findById(String id);
}

// Application executor
@Component
public class CreateOrderExecutor {
    private final OrderGateway orderGateway;

    public CreateOrderExecutor(OrderGateway orderGateway) {
        this.orderGateway = orderGateway;
    }

    @Transactional
    public OrderDto execute(CreateOrderCmd cmd) {
        Order order = Order.create(cmd.getItems(), cmd.getCustomerId());
        orderGateway.save(order);
        return OrderDto.from(order);
    }
}

// Infrastructure implementation
@Repository
public class OrderGatewayImpl implements OrderGateway {
    private final OrderMapper orderMapper;

    @Override
    public void save(Order order) {
        orderMapper.insert(OrderDO.fromDomain(order));
    }
}
```

## Best Practices

- Domain logic belongs exclusively in the Domain layer; Application layer only orchestrates and manages transaction boundaries
- Define ports (interfaces) in Domain or Application; Infrastructure implements them
- Avoid business logic in the Adapter layer; DTOs and domain objects are converted at the boundary
- Follow COLA naming conventions: `Cmd` for commands, `Executor` for handlers, `Gateway` for ports

## Resources

- COLA GitHub: https://github.com/alibaba/COLA
- COLA architecture guide: https://blog.csdn.net/significantfrank/article/details/110934799

## Keywords

cola, cola architecture, clean object-oriented layered architecture, COLA V5, adapter layer, application layer, domain layer, infrastructure layer, DDD, dependency inversion