#1 Laravel + DDD + Arquitectura Hexagonal: Desarrollo Profesional Explicado Paso a Paso | GOGODEV

[00:00] Hola deps Bueno Este es quizás uno de

[00:04] los contenidos que más nos habíais

[00:07] estado pidiendo a lo largo del Canal y

[00:11] Bueno aquí estamos otra vez al comienzo

[00:14] de un largo camino puesto que una vez

[00:18] más nos vamos a meter en el lío de

[00:20] grabar un nuevo curso profesional en

[00:24] este caso larabel dd y hexagonal Y es

[00:27] que bueno era que teníamos pendient hace

[00:31] mucho tiempo y el otro día no recuerdo

[00:35] muy bien cuándo estaba viendo por ahí

[00:37] YouTube y en los shorts me salió este

[00:39] vídeo de aquí una de las cosas que veo

[00:41] que me da un poco de pena Es que me da

[00:43] la sensación que no podemos hacer

[00:44] contenido que se salga de lo básico

[00:46] porque entonces Os salís todos corriendo

[00:48] entonces luego la gente me dice Ah vamos

[00:49] a hacer arquitectura exagonal Sí hago

[00:52] arquitectura exagonal y estoy aquí solo

[00:53] haciendo arquitectura sagon Y bueno pues

[00:56] eh lo estaba viendo y digo pues es una

[01:00] Lástima que Que poca gente se anime a a

[01:03] grabarlo ya sea

[01:04] por por número de gente que pueda estar

[01:07] interesado en seguir lo demás

[01:09] afortunadamente nosotros no tenemos ese

[01:12] problema porque ya sabéis que esto no es

[01:15] no es una profesión es simplemente el

[01:17] ánimo de compartir con vosotros Así que

[01:20] listo no le demos más vueltas curso de

[01:24] larabel de de day hexagonal profesional

[01:26] vamos a

[01:28] [Música]

[01:40] muy bien y antes de comenzar vamos a

[01:42] establecer a una serie de requisitos que

[01:44] van a ser necesarios para poder seguir

[01:46] este curso con normalidad Y es que

[01:48] tenéis que tener en cuenta que este no

[01:50] es un curso básico sino que vamos a

[01:52] necesitar ciertos conocimientos previos

[01:55] para poder seguirlo con

[01:57] normalidad lo primero que vamos a

[01:59] necesitar evidentemente vamos a estar

[02:01] aplicando arquitectura exagonal y DVD a

[02:04] en este caso larabel por lo tanto

[02:07] necesitamos conocer l arabel si no lo

[02:10] conocéis os lo dejo por aquí y si no en

[02:12] la descripción os aparecerá el enlace al

[02:15] curso profesional del arabel que tenemos

[02:17] en el canal ya sabéis que todo es

[02:19] totalmente gratuito podéis verlo sin

[02:21] problemas todo en YouTube muy bien Si ya

[02:25] conocemos la arabel y hemos visto ese

[02:28] curso que sería el necesario ya sea

[02:31] porque lo habéis superado o bueno porque

[02:35] ya conocíais la arabel con

[02:36] anterioridad y evidentemente todos los

[02:40] requisitos que este tiene el siguiente

[02:42] paso sería conocer los principios del

[02:45] domain driven design y de la

[02:47] arquitectura

[02:49] hexagonal Si no los conocéis Pues

[02:52] también tenéis un vídeo en el canal

[02:54] también os lo dejo por aquí o en la

[02:56] descripción os aparecerá para que podáis

[03:00] ver arquitectura hexagonal y domain

[03:03] driving design los fundamentos teóricos

[03:05] es un vídeo muy cortito para que sepamos

[03:08] en todo momento de qué estamos hablando

[03:10] y sepamos ubicarnos dentro del contexto

[03:12] de trabajo que vamos a estar realizando

[03:15] por último Y de forma transversal vamos

[03:17] a estar utilizando los principios solid

[03:19] a lo largo de todo el curso Si no los

[03:23] conoces y este ya por último también te

[03:26] lo dejo por ahí o en la descripción para

[03:28] que puedas verlo así pues si tenemos los

[03:31] conocimientos necesarios sobre el arabel

[03:34] en este caso el el framework de trabajo

[03:37] y todos los requerimientos previos que

[03:39] este tiene si conocemos solid Y si

[03:43] conocemos los fundamentos de la

[03:46] arquitectura que vamos a estar

[03:47] trabajando eso es suficiente para poder

[03:50] seguir este contenido y si te falta

[03:54] Cualquiera de esos conocimientos

[03:55] Recuerda que ahí tienes los vídeos para

[03:57] verlos cuando quieras y poder comenzar

[04:00] si no estás seguro de si tienes el nivel

[04:03] necesario Pues yo te annimo a que

[04:04] empieces a verlo y si ves que te quedas

[04:08] cojo en alguna parte pues siempre tienes

[04:10] ahí esas listas de reproducción Para

[04:12] volver a los basics cuando lo

[04:17] necesites aclarado esto quiero también

[04:21] poner

[04:23] otro punto importante que creo que es

[04:26] relevante porque es una consulta que

[04:28] suele aparecer mucho en los los

[04:30] comentarios del Canal y Es sobre las

[04:32] versiones de trabajo en este caso

[04:35] nosotros vamos a estar trabajando con la

[04:37] versión del arabel 12 que a día de esta

[04:39] grabación es la última que hay la

[04:42] larabel 12 sin embargo tened en cuenta

[04:45] que el equipo de larabel saca Major

[04:48] version cada 6 meses por lo tanto es

