esplotter/create-use-case

Objetivo de la Skill

Crear un Caso de Uso que:

• Orqueste entidades sin contener lógica empresarial crítica estructural.
• Sea independiente de frameworks, UI, DB o transporte.
• Use modelos de entrada/salida explícitos.
• Dependa solo de entidades e interfaces.
• Sea 100% testeable sin infraestructura real.

Definición Formal de Caso de Uso

Un caso de uso debe definir:

1. Input (Request Model) → datos primitivos.
2. Output (Response Model) → datos serializables.
3. Proceso → orquestación del dominio.

Nunca:

• Importar framework.
• Usar ORM directamente.
• Usar HttpRequest, Express, NextRequest, etc.
• Acceder a SQL.

Responsabilidades

El caso de uso:

• Coordina entidades.
• Aplica reglas específicas de aplicación.
• Define transacciones lógicas.
• Llama a repositorios a través de interfaces.
• Controla el flujo del proceso.

No:

• Implementa reglas empresariales nucleares (eso es entidad).
• Conoce detalles técnicos.
• Formatea respuestas HTTP.

Plantilla Obligatoria

Estructura recomendada:

<module>/
 └── application/
      └── use-cases/
           └── CreateOrder.ts

Ejemplo de caso de uso

export class CreateOrder {
  constructor(
    private readonly orderRepository: OrderRepository,
    private readonly paymentGateway: PaymentGateway,
  ) {}

  async run(request: CreateOrderRequest): Promise<CreateOrderResponse> {
    const order = Order.create(request.customerId, request.items);

    await this.orderRepository.save(order);

    await this.paymentGateway.charge(order.total());

    return {
      orderId: order.id,
      totalAmount: order.total(),
    };
  }
}

Ejemplo de test

describe('CreateOrder', () => {
  it('should create an order and charge payment', async () => {
    const orderRepository = new OrderRepositoryMock();
    const paymentGateway = new PaymentGatewayMock();

    const createOrder = new CreateOrder(orderRepository, paymentGateway);

    const response = await createOrder.run({
      customerId: '123',
      items: [{ productId: 'p1', quantity: 2 }],
    });

    expect(response.orderId).toBeDefined();
    expect(paymentMock.charge).toHaveBeenCalled();
  });
});

✔ Sin base de datos ✔ Sin servidor ✔ Sin framework

Checklist Automático (Debe cumplirse siempre)

Antes de considerar el caso de uso válido, verificar:

• [] No importa infraestructura.
• [] Usa Request/Response explícitos.
• [] No devuelve entidades.
• [] No contiene reglas empresariales nucleares.
• [] Orquesta entidades.
• [] Usa interfaces para I/O.
• [] Es unit-testable sin mocks complejos.
• [] No depende de transporte.