Las Novedades más destacadas que trae Laravel 8

9 minuto(s)

En esta página:

El día 8 de Septiembre de 2020 ha sido lanzada la versión 8 de Laravel, que cuenta con nuevas características como el directorio para los modelos, aplanamiento de las migraciones (Squashing), trabajos o Jobs por lotes, mejoras en el modo mantenimiento, componentes dinámicos en las vistas blade, mejoras en los oyentes de eventos, etc. En este Post te contaré todos los detalles de estas nuevas características, vamos con ello.

Antes de continuar, te invito a leer los siguientes artículos:

Asimismo te invito a escuchar el Podcast: “Como Mantenerte Motivado Para Seguir Programando”:

Spotify:	Sound Cloud:

Bien ahora continuemos con el Post: Las Novedades más destacadas que trae Laravel 8.

Desde la versión 7 de Laravel el proceso de actualización y de sus paquetes propios siguen el control de versiones semántico, esta versión 8 de Laravel continua cuenta con geniales características, para conocerlas mejor colocaré el nombre de la nueva característica, una descripción y el código, elemento o una imagen de referencia si es posible.

Laravel Jetstream

Este es un scaffolding que permite crear rápidamente en tu proyecto las funcionalidades de inicio de sesión, registro, verificación de correo o email, autenticación en 2 factores o 2 pasos, administrar sesiones, soporte de API a través de Laravel Sactum y de manera opcional el poder administrar el un equipo.

Laravel Jetstream reemplaza y mejora el scaffolding que tenia Laravel en versiones anteriores junto con la interface de usuario UI, la cual ha sido creada con Tailwind CSS, puedes optar por los scaffolding Livewire o Inertia.

Directorio para los Modelos

A petición de la comunidad ahora el esqueleto de un proyecto en Laravel incluye un directorio para los modelos, todos los comandos relevantes se han actualizado para asumir que existen modelos dentro del directorio, si es que existen. Si el directorio para los modelos no existe, Laravel asumirá que los modelos deben colocarse dentro del directorio app.


/miproyectolaravel
├── /app
    ├── /Console 
    ├── /Exceptions 
    ├── /Http  
    ├── /Models 
        ├── Productos.php 
        ├── User.php 
├── /Providers
├── /bootstrap
├── /config 
...
... 
...

/miproyectolaravel

├── /app

├── /Console

├── /Exceptions

├── /Http

├── /Models

├── Productos.php

├── User.php

├── /Providers

├── /bootstrap

├── /config

...

Model Factory Classes

Las model factories se han reescrito por completo como model factories basadas en clases y se han mejorado para tener un soporte de relación de primera clase, por ejemplo el UserFactory incluido en Laravel se escribe así:


<?php

namespace Database\Factories;

use App\Models\User;
use Illuminate\Database\Eloquent\Factories\Factory;
use Illuminate\Support\Str;

class UserFactory extends Factory
{
    /**
     * The name of the factory's corresponding model.
     *
     * @var string
     */
    protected $model = User::class;

    /**
     * Define the model's default state.
     *
     * @return array
     */
    public function definition()
    {
        return [
            'name' => $this->faker->name,
            'email' => $this->faker->unique()->safeEmail,
            'email_verified_at' => now(),
            'password' => '$2y$10$92IXUNpkjO0rOQ5byMi.Ye4oKoEa3Ro9llC/.og/at2.uheWG/igi', // password
            'remember_token' => Str::random(10),
        ];
    }
}

<?php

namespace Database\Factories;

use App\Models\User;

use Illuminate\Database\Eloquent\Factories\Factory;

use Illuminate\Support\Str;

class UserFactory extends Factory