[04:51] potencialmente posible que cuando veas

[04:53] este vídeo la ya estemos en la versión

[04:56] 13 o incluso en la 14 porque al final si

[04:59] sale meor versión cada 6 meses el ritmo

[05:02] es muy elevado sin embargo no tienes que

[05:06] preocuparte por esos problemas no tienes

[05:08] por qué preocuparte en exceso por la

[05:11] versión en la cual estás trabajando

[05:13] nosotros estamos ubicando conceptos que

[05:16] son transversales al framework y que no

[05:20] están sujetos o no son muy sensibles

[05:23] a modificaciones que pudiesen estar

[05:26] afectándolo lo mismo con el curso de

[05:29] Lara del profesional del árabe del

[05:30] básico que si no recuerdo mal estaba con

[05:32] la versión 10 creo recordar o parte con

[05:35] la nueve y parte con la

[05:36] 10 y no hay ningún problema al final los

[05:40] fundamentos son fundamentos y siguen

[05:42] estando ahí y en el caso de arquitectura

[05:45] exagonal y dd va a ocurrir lo mismo todo

[05:47] lo que vamos a estar aplicando dentro

[05:49] del contenido va a seguir estando ahí en

[05:51] las nuevas versiones porque no estamos

[05:53] trabajando partes muy sensibles no

[05:57] obstante si por supuesto en algún

[05:59] momento momento saliese alguna

[06:01] actualización en estos Major version que

[06:03] estuviese afectando de una forma directa

[06:05] a lo que estáis viendo pues en esta

[06:07] misma lista de reproducción os

[06:09] encontraría siempre por ahí algún vídeo

[06:11] de actualización explicando esos cambios

[06:14] que pudiese haber y Este es otro de los

[06:18] puntos que quería comentaros tenéis por

[06:22] ahí la lista de reproducción yo os

[06:24] recomiendo que la guardéis para que

[06:26] podáis ir viendo las diferentes clases y

[06:30] así no os perdáis nada el ritmo de

[06:33] publicación si lo estás viendo en

[06:34] directo va a ser todos los lunes a las 8

[06:39] hora española ese va a ser el ritmo de

[06:42] publicación y me gustaría si el tiempo

[06:46] nos respeta y dentro de lo posible que

[06:49] se organizas en ocho sesiones ocho

[06:53] sesiones de Cara a que quizás nos puedan

[06:57] quedar un poquito más extensas Esta es

[06:59] el esta primera clase simplemente la

[07:01] toma de contacto pero las posteriores

[07:03] quizás sean más extensas duren más de

[07:06] una hora que es más o menos el formato

[07:08] al cual nos hemos

[07:09] intentado ajustar los cursos

[07:11] profesionales el de 50 horas de View y

[07:14] el de arabel ambos tienen ese formato

[07:18] más o menos de una intentar hacer una

[07:20] hora por vídeo pero

[07:22] eh Claro si hacemos un proyecto como

[07:24] hicimos en View de 50 horas Pues nos va

[07:27] a quedar al final

[07:30] un contenido muy extenso en el tiempo y

[07:32] al final de viw fueron más de un año

[07:35] Casi casi algo más de un año grabando

[07:37] clases y no es mi intención mi intención

[07:40] es que sea se ejecute en un tiempo más

[07:43] reducido Yo creo que si lo hacemos en

[07:44] ocho sesiones lo estamos encajando si si

[07:47] publicamos uno a la semana durante ocho

[07:49] sesiones pues van a ser dos meses y en

[07:52] dos meses tenemos el curso terminado y

[07:55] podemos movernos hacia otros temas como

[07:58] podría ser tenemos dos todavía pendiente

[08:00] dentro del larabel que es Quizá el tema

[08:02] que no nos trata dentro de aquí tenemos

[08:04] todavía pendiente cqrs tenemos todavía

[08:07] pendiente microservicios tenemos todavía

[08:11] eh

[08:14] pendiente d design y un poquito de por

[08:17] ahí conexiones con Rabbit and que y

[08:18] algunas cosillas que hemos hablado en

[08:21] alguna ocasión todo eso pues irá

[08:22] viniendo y para que pueda ir viniendo

[08:24] Necesitamos ir limpiando parrilla Así

[08:26] que vamos a intentar encerrarlo en esas

[08:29] 8 semanas muy bien dicho Todo esto Ahora

[08:33] sí manos al código a

[08:38] [Música]

[08:44] programar y gracias a la magia de la

[08:47] edición ya nos encontramos aquí en las

[08:49] oficinas de 64 para continuar avanzando

[08:52] en la parte de codificación de toda la

[08:53] solución y lo primero que vamos a estar

[08:55] realizando va a ser la generación de un

[08:57] boiler Plate que nos pueda dar aporte a

[09:00] todos los desarrollos que vayamos a

[09:02] estar haciendo de aquí en adelante con

[09:04] este patrón de diseño y arquitectura Y

[09:07] es que si lo pensamos o lo tenemos en

[09:10] cuenta larabel por defecto está pensado

[09:13] estructuralmente para soportar una

[09:15] arquitectura de nvc o modelo vista

[09:17] controlador y nuestro interés va a ser

[09:19] adaptarla para que se ajuste mejor a

[09:23] cualquier desarrollo en este caso

[09:26] hexagonal punto importante también sobre

[09:28] este aspecto Y es que yo voy a estar

[09:30] hablando tanto de domain driven design

[09:33] como hexagonal que son ambas

[09:35] eh Son ambas soluciones las que vamos a

[09:38] ir eh desarrollando a lo largo del

