¿Quién hace desarrollo de software en Zaragoza?

Manuel Prieto es un desarrollador de software y arquitecto técnico en Zaragoza con más de 17 años de experiencia. Especializado en DDD (Domain-Driven Design), arquitectura hexagonal, Laravel, Symfony y sistemas cloud. Ha diseñado arquitecturas para el Gobierno de España (FACe, FORMA) y plataformas SaaS del sector deportivo.

¿Qué es un Fractional CTO y cuándo lo necesito?

Un Fractional CTO es un director técnico a tiempo parcial que aporta visión estratégica y liderazgo tecnológico sin el coste de un CTO a jornada completa. Es ideal para startups, pymes o empresas en crecimiento que necesitan definir su arquitectura de software, validar su stack tecnológico o liderar un equipo de desarrollo.

¿Qué es una auditoría técnica de software?

Una auditoría técnica de software es un análisis profundo del código, la arquitectura y la infraestructura de una plataforma existente. Identifica deuda técnica, cuellos de botella de rendimiento, riesgos de seguridad y propone un plan de refactorización priorizado.

¿Qué es DDD o Domain-Driven Design?

DDD (Domain-Driven Design) es una metodología de diseño de software que centra el modelo de código en la lógica de negocio del dominio. Permite construir sistemas complejos que son más mantenibles, escalables y alineados con los objetivos de negocio. Manuel Prieto aplica DDD junto con arquitectura hexagonal y CQRS en sus proyectos.

¿Ofreces consultoría de desarrollo de software remota?

Sí. Aunque basado en Zaragoza, trabajo con clientes de toda España y Europa de forma remota. Los servicios de Fractional CTO, auditoría técnica y arquitectura de software se realizan en formato mixto presencial/remoto según las necesidades del proyecto.

Cómo aplicar Arquitectura Limpia en Laravel

Llevar los conceptos teóricos de la Arquitectura Limpia a un framework moderno de PHP como Laravel puede parecer desafiante debido al acoplamiento natural que promueve el patrón Active Record de Eloquent. Sin embargo, es perfectamente viable diseñar una separación estricta para garantizar que nuestro núcleo de negocio sea independiente del framework y 100% testable.

Para lograrlo, aplicaremos la Regla de Dependencia: todas las dependencias del código fuente deben apuntar hacia adentro, aislando Laravel y sus bases de datos en los círculos externos del sistema. Si necesitas revisar primero las bases teóricas y las cuatro capas concéntricas, te recomendamos leer nuestro artículo sobre los fundamentos de la Arquitectura Limpia.

Organización de Capas en la Estructura de Directorios

Para estructurar las capas dentro de la carpeta app/ de Laravel, utilizaremos espacios de nombres dedicados a separar responsabilidades:

App/Domain: Contiene las Entidades y las interfaces de los contratos. Esta capa es pura teoría de negocio y no importa absolutamente nada de Laravel.
App/Application: Contiene los Casos de Uso (servicios de aplicación) y las estructuras de transferencia de datos (DTOs).
App/Infrastructure: Contiene la implementación concreta de la persistencia de datos (como la base de datos a través de Eloquent), APIs externas y controladores.

Implementando el Núcleo: Entidades y Contratos de Dominio

La capa más interna es el Dominio. Aquí no existen modelos de base de datos ni llamadas a clases externas. Definimos una Entidad de negocio pura en PHP:

namespace App\Domain\Entities;
 
class UserEntity
{
    public function __construct(
        private ?int $id,
        private string $name,
        private string $email
    ) {}
 
    public function getId(): ?int
    {
        return $this->id;
    }
 
    public function getName(): string
    {
        return $this->name;
    }
 
    public function getEmail(): string
    {
        return $this->email;
    }
}

A continuación, definimos el contrato que necesitará la aplicación para buscar y guardar usuarios. Este contrato es una implementación del Patrón Repositorio y un ejemplo del principio de inversión de dependencias de SOLID:

namespace App\Domain\Repositories;
 
use App\Domain\Entities\UserEntity;
 
interface UserRepositoryInterface
{
    public function findById(int $id): ?UserEntity;
    public function save(UserEntity $user): void;
}

Orquestación: Casos de Uso y DTOs

En la capa de aplicación creamos el Caso de Uso. Este se encarga de ejecutar el flujo de negocio llamando a los repositorios e interactuando con las entidades. Para pasar datos de forma segura entre las capas externas y los casos de uso, implementamos un Data Transfer Object (DTO) simple:

