Parte 2: Cómo crear entidades, migraciones y conectarnos a una base de datos con Symfony 6

En este tutorial vamos a ver cómo conectarnos a una base de datos y crear las entidades que después nos servirán para crear las tablas automáticamente con Symfony 6.

👋 Seguimos con la serie de tutoriales de Symfony 6 💪. La primera parte fue una introducción y en esta segunda parte nos vamos a meter más en el meollo, si te lo perdiste, os dejo a continuación toda la serie hasta la fecha:

• Parte 1: Cómo crear una webapp con Symfony 6
• Parte 2: Cómo crear entidades, migraciones y conectarnos a una base de datos con Symfony 6
• Parte 3: Cómo crear datos falsos en una base de datos con Symfony 6
• Parte 4: Controladores, templates y estilos con Tailwind CSS en Symfony 6
• Parte 5: Optimización de queries con Doctrine, ajustes y página de post en Symfony 6
• Parte 6: Autenticación y registro con Symfony 6

Sin más dilación, empezamos con la segunda parte 🚀.

Tablas de nuestra base de datos

Lo primero que vamos a definir son las tablas que vamos a necesitar, en mi caso he decidido crear cuatro tablas, users para almacenar los usuarios, posts para guardar los posts que escriba un usuario, tags para poder categorizar los posts y comments para guardar los comentarios que escriba un usuario en un post.

Aquí te dejo las tablas, campos que he decidido crear y sus tipos.

users
	- id: int
	- roles: json
	- password: string
	- email: string
	- username: string
tags
	- id: int
	- name: string
posts
	- id: int
	- title: string
	- slug: string
	- created_at: datetime
	- updated_at: datetime
	- publication_date
	- is_draft: boolean
	- content: longtext
	- id_user: int
comments
	- id: int
	- created_at: datetime
	- content: longtext
	- id_user: int
	- id_post: int

Conectarnos a la base de datos con Symfony 6 🚠

Una vez definidas las tablas, vamos a crear la conexión a la base de datos. Para ello vamos al archivo .env en el directorio raíz y dentro encontraremos una clave llamada DATABASE_URL en la que tendremos que indicar los parámetros de conexión.

Por defecto viene habilitada la conexión para PostgreSQL, pero como yo voy a utilizar MySQL, he comentado esta línea y he des comentado la línea de MySQL. Después solo debemos sustituir los parámetros de conexión por defecto por los nuestros:

# DATABASE_URL="mysql://<user>:<password>@127.0.0.1:3306/<database_name>?serverVersion=5.7&charset=utf8mb4"
# En mi caso sería así:
DATABASE_URL="mysql://cosasdedevs:gEU7aa06m9G1@127.0.0.1:3306/blog_symfony?serverVersion=5.7&charset=utf8mb4"

En mi caso, he llamado a la base de datos blog_symfony y no te preocupes si no existe porque vamos a ver como crearla automáticamente con Symfony 6.

Si vas a utilizar una base de datos distinta a MySQL, te dejo este enlace que explica como crear los distintos tipos de conexiones:

https://symfony.com/doc/current/doctrine.html#configuring-the-database

Crear una base de datos con Symfony 6 🚧

Una vez establecido los parámetros de conexión, ya podemos acceder a nuestra base de datos desde Symfony 6, pero para ello primero debemos crear la base de datos, esto lo podemos hacer con el siguiente comando:

php bin/console doctrine:database:create

Si todo ha ido bien, te aparecerá un mensaje confirmándote que la base de datos se ha creado satisfactoriamente. Si no es así, revisa que tus parámetros de conexión son correctos y que el usuario de la base de datos tiene permisos para crear la base de datos.

Una vez tengamos la base de datos lista, es hora de crear las entidades y repositorios que necesitaremos 💪.

Qué son las entidades 🤔

Una entidad es una clase que representa un registro en la base de datos, como un usuario, un post o un comentario. Es una forma de modelar la información en la aplicación para poder trabajar con ella en forma de objeto y está mapeada a una tabla en la base de datos.

Qué son los repositorios 🤨

Un repositorio es un objeto que proporciona una interfaz para acceder a los datos almacenados en la base de datos, como búsqueda, filtrado y actualización de entidades. Es una forma de abstraer la lógica de acceso a datos y se asocia con una entidad específica. Los repositorios son objetos de Doctrine, que es el ORM con el que trabajaremos en Symfony 6.

Crear la entidad para usuarios

La primera entidad con la que vamos a trabajar será la de usuarios. Para ello nos valdremos de un comando de Symfony 6 el cual nos creará la entidad automáticamente con varios campos ya definidos y actualizará el archivo de la configuración de seguridad de nuestro proyecto (config/packages/security.yaml):