[09:40] contenido pero tenemos que ser

[09:43] consciente de que aunque ambos conceptos

[09:46] son complementarios y funcionan muy bien

[09:48] Juntos son conceptos distintos dom Mind

[09:50] driven design es un patrón de diseño y

[09:53] arquitectura hexagonal es un patrón de

[09:55] arquitectura son cosas distintas en la

[09:57] caja de descripción os dejo la

[09:59] información de los fundamentos teóricos

[10:01] y la diferencia por si queréis echarle

[10:04] un vistazo podáis tenerla a mano y que

[10:06] no confundamos terminología no obstante

[10:09] nosotros a lo largo de este contenido

[10:11] vamos a estar viendo ambas soluciones y

[10:13] vamos a estar integrando los dos pero

[10:14] para que sepamos diferenciarlos Muy bien

[10:17] pues como decía lo primero que vamos a

[10:18] hacer es un Boiler Plate vamos a hacer

[10:20] una estructura que nos pueda servir para

[10:24] adaptar L arabel y utilizar todo este

[10:26] tipo de patrones en esta eh primera fase

[10:29] o fase inicial nosotros vamos a estar

[10:33] construyéndolo de tal forma que nos dé

[10:35] soporte a la estructura básica y en las

[10:38] lecciones finales vamos a estar

[10:40] adaptándolo también para eh algunos de

[10:43] vosotros Probablemente lo sabrá los

[10:45] hacer las adaptaciones sobre el orm para

[10:50] trabajar también no solo con en este

[10:52] caso con eloquent sino con algún

[10:54] doctrine o alguna versión más dat mapper

[10:56] que también nos pueda funcionar mejor en

[10:59] en esta situación pero todo eso lo

[11:01] iremos viendo más adelante de momento

[11:03] vamos a comenzar por el principio voy a

[11:05] hacer por aquí una un

[11:10] directorio para comenzar a trabajar y lo

[11:13] que voy a hacer es dentro del

[11:19] mismo lo tenemos por aquí vamos a

[11:22] abrirlo con visual Studio code y vamos a

[11:24] crear un primer proyecto sobre el cual

[11:27] ir aplicando toda esta estructura bien

[11:30] comenzamos por el principio me vengo por

[11:33] aquí al

[11:37] terminal Y como decía el primer paso va

[11:41] a ser

[11:45] generar nuestro proyecto que en este

[11:48] caso yo lo voy a llamar d boiler Plate

[11:50] puesto que es lo que vamos a estar

[11:53] realizando como siempre aquellos que ya

[11:55] habéis seguido alguno de nuestros

[11:57] contenidos no os preocupéis por los

[11:59] mensajes que me aparecen aquí en consola

[12:01] a vosotros no os saldrán es porque yo

[12:03] tengo habilitado eh esta parte de

[12:05] verbosidad sobre la parte de preciados

[12:07] porque lo utilizamos nosotros en la

[12:10] empresa bien eh dentro de las preguntas

[12:14] que me va a estar haciendo el arabel

[12:17] Installer no vamos a usar ningún starter

[12:19] kit vamos a dejarlo todo de base y da

[12:22] igual el framework que eh especifiques

[12:26] para los test puesto que los test los

[12:29] trataremos de forma aparte ahora mismo

[12:31] para nuestro boiler Plate nos da igual

[12:33] yo voy a poner php unit pero podríais

[12:36] estar colocando pest o el que prefiráis

[12:38] aquí va a ser eh totalmente indiferente

[12:41] de hecho esa es quizás una de las

[12:45] ventajas que vamos a estar aplicando con

[12:47] este tipo de arquitectura y va a ser la

[12:49] posibilidad de abstra de todo este tipo

[12:51] de instalaciones vamos a dejarlo todo

[12:54] preparado vamos a esperar a que finalice

[12:57] el scaffolding inicial y ahora sobre

[12:59] este scaffolding vamos a estar haciendo

[13:01] algunas modificaciones Y es que

[13:05] eh cuando estamos trabajando dentro del

[13:07] arabel con patrón de arquitectura en vic

[13:09] o modelo vista controlador si recordáis

[13:11] nosotros tenemos una estructura que está

[13:14] 100% acoplada al framework es decir todo

[13:17] lo que nosotros vamos a estar trabajando

[13:19] va a estar acoplado de de forma

[13:23] inherente a toda la estructura del

[13:25] framework de trabajo siguiendo los

[13:27] patrones que vamos a estar apc and

[13:29] nosotros deberíamos evitar el

[13:32] acoplamiento tanto a infraestructura

[13:35] como también dentro de forma interna el

[13:38] acoplamiento de clases o el acoplamiento

[13:40] de las diferentes áreas de negocio o

[13:43] entidades entonces para poder hacer todo

[13:45] esto vamos a necesitar hacer algunas

[13:47] modificaciones sobre la estructura de

[13:50] larabel entonces una vez una vez se

[13:53] finalice lo primero que vamos a estar

[13:55] haciendo es ahora que cuando tengamos el

[13:58] el el autoload va a ser modificar la

[14:01] carpeta de trabajo vamos a en primer

[14:04] lugar no mezclar el contenido que

[14:06] tenemos con el contenido que ya nos

[14:08] ofrece arabel si si estáis habituados

[14:11] Pues sabéis que toda la parte que

[14:14] correspondería aacen va dentro del

[14:17] directorio app o app y nosotros lo que

[14:20] vamos a hacer es moverlo hacia un

[14:22] directorio nuevo donde vamos a estar

[14:24] trabajando de una forma aislada para eso

[14:26] vamos a estar eh Pues modificando un

