Symfony: tutorial 2: los comandos de consola

Una respuesta a porqué Symfony es tan productivo son los comandos de consola. Con simples comandos podemos crear un proyecto nuevo, añadir nuevos componentes, lanzar un servidor de pruebas, chequear las URLs, crear entidades que vamos a guardar en base de datos, probar el envío de emails. También podemos modificar las tablas de datos, añadir nuevos elementos, editar los existentes, actualizar la base de datos, preparar nuevos elementos para almacenar, generar pantallas de listado de datos, ediciones de datos, borrados o creaciones. Generamos formularios automáticamente, con recepción de sus datos y guardado de dichos formularios en bases de datos. Podemos importar una base de datos de otro proyecto, generando todo el código fuente de una aplicación web que consulte los datos de dicha BD en apenas un rato. Podemos crear controladores, estructurando todas las zonas de la web, con sus plantillas, rutas, y URLs en poco tiempo. Y mucho más..

No tenemos que gastar tiempo en tediosas tareas repetitivas de construcción, y podremos centrarnos en lo especial de la aplicación web que estemos creando. Todas estas herramientas de generación de código las tenemos mediante comandos de consola. Cuantos más módulos añadas probablemente más comandos tendrás que te harán mucho más productivo. Te ahorrarán muchísimo tiempo, pero tienes que saber que estan ahí, saber cómo funcionan, y usarlos siempre que puedas. Hay que coger práctica con los comandos para aprovechar la productividad que te da Symfony.

Dicho esto, vamos al grano a ver los que pienso que primero hay que conocer y cómo crear uno propio.

Creando un proyecto para pruebas

Lo primero que hacemos es abrir un terminal o línea de comandos. Doy por sentado que ya conocemos cómo funciona bien PHP y Composer y tenemos bien preparado el espacio de trabajo. Con las versiones anteriores a Symfony 5 podemos ir al terminal y ejecutamos:

$ composer create-project symfony/skeleton symfony-tutorial-2
$ cd symfony-tutorial-2
$ composer require twig form security doctrine maker server swiftmailer-bundle

A partir de la versión 5 se han borrado los códigos deprecated, el servidor de desarrollo ha pasado al comando symfony. Conviene usar más el comando symfony, para instalarlo se puede seguir esta guía: https://symfony.com/download

Para crear un nuevo proyecto con el comando de Symfony para los proyectos a partir de Symfony 5 es:

$ symfony new symfony-tutorial-2
$ cd symfony-tutorial-2
$ composer require twig form security doctrine maker swiftmailer-bundle

Fíjate que he quitado el bundle server al hacer Composer instale los bundles.. Esperamos, y si todo a ido bien, ya tenemos un nuevo proyecto con Symfony Flex (Symfony 4) listo para construir. Vamos a listar todos los comandos que tenemos ahora mismo, para esto ponemos:

$ php bin/console

Hasta aquí, con los módulos que acabo de instalar me salen los siguientes comandos por pantalla:

Usando los primeros comandos

Uno de los primeros comandos a usar puede ser el arrancar un servidor web para trabajar. No necesitas una compleja instalación de Apache, ni un entorno completo LAMP para trabajar proyectos Symfony. Realmente sólo con PHP bien instalado basta para comenzar. Así en versiones anteriores a Symfony 5 podíamos hacer lo siguiente para arrancar el proyecto en un servidor local:

$ php bin/console server:start

..y navegamos a http://localhost:8000/ para ver nuestro proyecto. Para parar el servidor local:

$ php bin/console server:stop

El comando para lanzar el servidor se ha llevado al comando symfony a partir de la versión 5. Para lanzarlo se puede hacer así:

$ symfony server:start

Los comandos que empiezan por make: y los de doctrine: son los primeros y más habituales. Todos los make: son los que te generarán las estructuras de código iniciales para ir al grano a programar. Antes de ponerse a ejecutar comandos a lo loco, conviene sentarse con papel y lápiz todo el tiempo necesario, hasta haber diseñado bien la aplicación web que queremos construir. Algunos de estos comandos son:

$ php bin/console make:controller

..que sirve para crear un nuevo cotrolador que reciba las visitas de ciertas URLs.

$ php bin/console debug:router

..que sirve para ver las rutas accesibles desde el navegador. Junto con el make:controller, con este debug:router, veremos si estamos configurando bien los controladores.

$ php bin/console make:entity

..que sirve para crear o actualizar una entidad. Este comando es muy importante y potente, te hará muy productivo si lo usas correctamente. En otro tutorial trataremos las entidades de doctrine, porque dan mucho juego, y son la base de todo almacén de datos de nuestra aplicación.

$ php bin/console make:crud

..que sirve para crear lo que llamamos un CRUD a partir de una entidad. Un CRUD corresponde a las pantallas básicas para listar, ver, editar o borrar entidades. Por ejemplo, si tenemos una entidad que sea Persona, podemos generar el CRUD y así tendremos el controlador y vistas de Twig generadas automáticamente para listar, ver, editar o borrar personas de nuestra aplicación.

$ php bin/console make:form

..que sirve para crear formularios. Igual que el make:crud, este comando usa una entidad que hayamos creado para generar, en función a los parámetros que tenga la entidad, un formulario correspondiente con los mismos parámetros. El make:crud también te genera un formulario ya que en la pantalla de crear y en la de editar que crea, usa este formulario. Es decir, si hemos usado el make:crud de la entidad, ya tendremos el formulario creado en el directorio src/Entity/

