Modelos de Vista en Laravel (View Models): Cambia tu forma de desarrollar

Los Modelos de Vista en Laravel (View Models) son una herramienta poderosa para estructurar la lógica de negocio que enviamos a nuestras vistas. A diferencia de otras soluciones como los ViewComposers, los View Models nos permiten encapsular y organizar datos de manera clara y predecible, cambiando completamente nuestra forma de trabajar con las vistas.

En esta entrada, exploraremos en detalle qué son los Modelos de Vista, cómo funcionan, cómo difieren de los ViewComposers, y cómo implementarlos con ejemplos prácticos que muestren su potencia y flexibilidad.

¿Qué son los Modelos de Vista?

Los Modelos de Vista (View Models) son clases que actúan como una capa intermedia entre nuestros controladores y las vistas. Su propósito principal es preparar los datos que serán utilizados por una vista específica, permitiendo mantener la lógica fuera del controlador y la vista.

Un View Model es particularmente útil cuando:

• Necesitas agrupar datos complejos o derivados para una vista específica.

• Quieres encapsular la lógica de presentación.

• Deseas evitar llenar los controladores con lógica compleja o repetitiva.

Además, los modelos de vista pueden estructurarse según el contexto en el que se utilicen. Por ejemplo, puedes definir diferentes prefijos para organizar los modelos de vista según su función:

• Get: Para los listados de datos.

• Create o Update: Para preparar datos destinados a formularios de creación o actualización.

• Upsert: En ocasiones, para manejar la lógica combinada de creación o actualización.

Esta estructura ayuda a mantener una organización clara en tu proyecto y permite identificar rápidamente la finalidad de cada modelo de vista.

Implementación de un View Model Base

A continuación, mostramos una clase base abstracta para nuestros View Models. Esta clase convierte todos los métodos públicos en claves de un array, usando el método toArray. Esto facilita la transformación de los datos para ser utilizados en vistas o respuestas JSON.

Esta implementación convierte los nombres de los métodos públicos de estilo camelCase a claves snake_case en el array final. Esto es útil para mantener consistencia con los estándares de Laravel.

Ejemplo: View Model para un Dashboard

Extendiendo la clase base, crearemos un View Model para manejar los datos de un dashboard:

En este caso, el método toArray transformará los datos de la siguiente manera:

Controlador correspondiente:

Ejemplo: View Model para un Formulario

Siguiendo la convención mencionada, podemos crear un modelo de vista para preparar datos de un formulario de edición:

Controlador correspondiente:

De este modo, los datos necesarios para la edición del formulario están organizados y listos para ser utilizados en la vista.

View Models vs ViewComposers

Aunque ambos enfoques permiten compartir datos con las vistas, tienen diferencias clave:

View Models

• Son clases específicas para una vista o un conjunto de vistas relacionadas.

• Encapsulan toda la lógica de presentación en una sola clase.

• Fáciles de probar y mantener.

• Compatibles con respuestas JSON.

ViewComposers

• Se utilizan para compartir datos entre múltiples vistas.

• Se configuran globalmente en el AppServiceProvider o un proveedor específico.

• No encapsulan la lógica; suelen llamar a servicios o repositorios externos.

Ejemplo de un ViewComposer:

Configuración en un proveedor:

Organización por Modelo e Intención

Para mantener un código más estructurado y organizado, es buena práctica nombrar los Modelos de Vista de acuerdo al modelo principal que manejan y la intención detrás de ellos. Esto se puede lograr utilizando prefijos claros como:

• Get: Para listados de datos o vistas de solo lectura.

• Create: Para formularios de creación.

• Update: Para formularios de edición.

• Upsert: Para formularios que combinan creación y edición.

Ejemplo:

Este enfoque no solo facilita la comprensión del propósito de cada clase, sino que también promueve la reutilización y el mantenimiento a largo plazo del código.

Testing para los Modelos de Vista

Los modelos de vista normalmente necesitarán ser testeados de dos formas diferentes, con tests unitarios y con tests de integración, ya que por un lado queremos asegurar que el modelo de vista tiene la estructura y genera los datos correctamente (unit) y por otro lado queremos asegurarnos que al solicitar mediante petición HTTP los datos del modelo de vista (Vue, React) los datos recibidos son los esperados (feature).

Tests Unitarios en View Models

Los tests unitarios (unit) validarán la correcta transformación de los datos y las claves generadas por el método toArray.

Test Unitario 1: Verificar el formato de las claves

Este test verifica que todas las claves generadas por los métodos públicos del ViewModel sean transformadas correctamente a snake_case.

Test Unitario 2: Verificar el valor de un método

Este test verifica que un método específico del ViewModel (postCount) devuelve los datos esperados.

Tests de Integración en View Models

Los tests de integración (feature) verificarán la funcionalidad completa desde el controlador hasta la respuesta generada.

Test Feature 1: Verificar la estructura de la respuesta

Este test valida que el controlador devuelve la estructura de datos correcta proporcionada por el ViewModel.

Test Feature 2: Validar datos de la respuesta

Este test valida que los datos devueltos por el controlador son correctos, incluyendo el conteo de publicaciones y comentarios.

La importancia de los tests

Los tests son imprescindibles en cualquier desarrollo, en mayor o menor medida, pero necesarios. Gracias a los tests que hemos desarrollado para los modelos de vista, aseguramos que tanto la generación de datos como el valor de los datos, sean correctos, para ello, tenemos lo siguiente:

• Tests unitarios para validar que los métodos del ViewModel funcionan como se espera y que las claves están correctamente transformadas.

• Tests feature para verificar que el flujo completo (desde el controlador hasta la respuesta) devuelve los datos correctos y con la estructura adecuada.

Conclusión

Los Modelos de Vista (ViewModels) en Laravel son increíbles, nos permiten encapsular la lógica de presentación en una clase aislada, la cual contiene toda la información que una vista necesita. Además, se pueden testear fácilmente ya que no están acoplados a nada, son completamente independientes.

Al utilizar los Modelos de Vista en Laravel, conseguimos que nuestros controladores sean sencillos, fáciles de mantener, y lo mejor de todo, que se entiendan con una rápida lectura.

¿Quieres seguir profundizando en los Modelos de Vista en Laravel?

Si deseas seguir aprendiendo más sobre arquitectura y diseño de software en Laravel, no te puedes perder el curso Full Stack con Laravel y Vue con más 20 horas de contenido. Es una joya que te dará soluciones a los problemas que te encuentres en tu día a día trabajando como desarrollador Full Stack.

Combina los Modelos de Vista en Laravel con el patrón Action

Ahora que ya sabes cómo organizar mejor tus controladores Laravel utilizando Modelos de Vista, necesitas dar un paso más, ¿qué pasa con las acciones que se ejecutan con la interacción de los usuarios? Crear, actualizar, eliminar, todo eso son acciones y, en muchos casos, las procesamos en nuestros controladores pensando que -no es tanto código- o que -por qué no hacerlo en el controlador- pero es un error, y tenemos opciones.

Si quieres dar el siguiente paso y que tus controladores luzcan como nunca, no te pierdas la entrada acerca del Patrón Action en Laravel.

¿Quieres seguir profundizando en las últimas novedades de Laravel?

No te pierdas nuestra ruta de Laravel 11, donde exploramos las funciones más recientes del framework, prácticas avanzadas y consejos para optimizar tus proyectos. ¡Te esperamos allí para que lleves tus aplicaciones al siguiente nivel!