[14:29] poquito el en este caso el composer muy

[14:32] bien Vamos a esperar a que finalice y

[14:35] continuamos muy bien ya ha finalizado el

[14:38] scaffolding ya simplemente me pregunta

[14:40] eh Qué motor de bases de datos vamos a

[14:44] estar utilizando yo en mi caso pues voy

[14:46] a marcar squel Lite porque es lo más

[14:49] cómodo ahora mismo para comenzar pero

[14:51] recordad que en cualquier momento si

[14:54] queréis modificarlo pues podemos

[14:56] utilizar my squel o cualquiera de otros

[14:58] obviamente luego para pasar a a

[15:00] producción modificarías ese ese motor

[15:03] pero ahora mismo me vale No y bueno me

[15:05] pregunta si deseo ejecutar las

[15:07] migraciones voy a decirle que sí y Listo

[15:10] ya tenemos nuestro eh Pro el scaffolding

[15:14] finalizado con nuestro proyecto

[15:15] preparado Entonces lo primero que voy a

[15:17] hacer antes de nada Y como siempre va a

[15:18] ser Acceder al directorio de trabajo

[15:21] para poder comenzar a realizar las

[15:25] modificaciones y la primera que vamos a

[15:27] estar realizando como decía va a es cómo

[15:30] vamos a estar afectando a la estructura

[15:32] de directorios si os fijáis y lo

[15:35] conocemos más que de sobra verdad dentro

[15:38] de la estructura de directorios dentro

[15:40] del eh directorio app o app lo que

[15:43] tenemos es aquí Toda la estructura de lo

[15:46] que corresponde al backend de la

[15:47] aplicación al igual que por ejemplo las

[15:49] vistas las tenemos por aquí dentro de

[15:51] los resources muy bien nosotros lo que

[15:54] vamos a hacer es desacoplar un poco todo

[15:57] lo que vamos a ir realizando ya

[15:59] directamente eh del toda la estructura

[16:02] incluso del directorio para que luego

[16:04] tengamos muy bien diferenciado todo lo

[16:06] que hemos ido trabajando nosotros de

[16:07] todo lo que el arabel aporta a nivel de

[16:10] infraestructura entonces lo que voy a

[16:12] hacer es crear un nuevo folder y este

[16:15] folder yo lo voy a llamar eh src o

[16:18] source o como queráis llamarlo el nombre

[16:21] no es relevante podéis llamarlo como

[16:22] prefiráis yo estoy acostumbrado a

[16:24] llamarlo eh src Ya que es bastante

[16:28] descriptivo de lo que vamos a estar

[16:30] ubicando dentro de esta parte y son en

[16:32] este caso todos nuestros recursos muy

[16:36] bien ya lo tenemos por aquí sin embargo

[16:38] eh Como bien sabéis cuando nosotros

[16:41] creamos aquí un directorio no es

[16:44] reconocido por l arabel es decir

[16:46] nosotros lo hemos introducido aquí pero

[16:48] no forma parte del proyecto necesitamos

[16:52] que forme parte del proyecto y para ello

[16:54] lo que vamos a estar haciendo es

[16:56] modificar nuestro compost ser Jason para

[17:00] que pueda indexar toda esta parte del

[17:03] contenido que nosotros vamos a estar

[17:05] desarrollando aquí en src y de esta

[17:07] forma podamos utilizarlo bien si

[17:10] acudimos por aquí al autoload que tiene

[17:14] el composer Jason este se encarga de

[17:17] realizar las cargas para los diferentes

[17:20] directorios y fijaos como nos autocarga

[17:22] ya o nos mapea ya el directorio de

[17:25] App

[17:27] nosotros vamos a indicar

[17:29] que también queremos mapear el

[17:31] directorio

[17:36] src y el directorio src que vamos a

[17:39] estar mapeando va a ir contra el

[17:41] directorio que acabamos de crear que es

[17:45] este de

[17:46] aquí muy bien ahora además de estar

[17:50] tomando el app del directorio app que es

[17:53] lo que ya hacía por Norma general además

[17:55] va a estar utilizando el src

[17:59] que nosotros hemos marcado aquí como src

[18:02] Y de esa forma Ya lo tenemos mapeado ya

[18:05] podremos hacer el el seguimiento Muy

[18:09] bien pues ya tenemos la primera de las

[18:12] partes que vamos a ir necesitando ahora

[18:16] además de eso vamos a realizar alguna

[18:19] modificación adicional para que no solo

[18:22] nos mape toda esta parte sino que

[18:24] podamos ir trabajando con el eh resto de

[18:28] de elementos que vamos a necesitar para

[18:30] ir configurando nuestra estructura vamos

[18:33] a por

[18:34] [Música]

[18:40] ello Muy bien pues vamos a continuar

[18:42] adaptando nuestra estructura y para

[18:44] poder realizarlo lo primero que vamos a

[18:46] tener que hacer es entender cuál va a

[18:49] ser la estructura de directorios que

[18:51] nosotros vamos a estar construyendo

[18:53] dentro de ese rc bien la estructura que

[18:57] vamos a seguir va a ser la siguiente y

[18:58] va ser bastante sencillo de entender

[19:01] sobre todo si ya habéis visto el el

[19:02] vídeo del de dday hexagonal Y es que lo

[19:05] primero que vamos a hacer dentro de src

[19:07] o en primer lugar lo que vamos a hacer

[19:09] es colocar un directorio por cada

[19:12] bounded context es decir por cada

[19:15] contexto vamos a crear un eh directorio

[19:18] dentro de src recordamos que dentro de