php bin/console make:user

Una vez lanzado el comando, se habilitará un asistente y nos hará una serie de preguntas en las que yo he aceptado todos los parámetros por defecto.

 The name of the security user class (e.g. User) [User]:
 > 

 Do you want to store user data in the database (via Doctrine)? (yes/no) [yes]:
 >

 Enter a property name that will be the unique "display" name for the user (e.g. email, username, uuid) [email]:
 >

 Will this app need to hash/check user passwords? Choose No if passwords are not needed or will be checked/hashed by some other system (e.g. a single sign-on server).

 Does this app need to hash/check user passwords? (yes/no) [yes]:
 >

 created: src/Entity/User.php
 created: src/Repository/UserRepository.php
 updated: src/Entity/User.php
 updated: config/packages/security.yaml

Si accedéis a la clase src/Entity/User.php, podréis ver los campos ya predefinidos que son, id, email, roles y password. Como nosotros también queremos añadir el campo username, tendremos que editar la entidad. Para ello lanzamos el siguiente comando:

php bin/console make:entity

• Primero nos preguntará que entidad queremos crear o editar, en este caso la entidad User.
• Después nos pregunta el campo que queremos añadir, en nuestro caso username.
• El siguiente paso es indicar que tipo de dato es, en este caso, string (si queremos ver todos los tipos de datos, escribimos '?', y nos aparecerá un listado con todos los tipos válidos).
• Luego indicaremos el tamaño del campo, aquí he indicado que tendrá un máximo de 100 caracteres.
• Por último nos preguntará si queremos que el campo pueda ser nulo y le decimos que no.

Ahora nos preguntará si queremos añadir algún campo más y como no es así, pulsamos enter y listo, ya tenemos el nuevo campo.

Crear la entidad para tags

Para crear la entidad tags, lanzaremos el comando de Symfony 6 que nos permite generarlas, la diferencia con el comando anterior es que este es para crear cualquier tipo de entidad y el anterior se utiliza para crear concretamente la de usuarios con campos predefinidos y realiza las modificaciones en la configuración de seguridad de nuestro proyecto como comenté anteriormente.

Este comando lo usaremos para crear/modificar el resto de entidades:

php bin/console make:entity

• Primero nos pregunta el nombre que le queremos dar que será Tag.
• Después nos pide añadir un campo, aquí escribimos el nombre del campo que se llamará name.
• Luego nos pregunta el tipo, en este caso será string.
• La siguiente pregunta es el tamaño del campo, aquí indicaremos 50 caracteres.
• Y por último indicamos que no podrá ser nulo.

Como no queremos añadir más campos, pulsamos enter y salimos del asistente.

Crear la entidad para posts

Al igual que en el caso anterior, lanzamos el comando para crear una entidad y en este caso la llamaremos Post. Después solo debemos añadir los siguientes campos como ya hemos visto antes, pero esta vez NO SALGAS DEL ASISTENTE cuando añadas el último campo, ya que tendremos que añadir la relación entre la tabla posts y users y posts y tags y esa la explicaré más a fondo.

• Nombre: title, tipo: string, tamaño 255, no nulo.
• Nombre: slug, tipo: string, tamaño 255, no nulo.
• Nombre: created_at, tipo: datetime_immutable, no nulo.
• Nombre: updated_at, tipo: datetime_immutable, si puede ser nulo.
• Nombre: publication_date, tipo: datetime_immutable, si puede ser nulo.
• Nombre: is_draft, tipo: boolean, no nulo.
• Nombre: content, tipo: text, no nulo.

Como he comentado antes, el siguiente campo será la relación entre la tabla users y posts. Para crearlo seguiremos los siguientes pasos:

Primero añadimos el nombre de la propiedad que será llamada user.

Después tenemos que añadir el tipo de dato, aquí tenemos una posibilidad muy interesante y es que si le decimos de tipo relation, nos preguntará con que entidad queremos relaciornala, en nuestro caso con la entidad User y que tipo de relación queremos generar, lo que nos facilitará mucho el trabajo:

Field type (enter ? to see all types) [string]:
 > relation

 What class should this entity be related to?:
 > User

What type of relationship is this?
 ------------ ----------------------------------------------------------------- 
  Type         Description
 ------------ -----------------------------------------------------------------
  ManyToOne    Each Post relates to (has) one User.
               Each User can relate to (can have) many Post objects.

  OneToMany    Each Post can relate to (can have) many User objects.
               Each User relates to (has) one Post.

  ManyToMany   Each Post can relate to (can have) many User objects.
               Each User can also relate to (can also have) many Post objects.

  OneToOne     Each Post relates to (has) exactly one User.
               Each User also relates to (has) exactly one Post.
 ------------ -----------------------------------------------------------------