$ php bin/console make:command

..que sirve para crear nuevos comandos de consola.

$ php bin/console make:migration

..que sirve para preparar una actualización de la base de datos. Este comando se ha integrado en esta versión de Symfony, para facilitarnos la vida haciendo actualizaciones de la base de datos en producción. Viene del Doctrine Migrations, que sirve para detectar cambios de la BD, haciendo scripts de actualización y restauración, por si hubiera que volver atrás los últimos cambios.

$ php bin/console make:functional-test

..que sirve para crear tests funcionales. Estos tests son los que simulan la visita de un usuario a la web, simulando su navegación, detectando respuestas de error del servidor, o comprobando contenidos de respuesta. Por ejemplo, con esto se puede simular el login de usuario y así estaremos seguros de que si pasa el test es que sigue funcionando, antes de pasar todo a producción.

$ php bin/console make:unit-test

..que sirve para crear los tests unitarios. Igual que los funcionales simulan las visitas de usuario, los unitarios, por simplificarlo, testean partes pequeñas de la aplicación web. Es decir, pueden comprobar el funcionamiento de ciertas funciones, servicios.. partes pequeñas de la web que podemos comprobar independientemente.

Otros comandos también muy interesantes.

$ php bin/console doctrine:database:create
$ php bin/console doctrine:database:drop --force

..que sirven para crear o borrar la base de datos.

$ php bin/console doctrine:schema:create
$ php bin/console doctrine:schema:update --dump-sql --force
$ php bin/console doctrine:schema:drop --force

..junto con los comandos anteriores, primero podemos crear la base de datos, luego con estos actualizamos los esquemas. Es decir, los esquemas son las tablas, claves ajenas, primarias, etc.. todo lo que vamos trabajando en las entidades.

Un comando muy, pero que muy interesante, que nos sirve para traernos un proyecto a Symfony es:

$ php bin/console doctrine:mapping:import App\\Entity annotation --path=src/Entity

..que sirve para, dada una base de datos con sus tablas, genera los ficheros de entidades en PHP. Así tendremos un punto de partida muy bueno, y en muy poco tiempo, para comenzar a trabajar.

Como he instalado el swiftmailer-bundle también tenemos este comando:

$ php bin/console swiftmailer:email:send

..que sirve para enviar un email. Siguiendo las instrucciones por pantalla, verás si la aplicación puede enviarte un emails con el contenidos que escribes. Si no puede Symfony enviártelo, es que te falta configurarlo bien (usuario, contraseña, servidor SMTP, etc..).

En líneas generales, estos son los primeros a utilizar. Según vayas instalando más bundles, se irán añadiendo más y más comandos. La forma de trabajarlos siempre es la misma. Recomiendo que pruebes y pruebes con todos estos comandos, para que cojas práctica viendo hasta donde alcanzan. Úsalos, crea ficheros de pruebas, borra el proyecto, rómpelo, crea otro nuevo, así es como se aprende 😉

Creando un comando propio

No podemos terminar este post sin ver cómo crear un comando propio. Para esto comenzamos por ejecutar lo siguiente:

$ php bin/console make:command

..nos preguntará cómo queremos llamarle, le ponemos por ejemplo ‘app:mi-comando’ y le damos enter. Nos informará de que ha creado el fichero:

src/Command/MiComandoCommand.php

Lo abrimos y ya tenemos el comando listo para añadirle funcionalidades. Mirando el código creo que sobran explicaciones. Para ejecutarlo no tenemos más que escribir en terminal lo siguiente:

$ php bin/console app:mi-comando

<?php

namespace App\Command;

use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Input\InputArgument;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Input\InputOption;
use Symfony\Component\Console\Output\OutputInterface;
use Symfony\Component\Console\Style\SymfonyStyle;

class MiComandoCommand extends Command
{
    protected static $defaultName = 'app:mi-comando';

    protected function configure()
    {
        $this
            ->setDescription('Add a short description for your command')
            ->addArgument('arg1', InputArgument::OPTIONAL, 'Argument description')
            ->addOption('option1', null, InputOption::VALUE_NONE, 'Option description')
        ;
    }

    protected function execute(InputInterface $input, OutputInterface $output): int
    {
        $io = new SymfonyStyle($input, $output);
        $arg1 = $input->getArgument('arg1');

        if ($arg1) {
            $io->note(sprintf('You passed an argument: %s', $arg1));
        }

        if ($input->getOption('option1')) {
            // ...
        }

        $io->success('You have a new command! Now make it your own! Pass --help to see your options.');

        return 0;
    }
}

¿Fácil verdad? Pues es muy práctico programar en comandos ciertas acciones como revisiones periódicas, para sacar informes de la base de datos, para programar tareas a ejecutar cada X tiempo, etc.. todo este tipo de acciones que no deben de lanzarse visitando el navegador es muy útil programarlas desde un comando.

En los siguientes capítulos de este tutorial veremos cómo trabajar con datos, que creo que es lo siguiente más interesante.

Dejo en GitHub el código fuente para este tutorial:
https://github.com/jaimenj/symfony-starter-tutorials

Aquí la documentación oficial sobre la consola para seguir:
https://symfony.com/doc/current/components/console.html

Sólo me queda decir que este post es parte de otro tutorial de los muchos que hay sobre Symfony, por si te animas a seguirlo, los tienes todos enlazados aquí:
https://jnjsite.com/tutoriales-para-aprender-symfony/

¡Un saludo!