[19:22] los bounded context pues vamos a

[19:24] entender los diferentes usos que se

[19:26] pueden estar dando de nuestra

[19:29] plataforma no de nuestro desarrollo como

[19:31] podría ser por ejemplo Oye pues voy a

[19:33] crear un bounded context para el panel

[19:37] de administración o para el admin voy a

[19:39] crear un bounded context para el uso de

[19:42] este proyecto de la plataforma dentro de

[19:44] una web y voy a crear también a lo mejor

[19:46] pues no sé un tercer bounded context

[19:50] para para landing y material de

[19:53] marketing no independiente aquí cada

[19:55] cada proyecto tendría su bounded context

[19:57] concreto nosotros Pues dentro de la

[20:00] estructuración que vamos Air realizando

[20:01] voy a usar eso de momento como ejemplo

[20:03] para que podamos entender cuál va a ser

[20:05] la estructura entonces lo que decía si

[20:07] nosotros estamos haciendo vamos a

[20:09] suponer por ejemplo pues una plataforma

[20:11] de formación una plataforma e-learning

[20:14] tipo como la que podría ser además o

[20:15] como podría ser cser o como podría ser

[20:18] cualquiera de las otras pues lo primero

[20:22] que haría sería crear un bounded context

[20:25] admin lo voy a llamar así para colocar

[20:28] ahí todo lo referente a administración

[20:31] después vamos a crear otro bound context

[20:34] que en este caso lo voy a llamar cuidado

[20:37] que se creen src Ahí está que lo podría

[20:40] llamar pues por ejemplo e lms user

[20:45] platform o lo que sea es decir en este

[20:47] caso pues el contenido del desarrollo

[20:51] y voy a llamarlo si queréis platform que

[20:54] es más genérico para que lo entendamos

[20:56] vale platform de la plataforma y después

[20:59] Podría tener otro bounded context pues

[21:01] eso para landing marketing y otro tipo

[21:04] de elementos entonces cada uno de los

[21:06] bounded context lo vamos a generar en

[21:08] una carpeta todo esto lo iremos con la

[21:11] práctica ejemplificando y veréis que no

[21:14] es tan complicado es bastante sencillo

[21:16] al final ir diferenciando Cuáles son los

[21:18] contextos de uso que va a tener nuestra

[21:21] plataforma en este caso pues podemos

[21:23] marcar estos tres No ahora supongamos

[21:25] que yo inicialmente pues voy a estar

[21:27] desarrollando la plataforma en misma y

[21:29] ahora aquí dentro de la de de esta

[21:33] plataforma voy a definir cada uno de eh

[21:37] los módulos que voy a estar trabajando

[21:39] cada uno de los elementos cada una de

[21:42] las entidades con todo su contexto todo

[21:44] esto lo iremos viendo

[21:47] en sucesivas eh clases para que podáis

[21:51] entender muy bien Cuál es su

[21:53] estructura así pues ahora lo que vamos a

[21:55] estar haciendo es introducir dentro de

[21:58] cada uno de los bounded context los

[21:59] diferentes entidades o dominios que

[22:01] vamos a tener en cada uno de los

[22:03] elementos estas entidades o dominios que

[22:06] vamos a

[22:07] colocar Aunque ahora para que podamos

[22:09] entender la estructura pues vamos a ir

[22:11] ubicando una unas cuantas para hacer un

[22:14] ejemplo evidentemente luego a la hora de

[22:17] desarrollar pues las iremos creando

[22:19] conforme las vayamos necesitando en este

[22:22] caso ahora mismo yo por ejemplo pues voy

[22:24] a suponer de que en esta plataforma

[22:26] hubiese el

[22:29] curso que tuviese también el usuario por

[22:35] ejemplo y pues que hubiese también otro

[22:39] que fuesen por ejemplo pues

[22:42] certificaciones o diplomas o algo

[22:47] así muy bien como ejemplo nos vale no

[22:50] tenemos nuestro directorio src y nuestro

[22:53] dentro de nuestro directorio src los

[22:55] tres bounded context que hemos definido

[22:57] el uso de administrador el uso de

[22:59] landing y el uso para la plataforma y en

[23:02] el caso de la plataforma pues tenemos el

[23:04] curso el diploma y el usuario De igual

[23:08] forma si yo por ejemplo dentro de la

[23:11] Administración dentro del panel de

[23:13] administración también tuviese que usar

[23:15] por ejemplo el usuario también lo

[23:18] generaría dentro es decir también

[23:20] crearía aquí el usuario dentro de admin

[23:23] o suponiendo que dentro de admin Pues

[23:25] también esté por ejemplo eh usando el la

[23:29] administración de cursos por ejemplo

[23:31] Pues podría tenerlo podría darse ese

[23:33] caso de hecho es natural y normal que se

[23:36] dé porque aunque se llamen igual van a

[23:38] tener un contexto distinto en el caso de

[23:41] El bounded context de administración

[23:44] pues lo referente a a user pues serán

[23:47] acciones para Pues a lo mejor pues

[23:49] banear un usuario o eh restablecer la

[23:53] contraseña o dentro de los cursos Pues

[23:55] será para crear cursos para ah

[23:58] visualizar métricas de cursos lo que sea

[24:00] dentro de lo que tiene sentido dentro

[24:02] del panel de administración mientras que

[24:05] dentro de la sección de plataforma por

[24:06] ejemplo el la sección de usuario pues

[24:10] estará más enfocada a que un usuario

[24:12] pueda modificar su perfil por ejemplo o

[24:14] dentro de la sección de cursos pues lo