Como ves, nos explica de forma clara que tipo de relaciones existen y que implica cada una. En nuestro caso, un post pertenecerá a un único usuario y un usuario podrá tener varios posts por lo que seleccionaremos ManyToOne.

Luego nos pregunta si queremos que el campo pueda ser nulo y le diremos que no.

Después nos pregunta si queremos tener un método para obtener todos los posts por usuario y también le decimos que no.

Por último, sin salir del asistente, vamos a añadir la relación de tags con posts. Para ello seguimos los mismos pasos:

• Como nombre la llamaremos tags.
• Será de tipo relation.
• La entidad relacionada será Tag.
• El tipo de relación será ManyToMany porque un post puede tener varios tags y un tag puede pertenecer a varios posts.
• Por último nos pregunta si queremos crear el método para obtener todos los posts de un tag y le decimos que sí.

Listo, ya tenemos preparada la entidad para nuestros posts.

Crear la entidad para comentarios

Por último, crearemos la entidad para los comentarios. Lanzamos el comando y la llamaremos Comment.

Los campos deberán tener la siguiente configuración:

• Nombre: created_at, tipo: datetime_immutable, no nulo.
• Nombre: content, tipo: text, no nulo.
• Nombre: user, tipo: ManyToOne, entidad: User, no nulo, obtener comentarios desde el usuario: no.
• Nombre: post, tipo: ManyToOne, entidad: Post, no nulo, obtener comentarios desde el post si, eliminar comentarios si se elimina el post, sí.

Modificar campos para que sean de tipo único

Ahora que ya tenemos todas nuestras entidades listas, vamos a realizar unas pequeñas modificaciones, ya que quiero forzar a que algunos campos sean únicos en la base de datos como el username, el nombre de un tag y el título y slug de los posts.

Primeo vamos a modificar el username. Para realizar esta acción, vamos a la entidad User.php (src/Entity/User.php) y modificamos la declaración de la variable $username para que quede así:

#[ORM\Column(length: 100, unique: true)]
private ?string $username = null;

Como puedes ver, lo único que hemos hecho, es añadir a la anotación de la columna el parámetro unique: true.

Ahora haremos lo mismo para Tag.php (src/Entity/Tag.php).

#[ORM\Column(length: 50, unique: true)]
private ?string $name = null;

Y por último para Post.php (src/Entity/Post.php).

#[ORM\Column(length: 255, unique: true)]
private ?string $title = null;

#[ORM\Column(length: 255, unique: true)]
private ?string $slug = null;

Ahora si tenemos las entidades listas, así que el siguiente paso es generar las migraciones.

Qué son las migraciones

Las migraciones son un proceso por el cual Symfony nos permite crear/actualizar la estructura de la base de datos de nuestra aplicación sin perder datos. Las migraciones se definen como scripts en PHP que describen cambios en la estructura de la base de datos, como agregar o eliminar tablas, columnas, etc. Estos scripts se pueden generar y ejecutar de manera automática y controlada mediante comandos de Symfony.

Crear migraciones y subir los cambios a nuestra base de datos

Para crear el archivo de migración, debemos lanzar el siguiente comando:

php bin/console make:migration

Este comando generará un script PHP dentro de la carpeta migrations y si lo abrimos podremos ver las queries necesarias para crear nuestras tablas con base en la información almacenada en nuestras entidades.

Una vez creada la migración, ya podemos crear nuestras tablas de forma automática gracias a Symfony. Para ello debemos lanzar el siguiente comando:

php bin/console doctrine:migration:migrate

Si todo ha ido bien, podemos acceder a nuestra base de datos y visualizar las tablas.

Y listo, con esto podemos dar por finalizado este tutorial. Te dejo en enlace al repositorio https://github.com/albertorc87/blog-symfony-tutorial/tree/crear-entidades-migraciones-conexion-base-de-datos-symfony-6 y en el próximo veremos como crear datos de prueba en nuestras tablas para tener información con la que trabajar 💪.

Espero que este post te ayude y como siempre, te recomiendo seguirme en Twitter para estar al tanto de los nuevo contenido. Ahora también puedes seguirme en Instagram donde estoy subiendo tips, tutoriales en vídeo e información sobre herramientas para developers.

Por último os dejo mi guía para aprender a trabajar con APIs donde explico todo el funcionamiento de una API, el protocolo HTTP y veremos como construir una API con arquitectura REST.

Nos leemos 👋.