{

/**

* The name of the factory's corresponding model.

* @var string

protected $model = User::class;

/**

* Define the model's default state.

* @return array

public function definition()

{

return [

'name' => $this->faker->name,

'email' => $this->faker->unique()->safeEmail,

'email_verified_at' => now(),

'password' => '$2y$10$92IXUNpkjO0rOQ5byMi.Ye4oKoEa3Ro9llC/.og/at2.uheWG/igi', // password

'remember_token' => Str::random(10),

];

}

Gracias al nuevo rasngo HasFactory disponible en los modelos generados, la model factories se puede usar de la siguiente manera.


use App\Models\User;

User::factory()->count(50)->create();

use App\Models\User;

User::factory()->count(50)->create();

Ya que las model factories son ahora clases PHP simples, las transformaciones de estado se pueden escribir como métodos de clase. Asimismo, puedes agregar cualquier otra clase de ayuda a tu model factories Eloquent según sea necesario.

Por ejemplo el model User puede tener un estado suspendido (suspendido) que modifique uno de sus valores de atributo predeterminados. Puedes definir sus transformaciones de estado utilizando el método state() de la factory’s base, puedes nombrar un método local como desees, después de todo, es solo un método PHP típico.


/**
 * Indicate that the user is suspended.
 *
 * @return \Illuminate\Database\Eloquent\Factories\Factory
 */
public function suspended()
{
    return $this->state([
        'account_status' => 'suspended',
    ]);
}

/**

* Indicate that the user is suspended.

* @return \Illuminate\Database\Eloquent\Factories\Factory

public function suspended()

{

return $this->state([

'account_status' => 'suspended',

]);

}

Luego de definir el método de transformación de estado, puedes usarlo de la siguiente manera:


use App\Models\User;

User::factory()->count(5)->suspended()->create();

use App\Models\User;

User::factory()->count(5)->suspended()->create();

Como te mencioné, las model factories de Laravel 8 contienen soporte de primera clase para las relaciones, entonces suponiendo que nuestro modelo User tiene un método de relación posts(), sencillamente podemos ejecutar el siguiente código para generar un usuario con tres publicaciones.


$users = User::factory()
            ->hasPosts(3, [
                'published' => false,
            ])
            ->create();

$users = User::factory()

->hasPosts(3, [

'published' => false,

])

->create();

Para hacer el proceso de actualización más sencillo, se ha lanzado el paquete laravel/legacy-factories que brinda soporte para la trabajar con model factories.

Las factories contienen más características y si quieres saber más puedes visitar el siguiente enlace.

Migration Squashing

Si traducimos al español el nombre de esta novedad significa Aplastamiento de migración, a medida que nuestra aplicación va creciendo, solemos acumular muchas migraciones con el tiempo, esto hace que el directorio de migraciones se llene de cientos de archivos de migraciones. Si utilizas MySQL o PostgreSQL, ahora podrás aplastar las migraciones en un solo archivo SQL, ejecutando el comando, adicionalmente te comparto un comando al que le he colocado un comentario explicando que es lo que hace.


# Aplanar las migraciones 
php artisan schema:dump 

# Volcar el esquema de la base de datos actual y eliminar todas las 
# migraciones existentes 
php artisan schema:dump --prune

# Aplanar las migraciones

php artisan schema:dump

# Volcar el esquema de la base de datos actual y eliminar todas las

# migraciones existentes

php artisan schema:dump --prune

Luego de ejecutar el primer comando anterior, Laravel 8 escribe un archivo schema en nuestro directorio database/schema y cuando intentes migrar tu base de datos y no se hayan ejecutado otras migraciones, Laravel ejecutará primero el SQL del archivo schema. Después de ejecutar los comandos del archivo de schema, Laravel ejecutará las migraciones restantes que no formaban parte del volcado de esquema

Trabajos (Jobs) por Lotes

Esta nueva característica te permite ejecutar fácilmente un lote de trabajos y luego realizar alguna acción cuando el lote de trabajos se haya completado. El nuevo método batch() de la facade Bus puede ser utilizado para enviar un lote de trabajos. Por supuesto, el procesamiento por lotes es principalmente útil cuando se combina con callbacks. Por ende es posible utilizar los métodos then, catch y finally para definir las callbacks para el lote.

Cada uno de estas callbacks, recibirá una instancia cuando se invoque Illuminate\Bus\Batch


use App\Jobs\ProcessPodcast;
use App\Podcast;
use Illuminate\Bus\Batch;
use Illuminate\Support\Facades\Batch;
use Throwable;

$batch = Bus::batch([
    new ProcessPodcast(Podcast::find(1)),
    new ProcessPodcast(Podcast::find(2)),
    new ProcessPodcast(Podcast::find(3)),
    new ProcessPodcast(Podcast::find(4)),
    new ProcessPodcast(Podcast::find(5)),
])->then(function (Batch $batch) {
    // Todos los trabajos se completaron correctamente... 
})->catch(function (Batch $batch, Throwable $e) {
    // Se detectó un error en el primer trabajo del lote...
})->finally(function (Batch $batch) {
    // El lote ha terminado de ejecutarse...
})->dispatch();

return $batch->id;

use App\Jobs\ProcessPodcast;

use App\Podcast;

use Illuminate\Bus\Batch;

use Illuminate\Support\Facades\Batch;

use Throwable;

$batch = Bus::batch([

new ProcessPodcast(Podcast::find(1)),

new ProcessPodcast(Podcast::find(2)),

new ProcessPodcast(Podcast::find(3)),

new ProcessPodcast(Podcast::find(4)),

new ProcessPodcast(Podcast::find(5)),

])->then(function (Batch $batch) {

// Todos los trabajos se completaron correctamente...

})->catch(function (Batch $batch, Throwable $e) {

// Se detectó un error en el primer trabajo del lote...

})->finally(function (Batch $batch) {

// El lote ha terminado de ejecutarse...

})->dispatch();

return $batch->id;

Si quieres saber más sobre los Trabajos (Jobs) por Lotes, puedes visitar el siguiente enlace.

Limitación de Velocidad Mejorada

La función de limitación de la tasa de solicitud ha sido mejorada en Laravel 8, cuenta con más flexibilidad y potencia, al tiempo que mantiene la compatibilidad con versiones anteriores de la API de middleware throttle. Los limitadores de velocidad se definen utilizando el método for() de la facade RaterLimiter, este método for() acepta un nombre de limitador de velocidad y un cierre que devuelve la configuración de límite que debe aplicarse a las rutas a las que se asigna este limitador de velocidad.


use Illuminate\Cache\RateLimiting\Limit;
use Illuminate\Support\Facades\RateLimiter;

RateLimiter::for('global', function (Request $request) {
    return Limit::perMinute(1000);
});

use Illuminate\Cache\RateLimiting\Limit;

use Illuminate\Support\Facades\RateLimiter;

RateLimiter::for('global', function (Request $request) {

return Limit::perMinute(1000);

});

Ya que las devoluciones de llamada del limitador de tasa reciben la instancia de solicitud HTTP entrante, puedes crear el límite de tasa apropiado de forma dinámica en función de la solicitud entrante o del usuario autenticado.


RateLimiter::for('uploads', function (Request $request) {
    return $request->user()->vipCustomer()
                ? Limit::none()
                : Limit::perMinute(100);
});

RateLimiter::for('uploads', function (Request $request) {

return $request->user()->vipCustomer()

? Limit::none()

: Limit::perMinute(100);

});

En algunas ocasiones puede que desees segmentar los límites de tasas por alguna valor arbitrario, por ejemplo es posible que desees permitir que los usuarios accedan a una ruta determinada 100 veces por minuto por dirección IP. Para hacer esto, puedes utilizar el método by() al construir tu limite de tasa.


RateLimiter::for('uploads', function (Request $request) {
    return $request->user()->vipCustomer()
                ? Limit::none()
                : Limit::perMinute(100)->by($request->ip());
});

RateLimiter::for('uploads', function (Request $request) {

return $request->user()->vipCustomer()

? Limit::none()

: Limit::perMinute(100)->by($request->ip());

});

Puedes adjuntar limitadores de velocidad a rutas o grupos de rutas mediante el middleware throttle, el middleware del acelerador acepta el nombre del limitador de velocidad que desees asignar a tu ruta.


Route::middleware(['throttle:uploads'])->group(function () {
    Route::post('/audio', function () {
        //
    });

    Route::post('/video', function () {
        //
    });
});

Route::middleware(['throttle:uploads'])->group(function () {

Route::post('/audio', function () {

});

Route::post('/video', function () {

});

Mejoras en el Maintenance Mode (Modo Mantenimiento)

El modo mantenimiento es un estado en el que tu proyecto web esta offline por temas de mantenimiento, puedes leer el siguiente tutorial que si bien es una versión anterior de Laravel, explica bien de que trata el modo mantenimiento.

Poner en Mantenimiento mi Aplicación en Laravel 5

En versiones anteriores de Laravel, la funcionalidad del comando php artisan down se puede omitir utilizando una lista permitida de direcciones IP a las que se les permitió acceder a la aplicación. Esta característica se ha eliminado en favor de una solución de token secreto.

Mientras tu proyecto está en modo mantenimiento, puedes usar la opción secret para especificar un token de omision del modo mantenimiento.


# Omitir token en Modo Mantenimiento 
php artisan down --secret="1630542a-246b-4b66-afa1-dd72a4c43515"

# Omitir token en Modo Mantenimiento

php artisan down --secret="1630542a-246b-4b66-afa1-dd72a4c43515"

Luego de colocar la aplicación en modo mantenimiento, puedes navegar a la URL de la aplicación que coincide con este token y Laravel emitirá una cookie de omisión del modo mantenimiento a tu navegador.


# Cookie de omisión en el navegador 
https://example.com/1630542a-246b-4b66-afa1-dd72a4c43515

# Cookie de omisión en el navegador

https://example.com/1630542a-246b-4b66-afa1-dd72a4c43515

Si intentas acceder a esa ruta oculta, serás redirigido a la ruta de tu proyecto, una vez la cookie haya sido enviada al navegador, podrás navegar por tu proyecto normalmente como si no estuvieras en modo mantenimiento.

Renderizado previo de la vista del Modo Mantenimiento

Si utilizas el comando php artisan down, tus usuarios aún pueden encontrar errores ocasionalmente si acceden a tu proyecto mientras se actualizan las dependencias de Composer u otros componentes de la infraestructura. Esto suele ocurrir porque una parte importante de Laravel para determinar que tu aplicación está en modo mantenimiento y cargar la vista del modo de mantenimiento utilizando el motor de plantillas.

Por esta razón ahora Laravel te permite pre-renderizar una vista en modo mantenimiento que se devolverá al comienzo del ciclo de solicitud. Esta vista se representa antes de que se haya cargado cualquiera de las dependencias de tu aplicación. Puedes pre-renderizar una plantilla de tu elección usando la opción down en el comando render.


# Comando para pre-renderizar una plantilla según el código HTTP (503) 
php artisan down --render="errors::503"

# Comando para pre-renderizar una plantilla según el código HTTP (503)

php artisan down --render="errors::503"

Closure Dispatch/Chain ‘chain’

Mediante el nuevo método catch(), ahora puedes proporcionar un cierre que debe ejecutarse si un cierre en cola no se completa correctamente después de agotar todos los reintentos configurados en tu cola.


use Throwable;

dispatch(function () use ($podcast) {
    $podcast->publish();
})->catch(function (Throwable $e) {
    // Esta tarea ha fallado...
});

use Throwable;

dispatch(function () use ($podcast) {

$podcast->publish();

})->catch(function (Throwable $e) {

// Esta tarea ha fallado...

});

Componentes dinámicos Blade

En ocasiones es posible que necesites renderizar un componente sin saber que componente debe renderizarse hasta el tiempo de ejecución, en este caso, ahora puedes usar el componente dynamic-component incorporado de Laravel para renderizar el componente según un valor de tiempo de ejecución o variable:


// Componente dinámico Blade 
<x-dynamic-component :component="$componentName" class="mt-4" />

// Componente dinámico Blade

<x-dynamic-component :component="$componentName" class="mt-4" />

Si quieres saber más sobre los componentes dinámicos blade, puedes visitar el siguiente enlace.

Mejoras en los Event Listeners (Oyentes de Eventos)

Los Event Listeners (Oyentes de Eventos) basados en Closure, ahora pueden registrarse solo pasando el Closure al método Event::listen, Laravel inspecciona el Closure para determinar que tipo de evento maneja el oyente


use App\Events\PodcastProcessed;
use Illuminate\Support\Facades\Event;

Event::listen(function (PodcastProcessed $event) {
    //
});

use App\Events\PodcastProcessed;

use Illuminate\Support\Facades\Event;

Event::listen(function (PodcastProcessed $event) {

});

Asimismo los Event Listeners basados en Closure ahora pueden marcarse como en cola, usando la función Illuminate\Events\queueable


use App\Events\PodcastProcessed;
use function Illuminate\Events\queueable;
use Illuminate\Support\Facades\Event;

Event::listen(queueable(function (PodcastProcessed $event) {
    //
}));

use App\Events\PodcastProcessed;

use function Illuminate\Events\queueable;

use Illuminate\Support\Facades\Event;

Event::listen(queueable(function (PodcastProcessed $event) {

}));

Al igual que los Queued Jobs (Trabajos en cola), puedes utilizar los métodos onConnection(), onQueue() y delay() para personalizar la ejecución del oyente en cola.


Event::listen(queueable(function (PodcastProcessed $event) {
    //
})->onConnection('redis')->onQueue('podcasts')->delay(now()->addSeconds(10)));

Event::listen(queueable(function (PodcastProcessed $event) {

})->onConnection('redis')->onQueue('podcasts')->delay(now()->addSeconds(10)));

Si deseas manejar fallas anónimas del Listener en cola, puedes proporcionar un cierre al método catch() mientras defines el Listener queueable.


use App\Events\PodcastProcessed;
use function Illuminate\Events\queueable;
use Illuminate\Support\Facades\Event;
use Throwable;

Event::listen(queueable(function (PodcastProcessed $event) {
    //
})->catch(function (PodcastProcessed $event, Throwable $e) {
    // The queued listener failed...
}));

use App\Events\PodcastProcessed;

use function Illuminate\Events\queueable;

use Illuminate\Support\Facades\Event;

use Throwable;

Event::listen(queueable(function (PodcastProcessed $event) {

})->catch(function (PodcastProcessed $event, Throwable $e) {

// The queued listener failed...

}));

Time Testing Helpers

Cuando realizas pruebas en Laravel, es posible que ocasionalmente debas modificar el tiempo obtenido con el método now() o con Illuminate\Support\Carbon::now(), Laravel ahora incluye Helpers que te permiten manipular la hora actual.


public function testTimeCanBeManipulated()
{
    // Travel into the future...
    $this->travel(5)->milliseconds();
    $this->travel(5)->seconds();
    $this->travel(5)->minutes();
    $this->travel(5)->hours();
    $this->travel(5)->days();
    $this->travel(5)->weeks();
    $this->travel(5)->years();

    // Travel into the past...
    $this->travel(-5)->hours();

    // Travel to an explicit time...
    $this->travelTo(now()->subHours(6));

    // Return back to the present time...
    $this->travelBack();
}

public function testTimeCanBeManipulated()

{

// Travel into the future...

$this->travel(5)->milliseconds();

$this->travel(5)->seconds();

$this->travel(5)->minutes();

$this->travel(5)->hours();

$this->travel(5)->days();

$this->travel(5)->weeks();

$this->travel(5)->years();

// Travel into the past...

$this->travel(-5)->hours();

// Travel to an explicit time...

$this->travelTo(now()->subHours(6));

// Return back to the present time...

$this->travelBack();

}

Mejoras en “artisan serve”

El comando Artisan serve ha sido mejorado con la recarga automática cuando se detectan cambios en las variables de entorno dentro del archivo local .env, en versiones anteriores, el comando Artisan serve tenía que detenerse y reiniciarse manualmente.

Paginación con Tailwind CSS

La paginación en una vista blade de Laravel ahora utiliza Tailwind CSS de forma predeterminada, Tailwind CSS es un framework CSS de bajo nivel netamente personalizable que te brinda todos los bloques de construcción que necesitas para crear diseños a medida sin los molestos estilos obstinados por los que debes batallar para anularlos.

Porsupuesto las vistas con Bootstrap 3 y 4 también permanecen disponibles.

Actualizaciones en los Routings Namespace

En versiones anteriores de Laravel, RouteServiceProvider contenía una propiedad $namespace , el valor de esta propiedad se agregaría automáticamente como prefijo en las definiciones de ruta del controlador y las llamadas al helper action() / método URL::action. En Laravel 8 esta propiedad es predeterminada, esto significa que Laravel no realizará ningún prefijo automático del namespace. Por ende, en las nuevas aplicaciones de Laravel 8, las definiciones de ruta del controlador debe definirse usando la sintaxis estándar de PHP invocable:


use App\Http\Controllers\UserController;

Route::get('/users', [UserController::class, 'index']);

use App\Http\Controllers\UserController;

Route::get('/users', [UserController::class, 'index']);

Si deseas usar el prefijo de ruta del controlador de estilo de Laravel 7, simplemente puedes agregar la propiedad $namespace en el archivo RouteServiceProvider de tu proyecto.

Bien eso es todo, hasta la fecha de este artículo, estas son las Novedades que trae Laravel 8, con el paso de las Meses iremos viendo nuevas novedades sobre este Framework.

Nota(s)

Algunas Novedades pueden cambiar, modificarse o ser eliminadas en un futuro, esto no depende de nosotros, si no de los Desarrolladores que dan soporte a Laravel, que suelen cambiar las funcionalidades de Laravel en futuras versiones.
No olvides que debemos usar la Tecnología para hacer cosas Buenas por el Mundo.

Síguenos en nuestras Redes Sociales para que no te pierdas nuestros próximos contenidos