[24:16] que tendremos será listar cursos

[24:17] apuntarse a un curso etcétera cada uno

[24:20] le dará un uso distinto en base a su

[24:23] contexto todo esto lo sabemos del vídeo

[24:25] de arquitectura hexagonal y ddd bien

[24:29] teniendo esto Ahora como ejemplo y ya

[24:32] siguiendo esa estructura Pues por cada

[24:34] uno de los directorios que vayamos

[24:38] construyendo vamos a tener siempre y

[24:40] aquí tenemos nuestra capa de

[24:45] aplicación nuestra capa de

[24:49] dominio y nuestra capa de

[24:54] infraestructura qué es lo que Define a

[24:58] todo tod lo que estamos trabajando esto

[24:59] seguro que lo sabéis del vídeo es uno de

[25:02] los puntos más importantes con los que

[25:03] tenemos que quedarnos bien

[25:07] Entonces esto lo vamos a hacer por cada

[25:09] uno de ellos es decir si yo aquí dentro

[25:11] de diploma Pues también tendría

[25:15] infraestructure structure

[25:18] aquí tendría también

[25:21] domain tendría también

[25:26] application De igual forma con el resto

[25:29] igual concurso y también Dentro de este

[25:32] contexto con los

[25:34] correspondientes muy bien y ahora en

[25:37] base a

[25:39] eh aquí hay un punto un poco más

[25:41] subjetivo y por eso os comento ambas

[25:43] soluciones para que escojáis la que

[25:45] prefiráis Y es que ahora podemos dentro

[25:49] de la capa de dominio de usuario colocar

[25:51] Su contenido dentro de la capa de

[25:53] aplicación colocar Su contenido y De

[25:56] igual forma dentro de la capa de

[26:00] infraestructura colocar Su contenido y

[26:02] ya está o podemos también Seguir

[26:06] generando más estructura de directorios

[26:10] para

[26:11] diferenciarlo un poquito más No pues por

[26:13] ejemplo dentro de la capa de

[26:15] infraestructura Pues yo ahora podría

[26:17] diferenciar entre Pues no sé pues rutas

[26:21] podría diferenciar por ejemplo con

[26:23] perdón con repositorio

[26:29] podríamos eh eh tener también pues la

[26:34] capa de no sé de de

[26:37] observadores todo lo que pudiésemos

[26:39] necesitar no igual en la capa de domain

[26:43] donde podríamos tener por ejemplo la

[26:45] entidad las entidades normalmente la

[26:48] entidad y podríamos tener por ejemplo

[26:51] los value objects

[26:58] y De igual forma también en aplicación

[27:01] es decir podríamos ir diferenciando

[27:04] dentro de cada uno de cada una de las

[27:06] capas a su vez cada una de las subpartes

[27:08] que estas incluyen o

[27:11] no Cómo podemos hacerlo aquí como

[27:14] prefiráis no hay ninguna Norma que sea

[27:16] mejor que

[27:17] otra en mi caso yo suelo generar eh

[27:23] subestructura Si veo que los elementos

[27:26] Pues bueno pues tienen una estructura

[27:29] que lo merece es decir si solo voy a

[27:31] tener un par de casos de uso de la

[27:35] aplicación con una única con un único

[27:38] repositorio y una entidad con tres value

[27:42] objects Pues para eso quizá no merece la

[27:44] pena eh generar sub eh directorios o

[27:49] subestructura en el caso de que eh

[27:51] nuestros dominios sean más grandes

[27:53] nuestras entidades sean más mayores son

[27:54] mayores Bueno en ese caso pues Quizás sí

[27:56] que puede ser necesario en en este caso

[28:00] Yo a lo largo para seguir una

[28:01] metodología dentro de las clases yo sí

[28:04] voy a ir generando esos subdirectorios

[28:06] asumiendo de que lo que estamos

[28:08] desarrollando Pues bueno pudiese tener

[28:10] luego muchos adaptadores pudiese tener

[28:12] luego mucho contenido no entonces en

[28:14] base a eso voy a crear el subdirectorio

[28:16] Pero insisto si os sentís más cómodos no

[28:19] eh subdividiendo tanto el contenido

[28:21] también podéis hacerlo sin ningún

[28:24] problema bien hemos tenemos Entonces ya

[28:28] eh entendida Cuál va a ser la estructura

[28:30] de trabajo ya sabemos cómo vamos a ir

[28:32] ubicando cada uno de los elementos

[28:35] dentro del directorio src bounded

[28:38] context dentro de bounded context los

[28:40] diferentes eh dominios con sus este

[28:43] application lo escrito

[28:45] mal Ahí está con sus eh infraestructura

[28:51] dominio y aplicación representando a

[28:53] cada una de las tres capas y luego ya

[28:54] dentro de cada uno de ellos como queráis

[28:56] podéis colocarlo todo dentro o podéis

[28:59] también generar subestructuras como

[29:01] estoy haciendo yo aquí muy

[29:05] bien primera pregunta que os puede

[29:07] surgir en este punto y es Eh bueno pues

[29:12] una de las cosas que podemos apreciar es

[29:15] que la estructuración de cada uno de los

[29:17] elementos necesita de múltiples carpetas

[29:21] No es simplemente un fichero o lo que

[29:23] sea sino que tenemos que colocar

[29:25] diferentes eh directorios con

[29:28] subdirectorios etcétera y esta tarea se

[29:30] puede hacer tediosa

[29:34] entonces Cómo podemos

[29:36] eh acelerar esto bien os voy a dejar

[29:41] en en el la descripción en la cajita de