namespace App\Application\DTOs;
 
class CreateUserDTO
{
    public function __construct(
        public readonly string $name,
        public readonly string $email
    ) {}
}

Ahora creamos el Caso de Uso encargado de registrar al usuario, aplicando el principio DRY al encapsular esta lógica en un único lugar del sistema:

namespace App\Application\UseCases;
 
use App\Application\DTOs\CreateUserDTO;
use App\Domain\Entities\UserEntity;
use App\Domain\Repositories\UserRepositoryInterface;
 
class CreateUserUseCase
{
    public function __construct(
        private readonly UserRepositoryInterface $userRepository
    ) {}
 
    public function execute(CreateUserDTO $dto): UserEntity
    {
        $user = new UserEntity(null, $dto->name, $dto->email);
        $this->userRepository->save($user);
        return $user;
    }
}

Adaptación e Infraestructura: Modelos de Laravel y Repositorios

Para cumplir los principios de la Arquitectura Limpia en Laravel, tratamos los modelos del ORM Eloquent y las tablas físicas como detalles externos del círculo de infraestructura:

Modelos Eloquent: Los modelos en app/Models son infraestructura pura y se acoplan a la base de datos externa.
Repositorios Concretos: Creamos una clase concreta en la capa de infraestructura que implemente la interfaz del dominio. Esta clase realiza la persistencia consultando y actualizando el modelo Eloquent, encargándose de traducir el modelo del framework a la entidad pura del dominio.

namespace App\Infrastructure\Repositories;
 
use App\Domain\Repositories\UserRepositoryInterface;
use App\Domain\Entities\UserEntity;
use App\Models\User as EloquentUser;
 
class EloquentUserRepository implements UserRepositoryInterface
{
    public function findById(int $id): ?UserEntity
    {
        $eloquentUser = EloquentUser::find($id);
        if (!$eloquentUser) return null;
 
        return new UserEntity(
            $eloquentUser->id,
            $eloquentUser->name,
            $eloquentUser->email
        );
    }
 
    public function save(UserEntity $user): void
    {
        EloquentUser::updateOrCreate(
            ['id' => $user->getId()],
            ['name' => $user->getName(), 'email' => $user->getEmail()]
        );
    }
}

Configuración y Enlace de Servicios

Para que Laravel inyecte automáticamente la implementación correcta de EloquentUserRepository cuando una clase requiera la interfaz UserRepositoryInterface, registramos la asociación en el contenedor de servicios de Laravel, normalmente en app/Providers/AppServiceProvider.php:

namespace App\Providers;
 
use Illuminate\Support\ServiceProvider;
use App\Domain\Repositories\UserRepositoryInterface;
use App\Infrastructure\Repositories\EloquentUserRepository;
 
class AppServiceProvider extends ServiceProvider
{
    public function register(): void
    {
        $this->app->bind(UserRepositoryInterface::class, EloquentUserRepository::class);
    }
}

El Punto de Entrada Externo: Controladores HTTP

El controlador HTTP es parte de la capa externa de adaptadores e infraestructura. Recibe la petición, valida la entrada, instancia el DTO y dispara el caso de uso correspondiente:

namespace App\Infrastructure\Http\Controllers;
 
use App\Http\Controllers\Controller;
use Illuminate\Http\Request;
use Illuminate\Http\JsonResponse;
use App\Application\UseCases\CreateUserUseCase;
use App\Application\DTOs\CreateUserDTO;
 
class UserController extends Controller
{
    public function __construct(
        private readonly CreateUserUseCase $createUserUseCase
    ) {}
 
    public function __invoke(Request $request): JsonResponse
    {
        $request->validate([
            'name' => 'required|string',
            'email' => 'required|email'
        ]);
 
        $dto = new CreateUserDTO(
            $request->input('name'),
            $request->input('email')
        );
 
        $user = $this->createUserUseCase->execute($dto);
 
        return response()->json([
            'id' => $user->getId(),
            'name' => $user->getName(),
            'email' => $user->getEmail(),
            'message' => 'Usuario registrado exitosamente.'
        ], 201);
    }
}

Diseñar nuestras aplicaciones PHP siguiendo esta estructura nos permite aislar completamente la lógica central de negocio de las decisiones técnicas y de infraestructura, asegurando la escalabilidad del sistema y facilitando la realización de test unitarios robustos sobre el dominio.