[29:44] descripción un comando que he escrito

[29:48] para que nos genere toda esta estructura

[29:50] de código sin necesidad de que tengamos

[29:54] que estar haciendo cada uno de de los

[29:58] directorios cada vez os voy a explicar

[30:01] cómo funciona por si queréis utilizarlo

[30:03] si no queréis utilizarlo pues no pasa

[30:05] nada podéis hacerlo también como

[30:07] prefiráis podéis crear vuestros

[30:08] directorios lo que más cómodo os resulte

[30:11] pero yo os lo voy a pasar porque es muy

[30:13] tedioso tener que estar creando

[30:15] directorio directorio directorio a veces

[30:17] estos directorios Pues nos podemos

[30:19] equivocar como me ha ocurrido a mí

[30:20] anteriormente y tener un error de

[30:22] tipográfico o lo que sea y para evitar

[30:25] todo eso pues os voy a dejar ahora un un

[30:28] comando para utilizarlo lo primero que

[30:29] voy a hacer antes de nada eso sí

[30:32] recordad que en la versión eh 12 del

[30:36] arabel la parte de appi no nos aparece

[30:40] instalada por defecto Así que vamos a

[30:42] instalarla El Comando install Api

[30:45] siempre lo pongo al

[30:47] revés muy bien para dejarla eh instalada

[30:52] sin la sección De Api para que este eh

[30:55] esta infraestructura del arabel pues lo

[30:56] soporte que recorda que ahora desde las

[30:59] últimas versiones Hay que hacerlo

[31:01] manualmente no viene en el scaffolding

[31:03] inicial muy

[31:06] bien Esto Ya termina Por

[31:09] aquí sí vamos a migrar todo lo

[31:12] necesario y vamos a poner el Trade en el

[31:17] modelo de

[31:18] usuario para dejarlo ya totalmente

[31:21] instalado

[31:29] como ya sabéis hacer aquí nada

[31:35] nuevo muy

[31:37] bien y ahora que tenemos esta parte De

[31:39] Api como decía ya tenemos eh sabemos

[31:42] Cuál va a ser la estructura que vamos a

[31:44] desear generar Así que os voy a enseñar

[31:47] ese comandito que tengo por ahí me lo

[31:49] voy a traer a este proyecto y eh si

[31:53] queréis usarlo Pues a vuestra

[31:55] disposición queda

[31:58] [Música]

[32:04] muy bien ya tengo por aquí El Comando

[32:07] que tengo creado para esto eh lo podéis

[32:11] importar desde desde el repo que tenéis

[32:13] en la descripción para os lo podéis

[32:15] traer Y si queréis hacerlo manualmente

[32:17] es muy sencillo en

[32:19] App directorio console si no está lo

[32:22] creáis directorio commands si no está lo

[32:25] creáis y dentro

[32:27] fichero del Comando para poder usarlo

[32:32] este Comando es muy sencillo simplemente

[32:33] os el la firma es decir lo llamamos con

[32:37] make do. ddd y ahora nos va a pedir dos

[32:41] elementos en primer lugar el bounded

[32:43] context donde tiene que crear el la

[32:46] estructura y si no existe la creará Y en

[32:50] segundo lugar la entidad que debe crear

[32:55] hagamos un ejemplo nosotros por ejemplo

[32:57] aquí tenemos en src Pues tenemos la

[33:01] sección platform y aquí tenemos por

[33:05] ejemplo curso diploma y usuario No pues

[33:07] vamos a suponer que tuviésemos otro que

[33:12] fuese por ejemplo pues el contexto de

[33:15] compra por ejemplo de purchase no vamos

[33:18] a hacerlo si yo ahora digo php artisan

[33:21] make do pun ddd que es como se llama el

[33:27] El Comando que os estoy pasando y a

[33:30] partir de ahí le digo Cuál es el bounded

[33:32] context donde Quiero crear la estructura

[33:35] por ejemplo en este caso la el de

[33:38] platform y dentro de platform ahora voy

[33:41] a indicarle cuál es la entidad que voy a

[33:44] estar desarrollando en este caso pues

[33:46] hemos dicho que

[33:49] purchase lo ejecutamos perfecto os

[33:52] debería ir avisando por aquí de todo lo

[33:54] que ha hecho vale porque eso es lo que

[33:56] tengo escrito aquí básicamente os va

[33:59] informando de que va creando la

[34:00] estructura de que va creando cada una de

[34:02] las cosas entonces veréis que os va

[34:04] avisando de todo lo que ha ido creando Y

[34:07] si acudimos ahora a la sección del src

[34:11] platform ahora encontramos que nos ha

[34:13] creado el purchase y aquí ya os ha

[34:15] generado toda la estructura dentro de

[34:18] infraestructura os ha creado los

[34:20] controladores eventos lisen repositorios

[34:22] rutas validadores que son las más

[34:25] comunes puede que tengáis más además os

[34:28] ha creado el archivo de rutas ya

[34:32] preparado con algunos ejemplos

[34:34] comentados por si queréis ya des

[34:36] comentarlos y usarlos y dentro de

[34:39] controladores os ha generado también por

[34:41] aquí algún controlador de ejemplo y

[34:44] dentro de aplicación no no os genera

[34:48] nada no es necesario y dentro de domain

[34:50] pues toda su estructura los contratos

[34:51] que son las interfaces que vamos a estar

[34:53] trabajando las entidades y los value

[34:56] objects de tal forma de que a mí este

[34:59] Comando cuando lo escribí lo escribí

[35:01] sobre todo porque me resultaba Útil para

[35:03] no tener que estar copiando directorio

[35:06] por directorio una y otra vez Así que si

[35:09] os resulta de interés pues os lo dejo

[35:11] por ahí para que lo podáis usar pero

[35:13] siempre si no lo queréis usar no es

[35:16] necesario podéis hacerlo también

[35:17] manualmente o acudir a cualquier otro

[35:19] tipo de automatización en función al

[35:21] editor que estéis utilizando solo un

[35:24] punto más dentro de esta parte de de

[35:26] estructuración y ya lo dejamos todo

[35:29] listo y es que

[35:33] em Cómo cargamos las rutas dentro de

[35:37] toda esta estructura Pues bien las rutas

[35:41] como bien sabéis el punto de entrada es

[35:43] este de aquí el rotes punto en este caso

[35:46] api.php y si os fijáis El Comando que yo

[35:50] os he pasado Ya os va a crear la lectura

[35:54] de vuestro fichero de rutas fijaos que

[35:57] cuando cu hemos ejecutado el make ddd

[35:59] pues os ha creado Aquí esta ruta de aquí

[36:02] que os genera el platform purchase que

[36:06] está

[36:07] apuntando a la estructura que ha creado

[36:11] es decir con el comando que os he pasado

[36:12] no os tenéis que preocupar de derivar

[36:15] las rutas pero es posible que prefiráis

[36:19] hacer alguna otra estructura que

[36:22] prefiráis hacer una derivación por

[36:24] ejemplo que no dependa del Api sino que

[36:27] queráis por ejemplo cargarla dentro

[36:30] de pues por ejemplo que queréis hacer un

[36:32] service Provider o un Root service

[36:34] Provider para ello o que a lo mejor

[36:37] queráis veniros aquí al boostrap app y

[36:40] aquí donde mapea las rutas Pues igual

[36:43] que mapea las rutas de web o De Api

[36:46] queréis modificarle el mapeo de las

[36:49] rutas para que lea directamente las de

[36:51] ese directorio como prefiráis lo que sí

[36:55] es importante que tengamos en cuenta es

[36:56] que los directorios de rutas l arabel

[37:00] tiene que conocerlos porque es el punto

[37:02] de conexión Vale entonces eso eso debe

[37:04] conocerlo Sabiendo eso y teniendo eso

[37:07] controlado todo lo demás da igual

[37:08] podemos hacerlo como prefiráis en

[37:11] cualquier caso no tenéis que preocuparos

[37:14] por ello porque lo vamos a ir viendo

[37:16] paso a paso todo lo que hemos hecho a lo

[37:18] largo de este primer vídeo única y

[37:20] exclusivamente es preparar nuestro

[37:23] entorno del arabel para que sea un poco

[37:26] más cómodo y nos permita trabajar bien

[37:29] con las estructuras hexagonales y con

[37:32] ddd Entonces ahora sí lo tenemos ya

[37:36] preparado tenemos nuestra carpeta src

[37:39] que está siendo descubierta por el

[37:41] autoload del composer y dentro de ella

[37:44] Vamos a ir colocando los bounded context

[37:46] con las diferentes entidades con las

[37:48] tres capas la de infraestructura la de

[37:51] dominio y la de aplicación Esa es la

[37:54] base que tenemos que tener Clara y para

[37:57] acelerar toda esta parte del proceso

[37:59] tenemos este

[38:00] eh este Comando que os paso por aquí que

[38:04] os comparto por si os resulta de interés

[38:06] para no perder mucho tiempo generando

[38:08] esas estructuras de forma

[38:10] repetitiva bien tenemos Entonces el toda

[38:16] la base que necesitamos para poder

[38:18] construir nuestros proyectos vamos a ir

[38:19] construyendo

[38:21] diferentes desarrollos a lo largo de

[38:23] esta serie de vídeos por lo tanto yo os

[38:25] recomiendo que os hagáis un Boiler Plate

[38:28] con esto es decir sub subí al repo esta

[38:31] parte que es común y así cada vez que

[38:33] empecéis un nuevo proyecto solo tenéis

[38:35] que clonar os ese boiler Plate que os

[38:37] habéis creado Y partís desde ahí y no

[38:39] tenéis que estar haciendo todo este

[38:41] proceso una vez y otra vez de hecho os

[38:43] recomiendo que en este boiler Plate añad

[38:46] todo lo que os pueda resultar

[38:47] interesante no solo esto por ejemplo si

[38:49] queréis Añadir la documentación de

[38:51] scramble o si queréis hacer eh añadirle

[38:55] alguna implementación de panel de

[38:57] administración cualquier filament lo que

[38:59] sea todas las cosas que siempre usáis

[39:01] dentro de vuestro desarrollo o que son

[39:04] comunes ubicad lasas ya Dentro de este

[39:06] boiler Plate y así cada vez que

[39:08] empecemos a desarrollar lo único que

[39:09] tenéis que hacer es clonar ese proyecto

[39:12] base y ya tenéis toda la estructura para

[39:15] comenzar desde ahí Muy bien pues tenemos

[39:20] todo preparado como decía el siguiente

[39:23] lunes tenemos el el segundo vídeo de la

[39:26] serie Espero que os resulte de interés a

[39:30] toda esta línea A toda esta serie si os

[39:33] interesa de verdad toda esta parte pues

[39:34] dadle apoyo ya sabéis que todos los

[39:37] likes suscripciones y todo eso siempre

[39:39] se aprecian mucho y nos vemos en el

[39:41] siguiente vídeo yo me voy a trabajar a

[39:44] programar

[39:46] [Música]

[40:05] you