Flight es un framework rápido, simple y ampliable para PHP. Es bastante versátil y se puede utilizar para construir cualquier tipo de aplicación web. Está construido con la simplicidad en mente y está escrito de una manera que es fácil de entender y usar.
Aquí tienes un breve artículo sobre por qué deberías usar un framework. Es una buena idea entender los beneficios de usar un framework antes de empezar a utilizar uno.
Además, se ha creado un excelente tutorial por @lubiana. Si bien no entra en gran detalle sobre Flight específicamente, esta guía te ayudará a entender algunos de los principales conceptos en torno a un framework y por qué son beneficiosos de usar. Puedes encontrar el tutorial aquí.
Aprende cómo autocomentar tus propias clases en tu aplicación.
Aprende cómo gestionar rutas para tu aplicación web. Esto también incluye agrupar rutas, parámetros de ruta e intermediarios.
Aprende cómo usar intermediarios para filtrar las solicitudes y respuestas en tu aplicación.
Aprende cómo manejar solicitudes y respuestas en tu aplicación.
Aprende cómo enviar respuestas a tus usuarios.
Aprende cómo utilizar el motor de vista incorporado para renderizar tus plantillas HTML.
Aprende cómo asegurar tu aplicación de amenazas de seguridad comunes.
Aprende cómo configurar el framework para tu aplicación.
Aprende cómo extender el framework agregando tus propios métodos y clases.
Aprende cómo utilizar el sistema de eventos para agregar ganchos a tus métodos y métodos internos del framework.
Aprende cómo utilizar contenedores de inyección de dependencias (DIC) para administrar las dependencias de tu aplicación.
Aprende sobre los métodos principales del framework.
La compatibilidad con versiones anteriores se ha mantenido en su mayor parte, pero hay algunos cambios de los que debes ser consciente al migrar de la v2 a la v3.
Existen algunos problemas comunes con los que te puedes encontrar al usar Flight. Esta página te ayudará a solucionar esos problemas.
Puedes detener el marco de trabajo en cualquier momento llamando al método halt:
halt
Flight::halt();
También puedes especificar un código de estado HTTP opcional y un mensaje:
HTTP
Flight::halt(200, 'Vuelvo enseguida...');
Llamar a halt descartará cualquier contenido de respuesta hasta ese punto. Si deseas detener el marco de trabajo y generar la respuesta actual, utiliza el método stop:
stop
Flight::stop();
Todos los errores y excepciones son capturados por Flight y pasados al método error. El comportamiento predeterminado es enviar una respuesta genérica de HTTP 500 Internal Server Error con información sobre el error.
error
HTTP 500 Internal Server Error
Puede anular este comportamiento según sus necesidades:
Flight::map('error', function (Throwable $error) { // Manejar error echo $error->getTraceAsString(); });
Por defecto, los errores no se registran en el servidor web. Puede habilitar esto cambiando la configuración:
Flight::set('flight.log_errors', true);
Cuando una URL no se puede encontrar, Flight llama al método notFound. El comportamiento predeterminado es enviar una respuesta de HTTP 404 Not Found con un mensaje simple.
notFound
HTTP 404 Not Found
Flight::map('notFound', function () { // Manejar no encontrado });
La compatibilidad con versiones anteriores se ha mantenido en su mayor parte, pero hay algunos cambios de los que debes ser consciente al migrar de v2 a v3.
El almacenamiento en búfer de salida es el proceso en el cual la salida generada por un script de PHP se almacena en un búfer (interno de PHP) antes de ser enviada al cliente. Esto te permite modificar la salida antes de ser enviada al cliente.
En una aplicación MVC, el Controlador es el "gestor" y se encarga de lo que hace la vista. Tener la salida generada fuera del controlador (o en el caso de Flight a veces en una función anónima) rompe el patrón MVC. Este cambio es para estar más en línea con el patrón MVC y hacer que el framework sea más predecible y fácil de usar.
En v2, el almacenamiento en búfer de salida se manejaba de una manera en la que no cerraba de manera consistente su propio búfer de salida y eso hacía que las pruebas unitarias y el streaming fuesen más difíciles. Para la mayoría de los usuarios, este cambio puede que en realidad no te afecte. Sin embargo, si estás imprimiendo contenido fuera de las funciones llamables y controladores (por ejemplo en un gancho), es probable que tengas problemas. Imprimir contenido en ganchos, y antes de que el framework se ejecute realmente pudo haber funcionado en el pasado, pero no funcionará en adelante.
// index.php require 'vendor/autoload.php'; // solo un ejemplo define('TIEMPO_INICIO', microtime(true)); function hola() { echo 'Hola Mundo'; } Flight::map('hola', 'hola'); Flight::after('hola', function(){ // esto en realidad estará bien echo '<p>Esta frase de Hola Mundo te la trae la letra "H"</p>'; }); Flight::before('inicio', function(){ // cosas como estas causarán un error echo '<html><head><title>Mi Página</title></head><body>'; }); Flight::route('/', function(){ // esto en realidad está bien echo 'Hola Mundo'; // Esto también debería estar bien Flight::hola(); }); Flight::after('inicio', function(){ // esto causará un error echo '<div>Tu página cargó en '.(microtime(true) - TIEMPO_INICIO).' segundos</div></body></html>'; });
¿Todavía puedes mantener tu código antiguo tal como está sin necesidad de reescribirlo para que funcione con v3? ¡Sí, puedes! Puedes activar el comportamiento de renderización de v2 configurando la opción de configuración flight.v2.output_buffering en true. Esto te permitirá seguir utilizando el antiguo comportamiento de renderización, pero se recomienda corregirlo de cara al futuro. En la v4 del framework, esto será eliminado.
flight.v2.output_buffering
true
// index.php require 'vendor/autoload.php'; Flight::set('flight.v2.output_buffering', true); Flight::before('inicio', function(){ // Ahora esto estará bien echo '<html><head><title>Mi Página</title></head><body>'; }); // más código
Si has estado llamando directamente a métodos estáticos para Dispatcher como Dispatcher::invokeMethod(), Dispatcher::execute(), etc., necesitarás actualizar tu código para no llamar directamente a estos métodos. Dispatcher ha sido convertido para ser más orientado a objetos de manera que los Contenedores de Inyección de Dependencias puedan ser utilizados de una manera más sencilla. Si necesitas invocar un método de manera similar a como lo hacía Dispatcher, puedes usar manualmente algo como $resultado = $clase->$metodo(...$params); o call_user_func_array() en su lugar.
Dispatcher
Dispatcher::invokeMethod()
Dispatcher::execute()
$resultado = $clase->$metodo(...$params);
call_user_func_array()
Puedes personalizar ciertos comportamientos de Flight configurando los valores de configuración a través del método set.
set
La siguiente es una lista de todas las configuraciones disponibles:
?string
bool
string
Content-Length
Flight te permite guardar variables para que puedan ser utilizadas en cualquier parte de tu aplicación.
// Guarda tu variable Flight::set('id', 123); // En otra parte de tu aplicación $id = Flight::get('id');
Para verificar si una variable ha sido establecida, puedes hacer:
if (Flight::has('id')) { // Haz algo }
Puedes limpiar una variable haciendo:
// Limpia la variable id Flight::clear('id'); // Limpia todas las variables Flight::clear();
Flight también utiliza variables con fines de configuración.
Todos los errores y excepciones son capturados por Flight y pasados al método error. El comportamiento predeterminado es enviar una respuesta genérica de HTTP 500 Internal Server Error con algo de información sobre el error.
Puedes anular este comportamiento para tus propias necesidades:
De forma predeterminada, los errores no se registran en el servidor web. Puedes habilitar esto cambiando la configuración:
Cuando no se puede encontrar una URL, Flight llama al método notFound. El comportamiento predeterminado es enviar una respuesta de HTTP 404 Not Found con un mensaje simple.
La seguridad es fundamental cuando se trata de aplicaciones web. Deseas asegurarte de que tu aplicación sea segura y de que los datos de tus usuarios estén protegidos. Flight proporciona una serie de funciones para ayudarte a asegurar tus aplicaciones web.
Los encabezados HTTP son una de las formas más sencillas de asegurar tus aplicaciones web. Puedes usar encabezados para prevenir el secuestro de clics, XSS y otros ataques. Hay varias formas de agregar estos encabezados a tu aplicación.
Dos excelentes sitios web para verificar la seguridad de tus encabezados son securityheaders.com y observatory.mozilla.org.
Puedes agregar manualmente estos encabezados utilizando el método header en el objeto Flight\Response.
header
Flight\Response
// Establecer el encabezado X-Frame-Options para prevenir el secuestro de clics Flight::response()->header('X-Frame-Options', 'SAMEORIGIN'); // Establecer el encabezado Content-Security-Policy para prevenir XSS // Nota: este encabezado puede volverse muy complejo, así que es mejor // consultar ejemplos en Internet para tu aplicación Flight::response()->header("Content-Security-Policy", "default-src 'self'"); // Establecer el encabezado X-XSS-Protection para prevenir XSS Flight::response()->header('X-XSS-Protection', '1; mode=block'); // Establecer el encabezado X-Content-Type-Options para prevenir el sniffing MIME Flight::response()->header('X-Content-Type-Options', 'nosniff'); // Establecer el encabezado Referrer-Policy para controlar cuánta información del referente se envía Flight::response()->header('Referrer-Policy', 'no-referrer-when-downgrade'); // Establecer el encabezado Strict-Transport-Security para forzar el HTTPS Flight::response()->header('Strict-Transport-Security', 'max-age=31536000; includeSubDomains; preload'); // Establecer el encabezado Permissions-Policy para controlar qué funciones y APIs se pueden utilizar Flight::response()->header('Permissions-Policy', 'geolocation=()');
Estos pueden ser agregados al principio de tus archivos bootstrap.php o index.php.
bootstrap.php
index.php
También puedes agregarlos en un filtro/gancho como el siguiente:
// Agregar los encabezados en un filtro Flight::before('start', function() { Flight::response()->header('X-Frame-Options', 'SAMEORIGIN'); Flight::response()->header("Content-Security-Policy", "default-src 'self'"); Flight::response()->header('X-XSS-Protection', '1; mode=block'); Flight::response()->header('X-Content-Type-Options', 'nosniff'); Flight::response()->header('Referrer-Policy', 'no-referrer-when-downgrade'); Flight::response()->header('Strict-Transport-Security', 'max-age=31536000; includeSubDomains; preload'); Flight::response()->header('Permissions-Policy', 'geolocation=()'); });
También puedes añadirlos como una clase de middleware. Esta es una buena manera de mantener limpio y organizado tu código.
// app/middleware/SecurityHeadersMiddleware.php namespace app\middleware; class SecurityHeadersMiddleware { public function before(array $params): void { Flight::response()->header('X-Frame-Options', 'SAMEORIGIN'); Flight::response()->header("Content-Security-Policy", "default-src 'self'"); Flight::response()->header('X-XSS-Protection', '1; mode=block'); Flight::response()->header('X-Content-Type-Options', 'nosniff'); Flight::response()->header('Referrer-Policy', 'no-referrer-when-downgrade'); Flight::response()->header('Strict-Transport-Security', 'max-age=31536000; includeSubDomains; preload'); Flight::response()->header('Permissions-Policy', 'geolocation=()'); } } // index.php o donde tengas tus rutas // FYI, este grupo de cadena vacía actúa como un middleware global para // todas las rutas. Por supuesto, podrías hacer lo mismo y añadir esto solo a rutas específicas. Flight::group('', function(Router $router) { $router->get('/users', [ 'UserController', 'getUsers' ]); // más rutas }, [ new SecurityHeadersMiddleware() ]);
La falsificación de solicitudes entre sitios (CSRF) es un tipo de ataque en el que un sitio web malicioso puede hacer que el navegador de un usuario envíe una solicitud a tu sitio web. Esto se puede utilizar para realizar acciones en tu sitio web sin el conocimiento del usuario. Flight no proporciona un mecanismo de protección CSRF incorporado, pero puedes implementar fácilmente el tuyo propio utilizando middleware.
Primero necesitas generar un token CSRF y almacenarlo en la sesión del usuario. Luego puedes usar este token en tus formularios y verificarlo cuando se envía el formulario.
// Generar un token CSRF y almacenarlo en la sesión del usuario // (asumiendo que has creado un objeto de sesión y lo has adjuntado a Flight) // Solo necesitas generar un token por sesión (para que funcione // en varias pestañas y solicitudes para el mismo usuario) if(Flight::session()->get('csrf_token') === null) { Flight::session()->set('csrf_token', bin2hex(random_bytes(32)) ); }
<!-- Utiliza el token CSRF en tu formulario --> <form method="post"> <input type="hidden" name="csrf_token" value="<?= Flight::session()->get('csrf_token') ?>"> <!-- otros campos del formulario --> </form>
También puedes establecer una función personalizada para mostrar el token CSRF en tus plantillas de Latte.
// Establecer una función personalizada para mostrar el token CSRF // Nota: La Vista ha sido configurada con Latte como el motor de vista Flight::view()->addFunction('csrf', function() { $csrfToken = Flight::session()->get('csrf_token'); return new \Latte\Runtime\Html('<input type="hidden" name="csrf_token" value="' . $csrfToken . '">'); });
Y ahora en tus plantillas de Latte puedes usar la función csrf() para mostrar el token CSRF.
csrf()
<form method="post"> {csrf()} <!-- otros campos del formulario --> </form>
¡Corto y simple, ¿verdad?
Puedes verificar el token CSRF usando filtros de eventos:
// Este middleware verifica si la solicitud es una solicitud POST y si lo es, verifica si el token CSRF es válido Flight::before('start', function() { if(Flight::request()->method == 'POST') { // captura el token csrf de los valores del formulario $token = Flight::request()->data->csrf_token; if($token !== Flight::session()->get('csrf_token')) { Flight::halt(403, 'Token CSRF inválido'); } } });
O puedes usar una clase de middleware:
// app/middleware/CsrfMiddleware.php namespace app\middleware; class CsrfMiddleware { public function before(array $params): void { if(Flight::request()->method == 'POST') { $token = Flight::request()->data->csrf_token; if($token !== Flight::session()->get('csrf_token')) { Flight::halt(403, 'Token CSRF inválido'); } } } } // index.php o donde tengas tus rutas Flight::group('', function(Router $router) { $router->get('/users', [ 'UserController', 'getUsers' ]); // más rutas }, [ new CsrfMiddleware() ]);
Cross Site Scripting (XSS) es un tipo de ataque en el que un sitio web malicioso puede inyectar código en tu sitio web. La mayoría de estas oportunidades provienen de los valores de los formularios que completarán tus usuarios. ¡Nunca debes confiar en la salida de tus usuarios! Siempre asume que todos son los mejores hackers del mundo. Pueden inyectar JavaScript o HTML malicioso en tu página. Este código puede usarse para robar información de tus usuarios o realizar acciones en tu sitio web. Utilizando la clase de vista de Flight, puedes escapar fácilmente la salida para prevenir ataques XSS.
// Supongamos que el usuario es astuto y trata de usar esto como su nombre $nombre = '<script>alert("XSS")</script>'; // Esto escapará la salida Flight::view()->set('nombre', $nombre); // Esto producirá: <script>alert("XSS")</script> // Si utilizas algo como Latte registrado como tu clase de vista, esto también se escapará automáticamente. Flight::view()->render('plantilla', ['nombre' => $nombre]);
La inyección SQL es un tipo de ataque en el que un usuario malintencionado puede insertar código SQL en tu base de datos. Esto se puede usar para robar información de tu base de datos o ejecutar acciones en tu base de datos. Nuevamente, ¡nunca debes confiar en la entrada de tus usuarios! Siempre asume que van a por todas. Puedes utilizar declaraciones preparadas en tus objetos PDO para prevenir la inyección SQL.
PDO
// Suponiendo que tienes Flight::db() registrado como tu objeto PDO $declaracion = Flight::db()->prepare('SELECT * FROM users WHERE username = :username'); $declaracion->execute([':username' => $username]); $usuarios = $declaracion->fetchAll(); // Si utilizas la clase PdoWrapper, esto se puede hacer fácilmente en una línea $usuarios = Flight::db()->fetchAll('SELECT * FROM users WHERE username = :username', [ 'username' => $username ]); // Puedes hacer lo mismo con un objeto PDO con marcadores de posición ? $declaracion = Flight::db()->fetchAll('SELECT * FROM users WHERE username = ?', [ $username ]); // Solo promete que nunca, NUNCA harás algo como esto... $usuarios = Flight::db()->fetchAll("SELECT * FROM users WHERE username = '{$username}' LIMIT 5"); // porque ¿qué pasa si $username = "' OR 1=1; -- "; // Después de que se construye la consulta, parece esto // SELECT * FROM users WHERE username = '' OR 1=1; -- LIMIT 5 // Parece extraño, pero es una consulta válida que funcionará. De hecho, // es un ataque común de inyección SQL que devolverá todos los usuarios.
Cross-Origin Resource Sharing (CORS) es un mecanismo que permite solicitar muchos recursos (por ejemplo, fuentes, JavaScript, etc.) en una página web desde otro dominio fuera del dominio del que se originó el recurso. Flight no tiene funcionalidad incorporada, pero esto se puede manejar fácilmente con un gancho que se ejecuta antes de que se llame al método Flight::start().
Flight::start()
// app/utils/CorsUtil.php namespace app\utils; class CorsUtil { public function set(array $params): void { $solicitud = Flight::request(); $respuesta = Flight::response(); if ($solicitud->getVar('HTTP_ORIGIN') !== '') { $this->permitirOrígenes(); $respuesta->header('Access-Control-Allow-Credentials', 'true'); $respuesta->header('Access-Control-Max-Age', '86400'); } if ($solicitud->method === 'OPTIONS') { if ($solicitud->getVar('HTTP_ACCESS_CONTROL_REQUEST_METHOD') !== '') { $respuesta->header( 'Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, PATCH, OPTIONS, HEAD' ); } if ($solicitud->getVar('HTTP_ACCESS_CONTROL_REQUEST_HEADERS') !== '') { $respuesta->header( "Access-Control-Allow-Headers", $solicitud->getVar('HTTP_ACCESS_CONTROL_REQUEST_HEADERS') ); } $respuesta->status(200); $respuesta->send(); exit; } } private function permitirOrígenes(): void { // personaliza tus hosts permitidos aquí. $permitidos = [ 'capacitor://localhost', 'ionic://localhost', 'http://localhost', 'http://localhost:4200', 'http://localhost:8080', 'http://localhost:8100', ]; $solicitud = Flight::request(); if (in_array($solicitud->getVar('HTTP_ORIGIN'), $permitidos, true) === true) { $respuesta = Flight::response(); $respuesta->header("Access-Control-Allow-Origin", $solicitud->getVar('HTTP_ORIGIN')); } } } // index.php o donde tengas tus rutas $CorsUtil = new CorsUtil(); Flight::before('start', [ $CorsUtil, 'setupCors' ]);
La seguridad es fundamental y es importante asegurarte de que tus aplicaciones web sean seguras. Flight proporciona una serie de funciones para ayudarte a asegurar tus aplicaciones web, pero es importante estar siempre alerta y asegurarte de que estás haciendo todo lo posible para mantener seguros los datos de tus usuarios. Siempre asume lo peor y nunca confíes en la entrada de tus usuarios. Siempre escapa la salida y utiliza declaraciones preparadas para prevenir la inyección SQL. Siempre utiliza middleware para proteger tus rutas de ataques CSRF y CORS. Si haces todas estas cosas, estarás en buen camino para construir aplicaciones web seguras.
Flight te permite anular su funcionalidad predeterminada para adaptarla a tus propias necesidades, sin necesidad de modificar ningún código.
Por ejemplo, cuando Flight no puede encontrar una URL que coincida con una ruta, invoca el método notFound que envía una respuesta genérica de HTTP 404. Puedes anular este comportamiento utilizando el método map:
HTTP 404
map
Flight::map('notFound', function() { // Mostrar página de error 404 personalizada include 'errors/404.html'; });
Flight también te permite reemplazar componentes principales del framework. Por ejemplo, puedes reemplazar la clase Router predeterminada con tu propia clase personalizada:
// Registra tu clase personalizada Flight::register('router', MyRouter::class); // Cuando Flight carga la instancia del enrutador, cargará tu clase $myrouter = Flight::router();
Sin embargo, los métodos del framework como map y register no se pueden anular. Obtendrás un error si intentas hacerlo.
register
# Enrutamiento > **Nota:** ¿Quieres entender más sobre el enrutamiento? Consulta la página ["¿por qué un framework?"](/learn/why-frameworks) para obtener una explicación más detallada. El enrutamiento básico en Flight se realiza mediante la coincidencia de un patrón de URL con una función de devolución de llamada o un conjunto de una clase y un método. ```php Flight::route('/', function(){ echo '¡Hola Mundo!'; });
Las rutas se comparan en el orden en que se definen. La primera ruta que coincida con una solicitud será invocada.
La devolución de llamada puede ser cualquier objeto que sea invocable. Así que puedes usar una función regular:
function hola(){ echo '¡Hola Mundo!'; } Flight::route('/', 'hola');
También puedes usar un método estático de una clase:
class Saludo { public static function hola() { echo '¡Hola Mundo!'; } } Flight::route('/', [ 'Saludo','hola' ]);
O creando un objeto primero y luego llamando al método:
// Saludo.php class Saludo { public function __construct() { $this->nombre = 'John Doe'; } public function hola() { echo "¡Hola, {$this->nombre}!"; } } // index.php $saludo = new Saludo(); Flight::route('/', [ $saludo, 'hola' ]); // También puedes hacerlo sin crear el objeto primero // Nota: No se inyectarán argumentos en el constructor Flight::route('/', [ 'Saludo', 'hola' ]);
Si deseas utilizar la inyección de dependencias a través de un contenedor (PSR-11, PHP-DI, Dice, etc), el único tipo de rutas donde está disponible es creando el objeto directamente tú mismo y usando el contenedor para crear tu objeto o puedes usar cadenas para definir la clase y el método a llamar. Puedes ir a la página Inyección de Dependencias para obtener más información.
Aquí tienes un ejemplo rápido:
use flight\database\PdoWrapper; // Saludo.php class Saludo { protected PdoWrapper $pdoWrapper; public function __construct(PdoWrapper $pdoWrapper) { $this->pdoWrapper = $pdoWrapper; } public function hello(int $id) { // hacer algo con $this->pdoWrapper $nombre = $this->pdoWrapper->fetchField("SELECT nombre FROM usuarios WHERE id = ?", [ $id ]); echo "¡Hola, mundo! Mi nombre es {$nombre}!"; } } // index.php // Configura el contenedor con los parámetros que necesites // Consulta la página de Inyección de Dependencias para obtener más información sobre PSR-11 $dice = new \Dice\Dice(); // ¡No olvides reasignar la variable con '$dice = '!!!!! $dice = $dice->addRule('flight\database\PdoWrapper', [ 'shared' => true, 'constructParams' => [ 'mysql:host=localhost;dbname=test', 'root', 'password' ] ]); // Registra el manejador de contenedores Flight::registerContainerHandler(function($class, $params) use ($dice) { return $dice->create($class, $params); }); // Rutas como de costumbre Flight::route('/hola/@id', [ 'Saludo', 'hola' ]); // o Flight::route('/hola/@id', 'Saludo->hola'); // o Flight::route('/hola/@id', 'Saludo::hola'); Flight::start();
Por defecto, los patrones de ruta se comparan con todos los métodos de solicitud. Puedes responder a métodos específicos colocando un identificador antes de la URL.
Flight::route('GET /', function () { echo 'He recibido una solicitud GET.'; }); Flight::route('POST /', function () { echo 'He recibido una solicitud POST.'; }); // No puedes usar Flight::get() para rutas ya que es un método // para obtener variables, no crear una ruta. // Flight::post('/', function() { /* código */ }); // Flight::patch('/', function() { /* código */ }); // Flight::put('/', function() { /* código */ }); // Flight::delete('/', function() { /* código */ });
También puedes asignar múltiples métodos a una sola devolución de llamada mediante el uso de un delimitador |:
|
Flight::route('GET|POST /', function () { echo 'He recibido una solicitud GET o POST.'; });
Además, puedes obtener el objeto Router que tiene algunos métodos auxiliares para que los uses:
$router = Flight::router(); // mapea todos los métodos $router->map('/', function() { echo '¡Hola Mundo!'; }); // solicitud GET $router->get('/usuarios', function() { echo 'usuarios'; }); // $router->post(); // $router->put(); // $router->delete(); // $router->patch();
Puedes usar expresiones regulares en tus rutas:
Flight::route('/usuario/[0-9]+', function () { // Esto coincidirá con /usuario/1234 });
Aunque este método está disponible, se recomienda usar parámetros nombrados o parámetros nombrados con expresiones regulares, ya que son más legibles y fáciles de mantener.
Puedes especificar parámetros nombrados en tus rutas que se pasarán a tu función de devolución de llamada.
Flight::route('/@nombre/@id', function (string $nombre, string $id) { echo "¡hola, $nombre ($id)!"; });
También puedes incluir expresiones regulares con tus parámetros nombrados mediante el uso del delimitador ::
:
Flight::route('/@nombre/@id:[0-9]{3}', function (string $nombre, string $id) { // Esto coincidirá con /bob/123 // Pero no coincidirá con /bob/12345 });
Nota: No se admite la coincidencia de grupos de regex () con parámetros nombrados. :'(
()
Puedes especificar parámetros nombrados que son opcionales para que coincidan al envolver segmentos en paréntesis.
Flight::route( '/blog(/@year(/@month(/@day)))', function(?string $year, ?string $month, ?string $day) { // Esto coincidirá con las siguientes URLS: // /blog/2012/12/10 // /blog/2012/12 // /blog/2012 // /blog } );
Cualquier parámetro opcional que no coincida se pasará como NULL.
NULL
La coincidencia se hace solo en segmentos individuales de URL. Si deseas hacer coincidir múltiples segmentos puedes usar el comodín *.
*
Flight::route('/blog/*', function () { // Esto coincidirá con /blog/2000/02/01 });
Para dirigir todas las solicitudes a una única devolución de llamada, puedes hacer:
Flight::route('*', function () { // Haz algo });
Puedes pasar la ejecución a la siguiente ruta coincidente devolviendo true desde tu función de devolución de llamada.
Flight::route('/usuario/@nombre', function (string $nombre) { // Verifica alguna condición if ($nombre !== "Bob") { // Continuar a la siguiente ruta return true; } }); Flight::route('/usuario/*', function () { // Esto se llamará });
Puedes asignar un alias a una ruta, de modo que la URL pueda generarse dinámicamente más tarde en tu código (como una plantilla, por ejemplo).
Flight::route('/usuarios/@id', function($id) { echo 'usuario:'.$id; }, false, 'vista_usuario'); // más tarde en algún lugar del código Flight::getUrl('vista_usuario', [ 'id' => 5 ]); // devolverá '/usuarios/5'
Esto es especialmente útil si tu URL cambia. En el ejemplo anterior, digamos que los usuarios se movieron a /admin/usuarios/@id en lugar de eso. Con el alias en su lugar, no tienes que cambiar en ninguna parte que haga referencia al alias porque el alias ahora devolverá /admin/usuarios/5 como en el ejemplo anterior.
/admin/usuarios/@id
/admin/usuarios/5
El alias de ruta todavía funciona en grupos también:
Flight::group('/usuarios', function() { Flight::route('/@id', function($id) { echo 'usuario:'.$id; }, false, 'vista_usuario'); }); // más tarde en algún lugar del código Flight::getUrl('vista_usuario', [ 'id' => 5 ]); // devolverá '/usuarios/5'
Si deseas inspeccionar la información de ruta coincidente, puedes solicitar que se pase el objeto de ruta a tu devolución de llamada pasando true como el tercer parámetro en el método de ruta. El objeto de ruta siempre será el último parámetro pasado a la función de devolución de llamada.
Flight::route('/', function(\flight\net\Route $ruta) { // Array de métodos HTTP coincidentes $ruta->métodos; // Array de parámetros nombrados $ruta->params; // Expresión regular coincidente $ruta->regex; // Contiene el contenido de cualquier '*' utilizado en el patrón de URL $ruta->splat; // Muestra la ruta de la url....si realmente la necesitas $ruta->patrón; // Muestra qué middleware está asignado a esto $ruta->middleware; // Muestra el alias asignado a esta ruta $ruta->alias; }, true);
Puede haber momentos en los que quieras agrupar rutas relacionadas (como /api/v1). Puedes hacer esto usando el método group:
/api/v1
group
Flight::group('/api/v1', function () { Flight::route('/usuarios', function () { // Coincide con /api/v1/usuarios }); Flight::route('/publicaciones', function () { // Coincide con /api/v1/publicaciones }); });
Incluso puedes anidar grupos de grupos:
Flight::group('/api', function () { Flight::group('/v1', function () { // Flight::get() obtiene variables, ¡no establece una ruta! Ver contexto de objeto abajo Flight::route('GET /usuarios', function () { // Coincide con GET /api/v1/usuarios }); Flight::post('/publicaciones', function () { // Coincide con POST /api/v1/publicaciones }); Flight::put('/publicaciones/1', function () { // Coincide con PUT /api/v1/publicaciones }); }); Flight::group('/v2', function () { // Flight::get() obtiene variables, ¡no establece una ruta! Ver contexto de objeto abajo Flight::route('GET /usuarios', function () { // Coincide con GET /api/v2/usuarios }); }); });
Todavía puedes usar la agrupación de rutas con el objeto Engine de la siguiente manera:
Engine
$app = new \flight\Engine(); $app->group('/api/v1', function (Router $router) { // utiliza la variable $router $router->get('/usuarios', function () { // Coincide con GET /api/v1/usuarios }); $router->post('/publicaciones', function () { // Coincide con POST /api/v1/publicaciones }); });
Ahora puedes transmitir respuestas al cliente usando el método streamWithHeaders(). Esto es útil para enviar archivos grandes, procesos largos o generar respuestas grandes. El enrutamiento de un flujo se maneja un poco diferente que una ruta regular.
streamWithHeaders()
Nota: Las respuestas de transmisión solo están disponibles si tienes flight.v2.output_buffering configurado en false.
Puedes transmitir una respuesta al cliente usando el método stream() en una ruta. Si haces esto, debes configurar todos los métodos manualmente antes de enviar cualquier cosa al cliente. Esto se hace con la función header() de php o el método Flight::response()->setRealHeader().
stream()
header()
Flight::response()->setRealHeader()
Flight::route('/@nombre_archivo', function($nombre_archivo) { // obviamente deberías sanitizar la ruta y otras cosas. $nombre_archivo_seguro = basename($nombre_archivo); // Si tienes encabezados adicionales que configurar aquí después de que se haya ejecutado la ruta // debes definirlos antes de que se imprima cualquier cosa. // Todos deben ser una llamada en bruto a la función header() o // una llamada a Flight::response()->setRealHeader() header('Content-Disposition: attachment; filename="'.$nombre_archivo_seguro.'"'); // o Flight::response()->setRealHeader('Content-Disposition', 'attachment; filename="'.$nombre_archivo_seguro.'"'); $datos_archivo = file_get_contents('/alguna/ruta/a/archivos/'.$nombre_archivo_seguro); // Captura de errores y demás if(empty($datos_archivo)) { Flight::halt(404, 'Archivo no encontrado'); } // configura manualmente la longitud del contenido si lo deseas header('Content-Length: '.filesize($nombre_archivo)); // Transmite los datos al cliente echo $datos_archivo; // Esta es la línea mágica aquí })->stream();
También puedes usar el método streamWithHeaders() para configurar los encabezados antes de comenzar a transmitir.
Flight::route('/transmitir-usuarios', function() { // puedes agregar cualquier encabezado adicional que desees aquí // solo debes usar header() o Flight::response()->setRealHeader() // de cualquier manera extraigas tus datos, solo como ejemplo... $usuarios_stmt = Flight::db()->query("SELECT id, nombre, apellido FROM usuarios"); echo '{'; $cantidad_usuarios = count($usuarios); while($usuario = $usuarios_stmt->fetch(PDO::FETCH_ASSOC)) { echo json_encode($usuario); if(--$cantidad_usuarios > 0) { echo ','; } // Esto es necesario para enviar los datos al cliente ob_flush(); } echo '}'; // Así es como configurarás los encabezados antes de comenzar a transmitir. })->streamWithHeaders([ 'Content-Type' => 'application/json', 'Content-Disposition' => 'attachment; filename="usuarios.json"', // código de estado opcional, por defecto 200 'estado' => 200 ]);
Flight permite guardar variables para que puedan ser utilizadas en cualquier lugar de tu aplicación.
// Guarda tu variable Flight::set('id', 123); // En otro lugar de tu aplicación $id = Flight::get('id');
Para verificar si una variable ha sido establecida, puedes hacer lo siguiente:
// Elimina la variable id Flight::clear('id'); // Elimina todas las variables Flight::clear();
Flight también utiliza variables con propósitos de configuración.
El Contenedor de Inyección de Dependencias (DIC) es una herramienta potente que te permite gestionar las dependencias de tu aplicación. Es un concepto clave en los marcos de PHP modernos y se utiliza para gestionar la instanciación y configuración de objetos. Algunos ejemplos de bibliotecas DIC son: Dice, Pimple, PHP-DI y league/container.
Un DIC es una forma elegante de decir que te permite crear y gestionar tus clases en una ubicación centralizada. Esto es útil cuando necesitas pasar el mismo objeto a varias clases (como tus controladores). Un ejemplo sencillo podría ayudar a entender esto mejor.
La forma antigua de hacer las cosas podría verse así:
require 'vendor/autoload.php'; // clase para gestionar usuarios desde la base de datos class UserController { protected PDO $pdo; public function __construct(PDO $pdo) { $this->pdo = $pdo; } public function view(int $id) { $stmt = $this->pdo->prepare('SELECT * FROM users WHERE id = :id'); $stmt->execute(['id' => $id]); print_r($stmt->fetch()); } } $User = new UserController(new PDO('mysql:host=localhost;dbname=test', 'user', 'pass')); Flight::route('/user/@id', [ $UserController, 'view' ]); Flight::start();
Se puede ver en el código anterior que estamos creando un nuevo objeto PDO y pasándolo a nuestra clase UserController. Esto está bien para una aplicación pequeña, pero a medida que tu aplicación crece, descubrirás que estás creando el mismo objeto PDO en múltiples lugares. Aquí es donde resulta útil un DIC.
UserController
Aquí tienes el mismo ejemplo utilizando un DIC (usando Dice):
require 'vendor/autoload.php'; // misma clase que arriba. Sin cambios class UserController { protected PDO $pdo; public function __construct(PDO $pdo) { $this->pdo = $pdo; } public function view(int $id) { $stmt = $this->pdo->prepare('SELECT * FROM users WHERE id = :id'); $stmt->execute(['id' => $id]); print_r($stmt->fetch()); } } // crear un nuevo contenedor $container = new \Dice\Dice; // ¡no olvides volver a asignarlo a sí mismo como se muestra abajo! $container = $container->addRule('PDO', [ // shared significa que el mismo objeto se devolverá cada vez 'shared' => true, 'constructParams' => ['mysql:host=localhost;dbname=test', 'user', 'pass' ] ]); // Esto registra el controlador de contenedor para que Flight sepa usarlo. Flight::registerContainerHandler(function($class, $params) use ($container) { return $container->create($class, $params); }); // ahora podemos usar el contenedor para crear nuestro UserController Flight::route('/user/@id', [ 'UserController', 'view' ]); // o alternativamente puedes definir la ruta así Flight::route('/user/@id', 'UserController->view'); // o Flight::route('/user/@id', 'UserController::view'); Flight::start();
Apuesto a que puedes estar pensando que se añadió mucho código extra al ejemplo. La magia reside en cuando tienes otro controlador que necesita el objeto PDO.
// Si todos tus controladores tienen un constructor que necesita un objeto PDO // ¡¡¡Cada una de las rutas a continuación lo recibirán automáticamente inyectado!!! Flight::route('/empresa/@id', 'CompanyController->view'); Flight::route('/organización/@id', 'OrganizationController->view'); Flight::route('/categoría/@id', 'CategoryController->view'); Flight::route('/ajustes', 'SettingsController->view');
El beneficio adicional de utilizar un DIC es que las pruebas unitarias se vuelven mucho más fáciles. Puedes crear un objeto simulado y pasarlo a tu clase. ¡Este es un gran beneficio al escribir pruebas para tu aplicación!
Flight también puede utilizar cualquier contenedor compatible con PSR-11. Esto significa que puedes usar cualquier contenedor que implemente la interfaz PSR-11. Aquí tienes un ejemplo utilizando el contenedor PSR-11 de League:
require 'vendor/autoload.php'; // misma clase UserController que arriba $container = new \League\Container\Container(); $container->add(UserController::class)->addArgument(PdoWrapper::class); $container->add(PdoWrapper::class) ->addArgument('mysql:host=localhost;dbname=test') ->addArgument('user') ->addArgument('pass'); Flight::registerContainerHandler($container); Flight::route('/user', [ 'UserController', 'view' ]); Flight::start();
Aunque pueda ser un poco más detallado que el ejemplo anterior con Dice, aún se logra el mismo resultado con los mismos beneficios.
También puedes crear tu propio controlador DIC. Esto es útil si tienes un contenedor personalizado que quieres utilizar y que no es compatible con PSR-11 (Dice). Consulta el ejemplo básico para ver cómo hacerlo.
Además, existen algunas configuraciones útiles que facilitarán tu vida al usar Flight.
Si estás utilizando la instancia del Engine en tus controladores/middleware, así es como lo configurarías:
// En algún lugar de tu archivo de inicio $engine = Flight::app(); $container = new \Dice\Dice; $container = $container->addRule('*', [ 'substitutions' => [ // Aquí es donde pasas la instancia Engine::class => $engine ] ]); $engine->registerContainerHandler(function($class, $params) use ($container) { return $container->create($class, $params); }); // Ahora puedes usar la instancia del Motor en tus controladores/middleware class MyController { public function __construct(Engine $app) { $this->app = $app; } public function index() { $this->app->render('index'); } }
Si tienes otras clases que quieres agregar al contenedor, con Dice es fácil ya que serán resueltas automáticamente por el contenedor. Aquí tienes un ejemplo:
$container = new \Dice\Dice; // Si no necesitas inyectar nada en tu clase // ¡no necesitas definir nada! Flight::registerContainerHandler(function($class, $params) use ($container) { return $container->create($class, $params); }); class MyCustomClass { public function parseThing() { return 'cosa'; } } class UserController { protected MyCustomClass $MyCustomClass; public function __construct(MyCustomClass $MyCustomClass) { $this->MyCustomClass = $MyCustomClass; } public function index() { echo $this->MyCustomClass->parseThing(); } } Flight::route('/usuario', 'UserController->index');
Flight es compatible con middleware de ruta y de grupo de ruta. El middleware es una función que se ejecuta antes (o después) de la devolución de llamada de la ruta. Esta es una excelente manera de agregar verificaciones de autenticación de API en su código, o para validar que el usuario tiene permiso para acceder a la ruta.
Aquí tienes un ejemplo básico:
// Si solo proporcionas una función anónima, se ejecutará antes de la devolución de llamada de la ruta. // no hay funciones de middleware "después" excepto para clases (ver abajo) Flight::route('/ruta', function() { echo ' ¡Aquí estoy!'; })->addMiddleware(function() { echo '¡Middleware primero!'; }); Flight::start(); // ¡Esto mostrará "¡Middleware primero! ¡Aquí estoy!"!
Hay algunas notas muy importantes sobre el middleware que debes tener en cuenta antes de usarlos:
Flight::redirect()
function($params) { ... }
public function before($params) {}
flight\Engine
__construct()
El middleware también se puede registrar como una clase. Si necesitas la funcionalidad "después", debes usar una clase.
class MiMiddleware { public function before($params) { echo '¡Middleware primero!'; } public function after($params) { echo '¡Middleware último!'; } } $MiMiddleware = new MiMiddleware(); Flight::route('/ruta', function() { echo ' ¡Aquí estoy! '; })->addMiddleware($MiMiddleware); // también->addMiddleware([$MiMiddleware, $MiMiddleware2]); Flight::start(); // Esto mostrará "¡Middleware primero! ¡Aquí estoy! ¡Middleware último!"
Digamos que tienes un middleware de autenticación y quieres redirigir al usuario a una página de inicio de sesión si no está autenticado. Tienes un par de opciones a tu disposición:
Aquí tienes un ejemplo simple de return false;:
class MiMiddleware { public function before($params) { if (isset($_SESSION['usuario']) === false) { return false; } // dado que es verdadero, todo sigue su curso } }
Aquí tienes un ejemplo de redirigir al usuario a una página de inicio de sesión:
class MiMiddleware { public function before($params) { if (isset($_SESSION['usuario']) === false) { Flight::redirect('/login'); exit; } } }
Digamos que necesitas lanzar un error JSON porque estás construyendo una API. Puedes hacerlo de esta manera:
class MiMiddleware { public function before($params) { $autorización = Flight::request()->headers['Authorization']; if(empty($autorización)) { Flight::json(['error' => 'Debes iniciar sesión para acceder a esta página.'], 403); exit; // o Flight::halt(403, json_encode(['error' => 'Debes iniciar sesión para acceder a esta página.']); } } }
Puedes agregar un grupo de ruta, y luego cada ruta en ese grupo tendrá el mismo middleware también. Esto es útil si necesitas agrupar una serie de rutas, por ejemplo, por un middleware de autenticación para verificar la clave de API en el encabezado.
// añadido al final del método group Flight::group('/api', function() { // Esta ruta con aspecto "vacío" realmente coincidirá con /api Flight::route('', function() { echo 'api'; }, false, 'api'); Flight::route('/usuarios', function() { echo 'usuarios'; }, false, 'usuarios'); Flight::route('/usuarios/@id', function($id) { echo 'usuario:'.$id; }, false, 'ver_usuario'); }, [ new MiddlewareAutenticaciónApi() ]);
Si deseas aplicar un middleware global a todas tus rutas, puedes agregar un grupo "vacío":
// añadido al final del método group Flight::group('', function() { Flight::route('/usuarios', function() { echo 'usuarios'; }, false, 'usuarios'); Flight::route('/usuarios/@id', function($id) { echo 'usuario:'.$id; }, false, 'ver_usuario'); }, [ new MiddlewareAutenticaciónApi() ]);
# Filtrado Flight te permite filtrar métodos antes y después de que sean llamados. No hay ganchos predefinidos que necesites memorizar. Puedes filtrar cualquiera de los métodos predeterminados del marco de trabajo, así como cualquier método personalizado que hayas mapeado. Una función de filtro se ve así: ```php function (array &$params, string &$output): bool { // Código de filtro }
Usando las variables pasadas puedes manipular los parámetros de entrada y/o la salida.
Puedes hacer que un filtro se ejecute antes de un método haciendo:
Flight::before('start', function (array &$params, string &$output): bool { // Haz algo });
Puedes hacer que un filtro se ejecute después de un método haciendo:
Flight::after('start', function (array &$params, string &$output): bool { // Haz algo });
Puedes añadir tantos filtros como quieras a cualquier método. Serán llamados en el orden en el que son declarados.
Aquí tienes un ejemplo del proceso de filtrado:
// Mapear un método personalizado Flight::map('hello', function (string $name) { return "¡Hola, $name!"; }); // Agregar un filtro antes Flight::before('hello', function (array &$params, string &$output): bool { // Manipular el parámetro $params[0] = 'Fred'; return true; }); // Agregar un filtro después Flight::after('hello', function (array &$params, string &$output): bool { // Manipular la salida $output .= " ¡Que tengas un buen día!"; return true; }); // Invocar el método personalizado echo Flight::hello('Bob');
Esto debería mostrar:
¡Hola Fred! ¡Que tengas un buen día!
Si has definido múltiples filtros, puedes romper la cadena devolviendo false en cualquiera de tus funciones de filtro:
false
Flight::before('start', function (array &$params, string &$output): bool { echo 'uno'; return true; }); Flight::before('start', function (array &$params, string &$output): bool { echo 'dos'; // Esto terminará la cadena return false; }); // Esto no se llamará Flight::before('start', function (array &$params, string &$output): bool { echo 'tres'; return true; });
Nota, los métodos principales como map y register no pueden ser filtrados porque son llamados directamente y no son invocados dinámicamente.
Flight encapsula la solicitud HTTP en un solo objeto, al cual se puede acceder así:
$solicitud = Flight::solicitud();
El objeto de solicitud proporciona las siguientes propiedades:
Se puede acceder a las propiedades query, datos, cookies y archivos como arreglos u objetos.
query
datos
cookies
archivos
Entonces, para obtener un parámetro de cadena de consulta, puedes hacer:
$id = Flight::solicitud()->query['id'];
O puedes hacer:
$id = Flight::solicitud()->query->id;
Para obtener el cuerpo sin procesar de la solicitud HTTP, por ejemplo, al tratar con solicitudes PUT, puedes hacer:
$cuerpo = Flight::solicitud()->getBody();
Si envías una solicitud con el tipo application/json y los datos {"id": 123} estará disponible desde la propiedad datos:
application/json
{"id": 123}
$id = Flight::solicitud()->datos->id;
$_SERVER
Hay un atajo disponible para acceder a la matriz $_SERVER a través del método getVar():
getVar()
$host = Flight::solicitud()->getVar['HTTP_HOST'];
Puedes acceder a las cabeceras de la solicitud utilizando el método getHeader() o getHeaders():
getHeader()
getHeaders()
// Tal vez necesites la cabecera de Autorización $host = Flight::solicitud()->getHeader('Authorization'); // Si necesitas obtener todas las cabeceras $cabeceras = Flight::solicitud()->getHeaders();
Flight está diseñado para ser fácil de usar y entender. Lo siguiente es el conjunto completo de métodos para el framework. Consiste en métodos centrales, que son métodos estáticos regulares, y métodos extensibles, que son métodos asignados que pueden ser filtrados o anulados.
Flight::map(string $nombre, callable $retorno, bool $pasar_ruta = false) // Crea un método personalizado para el framework. Flight::register(string $nombre, string $clase, array $params = [], ?callable $retorno = null) // Registra una clase a un método del framework. Flight::before(string $nombre, callable $retorno) // Agrega un filtro antes de un método del framework. Flight::after(string $nombre, callable $retorno) // Agrega un filtro después de un método del framework. Flight::path(string $ruta) // Agrega una ruta para la carga automática de clases. Flight::get(string $clave) // Obtiene una variable. Flight::set(string $clave, mixed $valor) // Establece una variable. Flight::has(string $clave) // Verifica si una variable está establecida. Flight::clear(array|string $clave = []) // Borra una variable. Flight::init() // Inicializa el framework a sus ajustes predeterminados. Flight::app() // Obtiene la instancia del objeto de la aplicación
Flight::start() // Inicia el framework. Flight::stop() // Detiene el framework y envía una respuesta. Flight::halt(int $codigo = 200, string $mensaje = '') // Detiene el framework con un código de estado opcional y mensaje. Flight::route(string $patrón, callable $retorno, bool $pasar_ruta = false) // Asigna un patrón de URL a un retorno. Flight::group(string $patrón, callable $retorno) // Crea agrupaciones para URLs, el patrón debe ser una cadena. Flight::redirect(string $url, int $codigo) // Redirige a otra URL. Flight::render(string $archivo, array $datos, ?string $clave = null) // Renderiza un archivo de plantilla. Flight::error(Throwable $error) // Envía una respuesta HTTP 500. Flight::notFound() // Envía una respuesta HTTP 404. Flight::etag(string $id, string $tipo = 'string') // Realiza almacenamiento en caché HTTP ETag. Flight::lastModified(int $tiempo) // Realiza almacenamiento en caché HTTP de Última Modificación. Flight::json(mixed $datos, int $codigo = 200, bool $codificar = true, string $charset = 'utf8', int $opción) // Envía una respuesta JSON. Flight::jsonp(mixed $datos, string $parametro = 'jsonp', int $codigo = 200, bool $codificar = true, string $charset = 'utf8', int $opción) // Envía una respuesta JSONP.
Cualquier método personalizado añadido con map y register también puede ser filtrado.
Flight está diseñado para ser fácil de usar y entender. A continuación se muestra el conjunto completo de métodos para el framework. Consta de métodos principales, que son métodos estáticos regulares, y métodos extensibles, que son métodos mapeados que pueden ser filtrados o sobreescritos.
Estos métodos son fundamentales para el framework y no pueden ser sobreescritos.
Flight::map(string $nombre, callable $callback, bool $pasar_ruta = false) // Crea un método personalizado para el framework. Flight::register(string $nombre, string $clase, array $params = [], ?callable $callback = null) // Registra una clase a un método del framework. Flight::unregister(string $nombre) // Anula el registro de una clase a un método del framework. Flight::before(string $nombre, callable $callback) // Agrega un filtro antes de un método del framework. Flight::after(string $nombre, callable $callback) // Agrega un filtro después de un método del framework. Flight::path(string $ruta) // Agrega una ruta para cargar clases automáticamente. Flight::get(string $clave) // Obtiene una variable. Flight::set(string $clave, mixed $valor) // Establece una variable. Flight::has(string $clave) // Comprueba si una variable está establecida. Flight::clear(array|string $clave = []) // Borra una variable. Flight::init() // Inicializa el framework con su configuración predeterminada. Flight::app() // Obtiene la instancia del objeto de la aplicación Flight::request() // Obtiene la instancia del objeto de la solicitud Flight::response() // Obtiene la instancia del objeto de la respuesta Flight::router() // Obtiene la instancia del objeto del enrutador Flight::view() // Obtiene la instancia del objeto de vista
Flight::start() // Inicia el framework. Flight::stop() // Detiene el framework y envía una respuesta. Flight::halt(int $código = 200, string $mensaje = '') // Detiene el framework con un código de estado y mensaje opcionales. Flight::route(string $patrón, callable $callback, bool $pasar_ruta = false, string $alias = '') // Asocia un patrón de URL a un callback. Flight::post(string $patrón, callable $callback, bool $pasar_ruta = false, string $alias = '') // Asocia un patrón de URL de solicitud POST a un callback. Flight::put(string $patrón, callable $callback, bool $pasar_ruta = false, string $alias = '') // Asocia un patrón de URL de solicitud PUT a un callback. Flight::patch(string $patrón, callable $callback, bool $pasar_ruta = false, string $alias = '') // Asocia un patrón de URL de solicitud PATCH a un callback. Flight::delete(string $patrón, callable $callback, bool $pasar_ruta = false, string $alias = '') // Asocia un patrón de URL de solicitud DELETE a un callback. Flight::group(string $patrón, callable $callback) // Crea agrupaciones para URL, el patrón debe ser una cadena. Flight::getUrl(string $nombre, array $params = []) // Genera una URL basada en un alias de ruta. Flight::redirect(string $url, int $código) // Redirige a otra URL. Flight::render(string $archivo, array $datos, ?string $key = null) // Renderiza un archivo de plantilla. Flight::error(Throwable $error) // Envía una respuesta HTTP 500. Flight::notFound() // Envía una respuesta HTTP 404. Flight::etag(string $id, string $tipo = 'cadena') // Realiza el almacenamiento en caché HTTP ETag. Flight::lastModified(int $tiempo) // Realiza el almacenamiento en caché HTTP Last-Modified. Flight::json(mixed $datos, int $código = 200, bool $codificar = true, string $charset = 'utf8', int $opción) // Envía una respuesta JSON. Flight::jsonp(mixed $datos, string $param = 'jsonp', int $código = 200, bool $codificar = true, string $charset = 'utf8', int $opción) // Envía una respuesta JSONP.
Algunos programadores se oponen vehementemente a utilizar frameworks. Argumentan que los frameworks son pesados, lentos y difíciles de aprender. Dicen que los frameworks son innecesarios y que se puede escribir un mejor código sin ellos. Ciertamente hay algunos puntos válidos que se pueden hacer sobre las desventajas de usar frameworks. Sin embargo, también hay muchas ventajas en utilizar frameworks.
Aquí hay algunas razones por las que podrías considerar usar un framework:
Flight es un micro-framework. Esto significa que es pequeño y ligero. No proporciona tanta funcionalidad como frameworks más grandes como Laravel o Symfony. Sin embargo, sí proporciona gran parte de la funcionalidad que necesitas para construir aplicaciones web. También es fácil de aprender y utilizar. Esto lo convierte en una buena elección para construir aplicaciones web de forma rápida y sencilla. Si eres nuevo en los frameworks, Flight es un gran framework para principiantes para empezar. Te ayudará a conocer las ventajas de usar frameworks sin abrumarte con demasiada complejidad. Después de adquirir algo de experiencia con Flight, será más fácil pasar a frameworks más complejos como Laravel o Symfony, sin embargo, Flight aún puede crear una aplicación sólida y exitosa.
El enrutamiento es el núcleo del framework Flight, pero ¿qué es exactamente? El enrutamiento es el proceso de tomar una URL y hacer coincidir con una función específica en tu código. Así es como puedes hacer que tu sitio web haga diferentes cosas según la URL que se solicite. Por ejemplo, es posible que desees mostrar el perfil de un usuario cuando visiten /usuario/1234, pero mostrar una lista de todos los usuarios cuando visiten /usuarios. Todo esto se hace mediante el enrutamiento.
/usuario/1234
/usuarios
Podría funcionar algo así:
http://ejemplo.com/usuario/1234
Flight::route('/usuario/@id', [ 'ControladorUsuario', 'verPerfilUsuario' ]);
verPerfilUsuario($id)
ControladorUsuario
1234
$id
verPerfilUsuario()
¡Tener un router centralizado adecuado realmente puede hacer tu vida dramáticamente más fácil! Solo podría ser difícil verlo al principio. Aquí hay algunas razones por las que:
vista_usuario
id
/admin/usuario/1234
Seguramente estás familiarizado con la forma tradicional de crear un sitio web, script por script. Podrías tener un archivo llamado index.php que tiene un montón de declaraciones if para verificar la URL y luego ejecutar una función específica según la URL. Esta es una forma de enrutamiento, pero no es muy organizada y puede salirse de control rápidamente. El sistema de enrutamiento de Flight es una forma mucho más organizada y potente de manejar el enrutamiento.
if
¿Esto?
// /usuario/ver_perfil.php?id=1234 if ($_GET['id']) { $id = $_GET['id']; verPerfilUsuario($id); } // /usuario/editar_perfil.php?id=1234 if ($_GET['id']) { $id = $_GET['id']; editarPerfilUsuario($id); } // etc...
O ¿esto?
// index.php Flight::route('/usuario/@id', [ 'ControladorUsuario', 'verPerfilUsuario' ]); Flight::route('/usuario/@id/editar', [ 'ControladorUsuario', 'editarPerfilUsuario' ]); // En tal vez tu app/controladores/ControladorUsuario.php class ControladorUsuario { public function verPerfilUsuario($id) { // hacer algo } public function editarPerfilUsuario($id) { // hacer algo } }
Espero que empieces a ver los beneficios de usar un sistema de enrutamiento centralizado. ¡Es mucho más fácil de gestionar y entender a largo plazo!
Flight proporciona una forma simple y fácil de manejar las solicitudes y respuestas. Esto es lo fundamental que hace un framework web. Toma una solicitud de un navegador del usuario, la procesa y luego envía una respuesta. Así es como puedes construir aplicaciones web que hacen cosas como mostrar el perfil de un usuario, permitir que un usuario inicie sesión o permitir que un usuario publique una nueva entrada en un blog.
Una solicitud es lo que el navegador del usuario envía a tu servidor cuando visita tu sitio web. Esta solicitud contiene información sobre lo que el usuario desea hacer. Por ejemplo, podría contener información sobre qué URL quiere visitar el usuario, qué datos quiere enviar al servidor, o qué tipo de datos quiere recibir del servidor. Es importante saber que una solicitud es de solo lectura. No puedes cambiar la solicitud, pero puedes leer desde ella.
Flight proporciona una forma sencilla de acceder a información sobre la solicitud. Puedes acceder a información sobre la solicitud utilizando el método Flight::request(). Este método devuelve un objeto Request que contiene información sobre la solicitud. Puedes usar este objeto para acceder a información sobre la solicitud, como la URL, el método o los datos que el usuario envió a tu servidor.
Flight::request()
Request
Una respuesta es lo que tu servidor envía de vuelta al navegador del usuario cuando visitan tu sitio web. Esta respuesta contiene información sobre lo que tu servidor quiere hacer. Por ejemplo, podría contener información sobre qué tipo de datos quiere enviar tu servidor al usuario, qué tipo de datos quiere recibir tu servidor del usuario o qué tipo de datos quiere almacenar tu servidor en la computadora del usuario.
Flight proporciona una forma sencilla de enviar una respuesta al navegador del usuario. Puedes enviar una respuesta utilizando el método Flight::response(). Este método toma un objeto Response como argumento y envía la respuesta al navegador del usuario. Puedes usar este objeto para enviar una respuesta al navegador del usuario, como HTML, JSON o un archivo. Flight te ayuda a generar automáticamente algunas partes de la respuesta para facilitar las cosas, pero en última instancia tienes control sobre lo que envías de vuelta al usuario.
Flight::response()
Response
Flight proporciona soporte incorporado para el almacenamiento en caché a nivel HTTP. Si se cumple la condición de caché, Flight devolverá una respuesta HTTP 304 No modificado. La próxima vez que el cliente solicite el mismo recurso, se le pedirá que utilice su versión en caché local.
304 No modificado
Puedes utilizar el método lastModified y pasar un sello de tiempo UNIX para establecer la fecha y hora en que se modificó por última vez una página. El cliente seguirá utilizando su caché hasta que se cambie el valor de última modificación.
lastModified
Flight::route('/noticias', function () { Flight::lastModified(1234567890); echo 'Este contenido se almacenará en caché.'; });
La caché ETag es similar a Última modificación, excepto que puedes especificar cualquier identificación que desees para el recurso:
ETag
Última modificación
Flight::route('/noticias', function () { Flight::etag('mi-identificador-único'); echo 'Este contenido se almacenará en caché.'; });
Ten en cuenta que llamar a lastModified o etag establecerá y comprobará el valor de caché. Si el valor de caché es el mismo entre las solicitudes, Flight enviará inmediatamente una respuesta HTTP 304 y detendrá el procesamiento.
etag
HTTP 304
Flight ayuda a generar parte de los encabezados de respuesta, pero tienes la mayor parte del control sobre lo que envías de vuelta al usuario. A veces puedes acceder directamente al objeto Response, pero la mayor parte del tiempo usarás la instancia Flight para enviar una respuesta.
Flight
Flight utiliza ob_start() para almacenar en búfer la salida. Esto significa que puedes usar echo o print para enviar una respuesta al usuario y Flight la capturará y la enviará de vuelta al usuario con los encabezados adecuados.
echo
print
// Esto enviará "¡Hola, Mundo!" al navegador del usuario Flight::route('/', function() { echo "¡Hola, Mundo!"; }); // HTTP/1.1 200 OK // Content-Type: text/html // // ¡Hola, Mundo!
Como alternativa, puedes llamar al método write() para agregar al cuerpo también.
write()
// Esto enviará "¡Hola, Mundo!" al navegador del usuario Flight::route('/', function() { // A veces es detallado, pero hace el trabajo cuando lo necesitas Flight::response()->write("¡Hola, Mundo!"); // Si quieres recuperar el cuerpo que has establecido en este punto // puedes hacerlo así $body = Flight::response()->getBody(); });
Puedes establecer el código de estado de la respuesta usando el método status:
status
Flight::route('/@id', function($id) { if($id == 123) { Flight::response()->status(200); echo "¡Hola, Mundo!"; } else { Flight::response()->status(403); echo "Prohibido"; } });
Si deseas obtener el código de estado actual, puedes usar el método status sin argumentos:
Flight::response()->status(); // 200
Puedes ejecutar una devolución de llamada en el cuerpo de la respuesta usando el método addResponseBodyCallback:
addResponseBodyCallback
Flight::route('/usuarios', function() { $db = Flight::db(); $usuarios = $db->fetchAll("SELECT * FROM usuarios"); Flight::render('tabla_usuarios', ['usuarios' => $usuarios]); }); // Esto comprimirá todas las respuestas para cualquier ruta Flight::response()->addResponseBodyCallback(function($body) { return gzencode($body, 9); });
Puedes agregar múltiples devoluciones de llamada y se ejecutarán en el orden en que se agregaron. Dado que esto puede aceptar cualquier callable, puede aceptar una matriz de clases [ $clase, 'método' ], un cierre $strReplace = function($body) { str_replace('hola', 'allí', $body); };, o un nombre de función 'minificar' si tuvieras una función para minificar tu código html, por ejemplo.
[ $clase, 'método' ]
$strReplace = function($body) { str_replace('hola', 'allí', $body); };
'minificar'
Nota: Las devoluciones de llamada de ruta no funcionarán si estás utilizando la opción de configuración flight.v2.output_buffering.
Si deseas que esto se aplique solo a una ruta específica, podrías agregar la devolución de llamada en la propia ruta:
Flight::route('/usuarios', function() { $db = Flight::db(); $usuarios = $db->fetchAll("SELECT * FROM usuarios"); Flight::render('tabla_usuarios', ['usuarios' => $usuarios]); // Esto comprimirá solo la respuesta para esta ruta Flight::response()->addResponseBodyCallback(function($body) { return gzencode($body, 9); }); });
También puedes usar middleware para aplicar la devolución de llamada a todas las rutas a través del middleware:
// MinifyMiddleware.php class MinifyMiddleware { public function before() { Flight::response()->addResponseBodyCallback(function($body) { // Esto es un return $this->minificar($body); }); } protected function minificar(string $body): string { // minificar el cuerpo return $body; } } // index.php Flight::group('/usuarios', function() { Flight::route('', function() { /* ... */ }); Flight::route('/@id', function($id) { /* ... */ }); }, [ new MinifyMiddleware() ]);
Puedes establecer un encabezado como el tipo de contenido de la respuesta usando el método header:
// Esto enviará "¡Hola, Mundo!" al navegador del usuario en texto plano Flight::route('/', function() { Flight::response()->header('Content-Type', 'text/plain'); echo "¡Hola, Mundo!"; });
Flight proporciona soporte para enviar respuestas JSON y JSONP. Para enviar una respuesta JSON, pasas algunos datos para ser codificados en JSON:
Flight::json(['id' => 123]);
También puedes pasar un código de estado como segundo argumento:
Flight::json(['id' => 123], 201);
También puedes pasar un argumento a la última posición para habilitar la impresión clara:
Flight::json(['id' => 123], 200, true, 'utf-8', JSON_PRETTY_PRINT);
Si estás cambiando opciones pasadas a Flight::json() y deseas una syntax más simple, solo puedes mapear el método JSON:
Flight::json()
Flight::map('json', function($data, $code = 200, $options = 0) { Flight::_json($data, $code, true, 'utf-8', $options); } // Y ahora puede ser utilizado de esta manera Flight::json(['id' => 123], 200, JSON_PRETTY_PRINT);
Si deseas enviar una respuesta JSON y detener la ejecución, puedes usar el método jsonHalt. Esto es útil para casos en los que estás verificando tal vez algún tipo de autorización y si el usuario no está autorizado, puedes enviar una respuesta JSON inmediatamente, borrar el contenido del cuerpo existente y detener la ejecución.
jsonHalt
Flight::route('/usuarios', function() { $autorizado = algunaVerificaciónDeAutorización(); // Comprueba si el usuario está autorizado if($autorizado === false) { Flight::jsonHalt(['error' => 'No autorizado'], 401); } // Continuar con el resto de la ruta });
Para solicitudes JSONP, opcionalmente puedes pasar el nombre del parámetro de consulta que estás usando para definir tu función de devolución de llamada:
Flight::jsonp(['id' => 123], 'q');
Entonces, al hacer una solicitud GET usando ?q=mi_funcion, deberías recibir la salida:
?q=mi_funcion
mi_funcion({"id":123});
Si no pasas un nombre de parámetro de consulta, se establecerá por defecto en jsonp.
jsonp
Puedes redirigir la solicitud actual usando el método redirect() y pasando una nueva URL:
redirect()
Flight::redirect('/nueva/ubicacion');
Por defecto, Flight envía un código de estado HTTP 303 ("Ver Otro"). Opcionalmente, puedes establecer un código personalizado:
Flight::redirect('/nueva/ubicacion', 401);
Puedes detener el framework en cualquier momento llamando al método halt:
También puedes especificar opcionalmente un código de estado HTTP y un mensaje:
Flight::halt(200, 'Volveremos enseguida...');
Llamar a halt descartará cualquier contenido de respuesta hasta ese punto. Si deseas detener el framework y enviar la respuesta actual, usa el método stop:
Flight proporciona soporte integrado para el almacenamiento en caché a nivel HTTP. Si la condición de caché se cumple, Flight devolverá una respuesta HTTP 304 No Modificado. La próxima vez que el cliente solicite el mismo recurso, se le pedirá usar su versión en caché local.
HTTP 304 No Modificado
Si deseas almacenar en caché toda tu respuesta, puedes usar el método cache() y pasar el tiempo en caché.
cache()
// Esto almacenará en caché la respuesta durante 5 minutos Flight::route('/noticias', function () { Flight::response()->cache(time() + 300); echo 'Este contenido será almacenado en caché.'; }); // Alternativamente, puedes usar una cadena que pasarías // al método strtotime() Flight::route('/noticias', function () { Flight::response()->cache('+5 minutes'); echo 'Este contenido será almacenado en caché.'; });
Puedes usar el método lastModified y pasar una marca de tiempo UNIX para establecer la fecha y hora en que una página fue modificada por última vez. El cliente seguirá usando su caché hasta que el valor de última modificación sea cambiado.
Flight::route('/noticias', function () { Flight::lastModified(1234567890); echo 'Este contenido será almacenado en caché.'; });
El almacenamiento en caché del ETag es similar a Última Modificación, excepto que puedes especificar cualquier identificación que desees para el recurso:
Última Modificación
Flight::route('/noticias', function () { Flight::etag('mi-identificador-único'); echo 'Este contenido será almacenado en caché.'; });
Ten en cuenta que llamar tanto a lastModified como a etag establecerá y verificará el valor de la caché. Si el valor de la caché es el mismo entre las solicitudes, Flight enviará inmediatamente una respuesta HTTP 304 y detendrá el procesamiento.
En lugar de ejecutar Flight como una clase estática global, puedes opcionalmente ejecutarlo como una instancia de objeto.
require 'flight/autoload.php'; $app = Flight::app(); $app->route('/', function () { echo '¡hola mundo!'; }); $app->start();
Así que en lugar de llamar al método estático, llamarías al método de instancia con el mismo nombre en el objeto Engine.
Puedes redirigir la solicitud actual utilizando el método redirect y pasando una nueva URL:
redirect
Por defecto, Flight envía un código de estado HTTP 303. Opcionalmente, puedes establecer un código personalizado:
Flight proporciona algunas funcionalidades básicas de plantillas de forma predeterminada. Para mostrar una vista de plantilla llame al método render con el nombre del archivo de plantilla y datos de plantilla opcionales:
render
Flight::render('hello.php', ['name' => 'Bob']);
Los datos de plantilla que pase se inyectan automáticamente en la plantilla y se pueden hacer referencia como una variable local. Los archivos de plantilla son simplemente archivos PHP. Si el contenido del archivo de plantilla hello.php es:
hello.php
¡Hola, <?= $name ?>!
La salida sería:
¡Hola, Bob!
También puede configurar manualmente variables de vista utilizando el método set:
Flight::view()->set('name', 'Bob');
La variable name ahora está disponible en todas sus vistas. Entonces simplemente puede hacer:
name
Flight::render('hello');
Tenga en cuenta que al especificar el nombre de la plantilla en el método render, puede omitir la extensión .php.
.php
Por defecto, Flight buscará un directorio views para los archivos de plantilla. Puede establecer una ruta alternativa para sus plantillas configurando lo siguiente:
views
Flight::set('flight.views.path', '/ruta/a/vistas');
Es común que los sitios web tengan un solo archivo de plantilla de diseño con contenido intercambiable. Para renderizar contenido que se utilizará en un diseño, puede pasar un parámetro opcional al método render.
Flight::render('header', ['heading' => 'Hola'], 'headerContent'); Flight::render('body', ['body' => 'Mundo'], 'bodyContent');
Su vista tendrá variables guardadas llamadas headerContent y bodyContent. Luego puede renderizar su diseño haciendo:
headerContent
bodyContent
Flight::render('layout', ['title' => 'Página de inicio']);
Si los archivos de plantilla se ven así:
header.php:
header.php
<h1><?= $heading ?></h1>
body.php:
body.php
<div><?= $body ?></div>
layout.php:
layout.php
<html> <head> <title><?= $title ?></title> </head> <body> <?= $headerContent ?> <?= $bodyContent ?> </body> </html>
<html> <head> <title>Página de inicio</title> </head> <body> <h1>Hola</h1> <div>Mundo</div> </body> </html>
Flight le permite cambiar el motor de vista predeterminado simplemente registrando su propia clase de vista. Así es como utilizaría el Smarty motor de plantillas para sus vistas:
// Cargar biblioteca Smarty require './Smarty/libs/Smarty.class.php'; // Registrar Smarty como clase de vista // También pase una función de devolución de llamada para configurar Smarty al cargar Flight::register('view', Smarty::class, [], function (Smarty $smarty) { $smarty->setTemplateDir('./templates/'); $smarty->setCompileDir('./templates_c/'); $smarty->setConfigDir('./config/'); $smarty->setCacheDir('./cache/'); }); // Asignar datos de la plantilla Flight::view()->assign('name', 'Bob'); // Mostrar la plantilla Flight::view()->display('hello.tpl');
Por completitud, también debería anular el método de renderizado predeterminado de Flight:
Flight::map('render', function(string $template, array $data): void { Flight::view()->assign($data); Flight::view()->display($template); });
Flight proporciona alguna funcionalidad básica de plantillas de forma predeterminada.
Si necesitas necesidades de plantillas más complejas, consulta los ejemplos de Smarty y Latte en la sección de Vistas Personalizadas.
Para mostrar una plantilla de vista llama al método render con el nombre del archivo de la plantilla y datos de la plantilla opcionales:
Los datos de la plantilla que pasas se inyectan automáticamente en la plantilla y pueden ser referenciados como una variable local. Los archivos de plantilla son simplemente archivos PHP. Si el contenido del archivo de plantilla hello.php es:
También puedes establecer manualmente variables de vista usando el método set:
La variable name está ahora disponible en todas tus vistas. Por lo tanto, simplemente puedes hacer:
Ten en cuenta que al especificar el nombre de la plantilla en el método render, puedes omitir la extensión .php.
Por defecto, Flight buscará un directorio views para archivos de plantilla. Puedes establecer una ruta alternativa para tus plantillas configurando lo siguiente:
Es común que los sitios web tengan un único archivo de plantilla de diseño con contenido intercambiable. Para renderizar contenido que se utilizará en un diseño, puedes pasar un parámetro opcional al método render.
Tu vista tendrá entonces variables guardadas llamadas headerContent y bodyContent. Luego puedes renderizar tu diseño haciendo:
Flight::render('layout', ['title' => 'Página de Inicio']);
Si los archivos de plantilla lucen así:
<html> <head> <title>Página de Inicio</title> </head> <body> <h1>Hola</h1> <div>Mundo</div> </body> </html>
Flight te permite intercambiar el motor de vista predeterminado simplemente registrando tu propia clase de vista.
Así es como usarías el motor de plantillas Smarty para tus vistas:
// Cargar biblioteca de Smarty require './Smarty/libs/Smarty.class.php'; // Registrar Smarty como la clase de vista // También pasa una función de devolución de llamada para configurar Smarty al cargar Flight::register('view', Smarty::class, [], function (Smarty $smarty) { $smarty->setTemplateDir('./templates/'); $smarty->setCompileDir('./templates_c/'); $smarty->setConfigDir('./config/'); }); // Asignar datos de la plantilla Flight::view()->assign('name', 'Bob'); // Mostrar la plantilla Flight::view()->display('hello.tpl');
Para completitud, también deberías sobrescribir el método render predeterminado de Flight:
Así es como usarías el motor de plantillas Latte para tus vistas:
// Registrar Latte como la clase de vista // También pasa una función de devolución de llamada para configurar Latte al cargar Flight::register('view', Latte\Engine::class, [], function (Latte\Engine $laette) { // Aquí es donde Latte almacenará en caché tus plantillas para acelerar las cosas // ¡Algo genial de Latte es que actualiza automáticamente tu caché cuando realizas cambios en tus plantillas! $latte->setTempDirectory(__DIR__ . '/../cache/'); // Indica a Latte dónde estará el directorio raíz para tus vistas. $latte->setLoader(new \Latte\Loaders\FileLoader(__DIR__ . '/../views/')); }); // Y envuélvelo para que puedas usar Flight::render() correctamente Flight::map('render', function(string $template, array $data): void { // Esto es como $latte_engine->render($template, $data); echo Flight::view()->render($template, $data); });
Flight está diseñado para ser un marco extensible. El marco viene con un conjunto de métodos y componentes predeterminados, pero te permite mapear tus propios métodos, registrar tus propias clases, o incluso anular clases y métodos existentes.
Si buscas un DIC (Contenedor de Inyección de Dependencias), ve a la página de Contenedor de Inyección de Dependencias.
Para mapear tu propio método personalizado simple, utiliza la función map:
// Mapea tu método Flight::map('hello', function (string $name) { echo "¡Hola $name!"; }); // Llama a tu método personalizado Flight::hello('Bob');
Esto se utiliza más cuando necesitas pasar variables a tu método para obtener un valor esperado. Usar el método register() como se detalla abajo es más para pasar configuraciones y luego llamar a tu clase preconfigurada.
register()
Para registrar tu propia clase y configurarla, utiliza la función register:
// Registra tu clase Flight::register('user', User::class); // Obtén una instancia de tu clase $user = Flight::user();
El método de registro también te permite pasar parámetros al constructor de tu clase. Entonces cuando cargas tu clase personalizada, vendrá preinicializada. Puedes definir los parámetros del constructor pasando un array adicional. Aquí tienes un ejemplo de carga de una conexión de base de datos:
// Registra clase con parámetros de constructor Flight::register('db', PDO::class, ['mysql:host=localhost;dbname=test', 'user', 'pass']); // Obtén una instancia de tu clase // Esto creará un objeto con los parámetros definidos // // new PDO('mysql:host=localhost;dbname=test','user','pass'); // $db = Flight::db(); // y si lo necesitas más tarde en tu código, simplemente llama al mismo método de nuevo class SomeController { public function __construct() { $this->db = Flight::db(); } }
Si pasas un parámetro de devolución de llamada adicional, se ejecutará inmediatamente después de la construcción de la clase. Esto te permite realizar cualquier procedimiento de configuración para tu nuevo objeto. La función de devolución de llamada recibe un parámetro, una instancia del nuevo objeto.
// La devolución de llamada recibirá el objeto que se construyó Flight::register( 'db', PDO::class, ['mysql:host=localhost;dbname=test', 'user', 'pass'], function (PDO $db) { $db->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION); } );
Por defecto, cada vez que cargas tu clase obtendrás una instancia compartida. Para obtener una nueva instancia de una clase, simplemente pasa false como parámetro:
// Instancia compartida de la clase $compartido = Flight::db(); // Nueva instancia de la clase $nuevo = Flight::db(false);
Ten en cuenta que los métodos mapeados tienen prioridad sobre las clases registradas. Si declaras ambos usando el mismo nombre, solo se invocará el método mapeado.
Flight te permite anular su funcionalidad predeterminada para adaptarla a tus necesidades, sin necesidad de modificar ningún código.
Por ejemplo, cuando Flight no puede hacer coincidir una URL con una ruta, invoca el método notFound que envía una respuesta genérica de HTTP 404. Puedes anular este comportamiento usando el método map:
Flight::map('notFound', function() { // Mostrar página de error 404 personalizada include 'errores/404.html'; });
Flight también te permite reemplazar componentes básicos del marco. Por ejemplo, puedes reemplazar la clase de Enrutador predeterminada con tu propia clase personalizada:
// Registra tu clase personalizada Flight::register('router', MyRouter::class); // Cuando Flight carga la instancia de Enrutador, cargará tu clase $mienrutador = Flight::router();
Sin embargo, los métodos del marco como map y register no pueden ser anulados. Obtendrás un error si intentas hacerlo.
Para solicitudes JSONP, opcionalmente puedes pasar el nombre del parámetro de consulta que estás utilizando para definir tu función de callback:
Entonces, al hacer una solicitud GET usando ?q=my_func, deberías recibir la salida:
?q=my_func
my_func({"id":123});
Si no pasas un nombre de parámetro de consulta, se utilizará por defecto jsonp.
La carga automática es un concepto en PHP donde especificas un directorio o directorios para cargar clases desde. Esto es mucho más beneficioso que usar require o include para cargar clases. También es un requisito para usar paquetes de Composer.
require
include
Por defecto, cualquier clase de Flight se carga automáticamente gracias a Composer. Sin embargo, si deseas cargar tus propias clases, puedes usar el método Flight::path para especificar un directorio desde el cual cargar las clases.
Flight::path
Supongamos que tenemos un árbol de directorios como el siguiente:
# Ejemplo de ruta /home/usuario/proyecto/mi-proyecto-de-flight/ ├── app │ ├── cache │ ├── config │ ├── controllers - contiene los controladores para este proyecto │ ├── translations │ ├── UTILS - contiene clases solo para esta aplicación (esto está en mayúsculas a propósito para un ejemplo posterior) │ └── vistas └── público └── css └── js └── index.php
Puedes especificar cada directorio desde el cual cargar de la siguiente manera:
/** * public/index.php */ // Agregar una ruta al cargador automático Flight::path(__DIR__.'/../app/controllers/'); Flight::path(__DIR__.'/../app/utils/'); /** * app/controllers/MyController.php */ // no se requiere espacio de nombres // Se recomienda que todas las clases cargadas automáticamente sean de tipo Pascal Case (cada palabra en mayúscula, sin espacios) // A partir de la versión 3.7.2, puedes utilizar Pascal_Snake_Case para los nombres de tus clases ejecutando Loader::setV2ClassLoading(false); class MyController { public function index() { // hacer algo } }
Si tienes espacios de nombres, en realidad se vuelve muy fácil de implementar. Debes usar el método Flight::path() para especificar el directorio raíz (no el directorio de documentos raíz o la carpeta público/) de tu aplicación.
Flight::path()
público/
/** * public/index.php */ // Agregar una ruta al cargador automático Flight::path(__DIR__.'/../');
Así es como podría verse tu controlador. Observa el ejemplo a continuación, pero presta atención a los comentarios para obtener información importante.
/** * app/controllers/MyController.php */ // se requieren espacios de nombres // los espacios de nombres son iguales a la estructura de directorios // los espacios de nombres deben seguir la misma estructura de mayúsculas y minúsculas que la de los directorios // los espacios de nombres y directorios no pueden tener guiones bajos (a menos que se establezca Loader::setV2ClassLoading(false)) namespace app\controllers; // Se recomienda que todas las clases cargadas automáticamente sean de tipo Pascal Case (cada palabra en mayúscula, sin espacios) // A partir de la versión 3.7.2, puedes utilizar Pascal_Snake_Case para los nombres de tus clases ejecutando Loader::setV2ClassLoading(false); class MyController { public function index() { // hacer algo } }
Y si deseas cargar automáticamente una clase en tu directorio utils, harías básicamente lo mismo:
utils
/** * app/UTILS/ArrayHelperUtil.php */ // el espacio de nombres debe coincidir con la estructura y mayúsculas/minúsculas del directorio (nota que el directorio UTILS está todo en mayúsculas // como en el árbol de archivos anterior) namespace app\UTILS; class ArrayHelperUtil { public function changeArrayCase(array $array) { // hacer algo } }
A partir de la versión 3.7.2, puedes usar Pascal_Snake_Case para los nombres de tus clases ejecutando Loader::setV2ClassLoading(false);. Esto te permitirá usar guiones bajos en los nombres de tus clases. Esto no se recomienda, pero está disponible para aquellos que lo necesiten.
Loader::setV2ClassLoading(false);
/** * public/index.php */ // Agregar una ruta al cargador automático Flight::path(__DIR__.'/../app/controllers/'); Flight::path(__DIR__.'/../app/utils/'); Loader::setV2ClassLoading(false); /** * app/controllers/My_Controller.php */ // no se requiere espacio de nombres class My_Controller { public function index() { // hacer algo } }
Esta página te ayudará a solucionar problemas comunes que puedas encontrar al usar Flight.
Si estás viendo un error 404 No Encontrado (pero juras por tu vida que realmente está allí y no es un error tipográfico) esto podría ser en realidad un problema con que estás devolviendo un valor en el punto final de tu ruta en lugar de simplemente emitirlo. La razón de esto es intencional pero podría sorprender a algunos desarrolladores.
Flight::route('/hello', function(){ // Esto podría causar un error 404 No Encontrado return 'Hola Mundo'; }); // Lo que probablemente deseas Flight::route('/hello', function(){ echo 'Hola Mundo'; });
La razón de esto es debido a un mecanismo especial incorporado en el enrutador que maneja la salida de retorno como una señal de "ir a la siguiente ruta". Puedes ver el comportamiento documentado en la sección de Enrutamiento.
Si estás utilizando Composer, puedes ejecutar el siguiente comando:
composer require flightphp/core
O puedes descargar los archivos directamente y extraerlos en tu directorio web.
Para Apache, edita tu archivo .htaccess con lo siguiente:
.htaccess
RewriteEngine On RewriteCond %{REQUEST_FILENAME} !-f RewriteCond %{REQUEST_FILENAME} !-d RewriteRule ^(.*)$ index.php [QSA,L]
Nota: Si necesitas usar flight en un subdirectorio, añade la línea RewriteBase /subdir/ justo después de RewriteEngine On. Nota: Si deseas proteger todos los archivos del servidor, como un archivo de base de datos o env. Agrega esto en tu archivo .htaccess:
Nota: Si necesitas usar flight en un subdirectorio, añade la línea RewriteBase /subdir/ justo después de RewriteEngine On.
RewriteBase /subdir/
RewriteEngine On
Nota: Si deseas proteger todos los archivos del servidor, como un archivo de base de datos o env. Agrega esto en tu archivo .htaccess:
RewriteEngine On RewriteRule ^(.*)$ index.php
Para Nginx, agrega lo siguiente a la declaración de tu servidor:
server { location / { try_files $uri $uri/ /index.php; } }
<?php // Si estás utilizando Composer, requiere el cargador automático. require 'vendor/autoload.php'; // si no estás utilizando Composer, carga el framework directamente // require 'flight/Flight.php'; // Luego define una ruta y asigna una función para manejar la solicitud. Flight::route('/', function () { echo '¡Hola Mundo!'; }); // Finalmente, inicia el framework. Flight::start();
========================
Derechos de autor © 2023 @mikecao, @n0nag0n
2023
@mikecao, @n0nag0n
Se concede permiso, de forma gratuita, a cualquier persona que obtenga una copia de este software y documentación asociada (los “Software”), para tratar el Software sin restricciones, incluidos, entre otros, los derechos de usar, copiar, modificar, fusionar, publicar, distribuir, sublicenciar y/o vender copias del Software, y para permitir a las personas a las que se les proporcione el Software que lo hagan, sujetas a las siguientes condiciones:
El aviso de derechos de autor anterior y este aviso de permiso deberán incluirse en todas las copias o partes sustanciales del Software.
EL SOFTWARE SE SUMINISTRA "TAL CUAL", SIN GARANTÍA DE NINGÚN TIPO, EXPRESA O IMPLÍCITA, INCLUYENDO, PERO SIN LIMITARSE A, LAS GARANTÍAS DE COMERCIALIZACIÓN, ADECUACIÓN PARA UN PROPÓSITO PARTICULAR Y NO INFRACCIÓN. EN NINGÚN CASO LOS AUTORES O TITULARES DE DERECHOS DE AUTOR SERÁN RESPONSABLES DE NINGUNA RECLAMACIÓN, DAÑOS U OTRA RESPONSABILIDAD, YA SEA EN UNA ACCIÓN DE CONTRATO, AGRAVIO O DE OTRO MODO, DERIVADA DE, FUERA DE O EN CONEXIÓN CON EL SOFTWARE O EL USO U OTROS TRATOS EN EL SOFTWARE.
Flight es un framework rápido, simple y extensible para PHP. Es bastante versátil y se puede utilizar para construir cualquier tipo de aplicación web. Está diseñado con simplicidad en mente y está escrito de una manera que es fácil de entender y usar.
Flight es un excelente framework para principiantes que son nuevos en PHP y desean aprender a construir aplicaciones web. También es un gran framework para desarrolladores experimentados que desean tener más control sobre sus aplicaciones web. Está diseñado para construir fácilmente una API RESTful, una aplicación web simple o una aplicación web compleja.
<?php // si está instalado con composer require 'vendor/autoload.php'; // o si está instalado manualmente por archivo zip // require 'flight/Flight.php'; Flight::route('/', function() { echo '¡Hola Mundo!'; }); Flight::route('/json', function() { Flight::json(['hello' => 'world']); }); Flight::start();
¿Sencillo, verdad? ¡Aprende más sobre Flight en la documentación!
Hay una aplicación de ejemplo que puede ayudarte a empezar con el Framework Flight. ¡Ve a flightphp/skeleton para obtener instrucciones sobre cómo empezar! También puedes visitar la página de ejemplos para inspirarte en algunas de las cosas que puedes hacer con Flight.
¡Estamos en Matrix! Chatea con nosotros en #flight-php-framework:matrix.org.
Hay dos maneras en las que puedes contribuir a Flight:
Flight requiere PHP 7.4 o superior.
Nota: Se admite PHP 7.4 porque en el momento actual de la escritura (2024) PHP 7.4 es la versión predeterminada para algunas distribuciones de Linux LTS. Forzar un cambio a PHP >8 causaría muchos dolores de cabeza a esos usuarios. El framework también soporta PHP >8.
Flight se publica bajo la licencia MIT.
overclokk/cookie es una biblioteca sencilla para administrar cookies dentro de su aplicación.
La instalación es sencilla con composer.
composer require overclokk/cookie
El uso es tan simple como registrar un nuevo método en la clase Flight.
use Overclokk\Cookie\Cookie; /* * Establezca en su archivo bootstrap o public/index.php */ Flight::register('cookie', Cookie::class); /** * ExampleController.php */ class ExampleController { public function login() { // Establecer una cookie // querrás que esto sea falso para obtener una nueva instancia // usa el comentario a continuación si deseas el autocompletado /** @var \Overclokk\Cookie\Cookie $cookie */ $cookie = Flight::cookie(false); $cookie->set( 'stay_logged_in', // nombre de la cookie '1', // el valor que deseas establecer 86400, // número de segundos que la cookie debe durar '/', // ruta en la que estará disponible la cookie 'example.com', // dominio en el que estará disponible la cookie true, // la cookie solo se transmitirá a través de una conexión segura HTTPS true // la cookie solo estará disponible a través del protocolo HTTP ); // opcionalmente, si deseas mantener los valores predeterminados // y tener una forma rápida de establecer una cookie por mucho tiempo $cookie->forever('stay_logged_in', '1'); } public function home() { // Verifica si tienes la cookie if (Flight::cookie()->has('stay_logged_in')) { // ponlos en el área del panel, por ejemplo. Flight::redirect('/dashboard'); } } }
defuse/php-encryption es una biblioteca que se puede utilizar para cifrar y descifrar datos. Ponerse en marcha es bastante simple para comenzar a cifrar y descifrar datos. Tienen un excelente tutorial que ayuda a explicar los conceptos básicos sobre cómo utilizar la biblioteca, así como las importantes implicaciones de seguridad relacionadas con el cifrado.
composer require defuse/php-encryption
Luego necesitarás generar una clave de cifrado.
vendor/bin/generate-defuse-key
Esto generará una clave que deberás mantener segura. Podrías guardar la clave en tu archivo app/config/config.php en el array al final del archivo. Aunque no es el lugar perfecto, al menos es algo.
app/config/config.php
Ahora que tienes la biblioteca y una clave de cifrado, puedes empezar a cifrar y descifrar datos.
use Defuse\Crypto\Crypto; use Defuse\Crypto\Key; /* * Establecerlo en tu archivo de inicio (bootstrap) o public/index.php */ // Método de cifrado Flight::map('encrypt', function($datos_crudos) { $clave_cifrado = /* $config['clave_cifrado'] o un file_get_contents de dónde pusiste la clave */; return Crypto::encrypt($datos_crudos, Key::loadFromAsciiSafeString($clave_cifrado)); }); // Método de descifrado Flight::map('decrypt', function($datos_cifrados) { $clave_cifrado = /* $config['clave_cifrado'] o un file_get_contents de dónde pusiste la clave */; try { $datos_crudos = Crypto::decrypt($datos_cifrados, Key::loadFromAsciiSafeString($clave_cifrado)); } catch (Defuse\Crypto\Exception\WrongKeyOrModifiedCiphertextException $ex) { // ¡Un ataque! Se cargó la clave incorrecta o el texto cifrado // ha cambiado desde que fue creado, ya sea corrompido en la base de datos o modificado intencionalmente por Eve tratando de llevar a cabo un ataque. // ... manejar este caso de una manera adecuada para tu aplicación ... } return $datos_crudos; }); Flight::route('/cifrar', function() { $datos_cifrados = Flight::encrypt('Esto es un secreto'); echo $datos_cifrados; }); Flight::route('/descifrar', function() { $datos_cifrados = '...'; // Obtener los datos cifrados de algún lugar $datos_descifrados = Flight::decrypt($datos_cifrados); echo $datos_descifrados; });
Clase de almacenamiento en caché de PHP en archivo ligera, simple y independiente
Ventajas
Instalar a través de composer:
composer require wruczek/php-file-cache
El uso es bastante sencillo.
use Wruczek\PhpFileCache\PhpFileCache; $app = Flight::app(); // Pasa el directorio en el que se almacenará la caché al constructor $app->register('cache', PhpFileCache::class, [ __DIR__ . '/../cache/' ], function(PhpFileCache $cache) { // Esto asegura que la caché solo se use en modo de producción // ENVIRONMENT es una constante que se establece en tu archivo de inicio o en otro lugar de tu aplicación $cache->setDevMode(ENVIRONMENT === 'development'); });
Luego puedes usarlo en tu código de la siguiente manera:
// Obtener instancia de caché $cache = Flight::cache(); $data = $cache->refreshIfExpired('simple-cache-test', function () { return date("H:i:s"); // devolver datos para ser almacenados en caché }, 10); // 10 segundos // o $data = $cache->retrieve('simple-cache-test'); if(empty($data)) { $data = date("H:i:s"); $cache->store('simple-cache-test', $data, 10); // 10 segundos }
Visita https://github.com/Wruczek/PHP-File-Cache para ver la documentación completa y asegúrate de ver la carpeta de ejemplos.
Flight es increíblemente extensible. Hay varios complementos que se pueden utilizar para añadir funcionalidad a tu aplicación Flight. Algunos son oficialmente compatibles con el Equipo de Flight y otros son bibliotecas micro/lite para ayudarte a comenzar.
La caché es una excelente manera de acelerar tu aplicación. Hay varias bibliotecas de caché que se pueden utilizar con Flight.
La depuración es crucial cuando estás desarrollando en tu entorno local. Hay algunos complementos que pueden mejorar tu experiencia de depuración.
Las bases de datos son el núcleo de la mayoría de las aplicaciones. Así es como almacenas y recuperas datos. Algunas bibliotecas de bases de datos son simplemente envoltorios para escribir consultas y otras son ORM completos.
Las sesiones no son realmente útiles para las API, pero para desarrollar una aplicación web, las sesiones pueden ser cruciales para mantener el estado e información de inicio de sesión.
Las plantillas son esenciales para cualquier aplicación web con un UI. Hay varios motores de plantillas que se pueden utilizar con Flight.
¿Tienes un complemento que te gustaría compartir? ¡Envía una solicitud de extracción para añadirlo a la lista!
Flight viene con una clase de ayuda para PDO. Le permite consultar fácilmente su base de datos con toda la locura de preparar/ejecutar/obtenerTodo(). Simplifica en gran medida cómo puede consultar su base de datos. Cada resultado de fila se devuelve como una clase Flight Collection que le permite acceder a sus datos mediante la sintaxis de matriz o la sintaxis de objeto.
// Registrar la clase de ayuda PDO Flight::register('db', \flight\database\PdoWrapper::class, ['mysql:host=localhost;dbname=cool_db_name', 'usuario', 'contraseña', [ PDO::MYSQL_ATTR_INIT_COMMAND => 'SET NAMES \'utf8mb4\'', PDO::ATTR_EMULATE_PREPARES => false, PDO::ATTR_STRINGIFY_FETCHES => false, PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC ] ]);
Este objeto extiende PDO, por lo que todos los métodos normales de PDO están disponibles. Los siguientes métodos se agregan para facilitar la consulta a la base de datos:
runQuery(string $sql, array $params = []): PDOStatement
Úselo para INSERTS, UPDATES o si planea usar un SELECT en un bucle while
$db = Flight::db(); $statement = $db->runQuery("SELECT * FROM table WHERE something = ?", [ $algo ]); while($row = $statement->fetch()) { // ... } // O escribir en la base de datos $db->runQuery("INSERT INTO table (nombre) VALUES (?)", [ $nombre ]); $db->runQuery("UPDATE table SET nombre = ? WHERE id = ?", [ $nombre, $id ]);
fetchField(string $sql, array $params = []): mixed
Extrae el primer campo de la consulta
$db = Flight::db(); $count = $db->fetchField("SELECT COUNT(*) FROM table WHERE something = ?", [ $algo ]);
fetchRow(string $sql, array $params = []): array
Extrae una fila de la consulta
$db = Flight::db(); $row = $db->fetchRow("SELECT id, nombre FROM table WHERE id = ?", [ $id ]); echo $row['nombre']; // o echo $row->nombre;
fetchAll(string $sql, array $params = []): array
Extrae todas las filas de la consulta
$db = Flight::db(); $rows = $db->fetchAll("SELECT id, nombre FROM table WHERE something = ?", [ $algo ]); foreach($rows as $row) { echo $row['nombre']; // o echo $row->nombre; }
IN()
Esto también tiene un envoltorio útil para las declaraciones IN(). Simplemente puede pasar un signo de interrogación como marcador de posición para IN() y luego un array de valores. Aquí hay un ejemplo de cómo podría verse eso:
$db = Flight::db(); $nombre = 'Bob'; $ids_compañía = [1,2,3,4,5]; $rows = $db->fetchAll("SELECT id, nombre FROM table WHERE nombre = ? AND company_id IN (?)", [ $nombre, $ids_compañía ]);
// Ruta de ejemplo y cómo usar este envoltorio Flight::route('/usuarios', function () { // Obtener todos los usuarios $usuarios = Flight::db()->fetchAll('SELECT * FROM users'); // Transmitir todos los usuarios $declaración = Flight::db()->runQuery('SELECT * FROM users'); while ($usuario = $declaración->fetch()) { echo $usuario['nombre']; // o echo $usuario->nombre; } // Obtener un usuario único $usuario = Flight::db()->fetchRow('SELECT * FROM users WHERE id = ?', [123]); // Obtener un valor único $count = Flight::db()->fetchField('SELECT COUNT(*) FROM users'); // Sintaxis especial de IN() para ayudar (asegúrese de que IN esté en mayúsculas) $usuarios = Flight::db()->fetchAll('SELECT * FROM users WHERE id IN (?)', [[1,2,3,4,5]]); // también se podría hacer esto $usuarios = Flight::db()->fetchAll('SELECT * FROM users WHERE id IN (?)', [ '1,2,3,4,5']); // Insertar un nuevo usuario Flight::db()->runQuery("INSERT INTO users (nombre, email) VALUES (?, ?)", ['Bob', 'bob@example.com']); $id_insertado = Flight::db()->lastInsertId(); // Actualizar un usuario Flight::db()->runQuery("UPDATE users SET nombre = ? WHERE id = ?", ['Bob', 123]); // Eliminar un usuario Flight::db()->runQuery("DELETE FROM users WHERE id = ?", [123]); // Obtener el número de filas afectadas $declaración = Flight::db()->runQuery("UPDATE users SET nombre = ? WHERE nombre = ?", ['Bob', 'Sally']); $filas_afectadas = $declaración->rowCount(); });
Administrador de Sesiones PHP (sin bloqueo, flash, segmento, cifrado de sesión). Utiliza PHP open_ssl para cifrar/descifrar opcionalmente los datos de sesión. Admite File, MySQL, Redis y Memcached.
Instalar con composer.
composer require ghostff/session
No es necesario pasar nada para usar la configuración predeterminada con su sesión. Puede leer sobre más configuraciones en el Readme de Github.
use Ghostff\Session\Session; require 'vendor/autoload.php'; $app = Flight::app(); $app->register('session', Session::class); // una cosa a recordar es que debes confirmar tu sesión en cada carga de página // o necesitarás ejecutar auto_commit en tu configuración.
Aquí tienes un ejemplo simple de cómo podrías usar esto.
Flight::route('POST /login', function() { $session = Flight::session(); // haz tu lógica de inicio de sesión aquí // valida la contraseña, etc. // si el inicio de sesión es exitoso $session->set('is_logged_in', true); $session->set('user', $user); // cada vez que escribas en la sesión, debes confirmarlo deliberadamente. $session->commit(); }); // Esta verificación podría estar en la lógica de la página restringida, o envuelta con middleware. Flight::route('/alguna-página-restringida', function() { $session = Flight::session(); if(!$session->get('is_logged_in')) { Flight::redirect('/login'); } // haz tu lógica de página restringida aquí }); // la versión del middleware Flight::route('/alguna-página-restringida', function() { // lógica regular de la página })->addMiddleware(function() { $session = Flight::session(); if(!$session->get('is_logged_in')) { Flight::redirect('/login'); } });
Aquí tienes un ejemplo más complejo de cómo podrías usar esto.
use Ghostff\Session\Session; require 'vendor/autoload.php'; $app = Flight::app(); // establece una ruta personalizada a tu archivo de configuración de sesión y dale una cadena aleatoria para el id de sesión $app->register('session', Session::class, [ 'ruta/hacia/session_config.php', bin2hex(random_bytes(32)) ], function(Session $session) { // o puedes anular manualmente las opciones de configuración $session->updateConfiguration([ // si deseas almacenar tus datos de sesión en una base de datos (útil si deseas algo como funcionalidad de "cerrar sesión en todos los dispositivos") Session::CONFIG_DRIVER => Ghostff\Session\Drivers\MySql::class, Session::CONFIG_ENCRYPT_DATA => true, Session::CONFIG_SALT_KEY => hash('sha256', 'mi-súper-S3GR3T-salt'), // cambia esto a algo diferente Session::CONFIG_AUTO_COMMIT => true, // haz esto solo si es necesario y/o es difícil confirmar() tu sesión. // además podrías hacer Flight::after('start', function() { Flight::session()->commit(); }); Session::CONFIG_MYSQL_DS => [ 'driver' => 'mysql', # Controlador de base de datos para PDO dns ej(mysql:host=...;dbname=...) 'host' => '127.0.0.1', # Host de la base de datos 'db_name' => 'mi_base_de_datos_app', # Nombre de la base de datos 'db_table' => 'sesiones', # Tabla de la base de datos 'db_user' => 'root', # Nombre de usuario de la base de datos 'db_pass' => '', # Contraseña de la base de datos 'persistent_conn'=> false, # Evita el costo de establecer una nueva conexión cada vez que un script necesita comunicarse con una base de datos, lo que resulta en una aplicación web más rápida. ENCUENTRA EL LADO NEGATIVO TÚ MISMO ] ]); } );
¿Estás estableciendo tus datos de sesión y no se mantienen entre solicitudes? Es posible que hayas olvidado confirmar tus datos de sesión. Puedes hacer esto llamando a $session->commit() después de haber establecido tus datos de sesión.
$session->commit()
Flight::route('POST /login', function() { $session = Flight::session(); // haz tu lógica de inicio de sesión aquí // valida la contraseña, etc. // si el inicio de sesión es exitoso $session->set('is_logged_in', true); $session->set('user', $user); // cada vez que escribas en la sesión, debes confirmarlo deliberadamente. $session->commit(); });
La otra forma de solucionar esto es cuando configuras tu servicio de sesión, debes establecer auto_commit en true en tu configuración. Esto confirmará automáticamente tus datos de sesión después de cada solicitud.
auto_commit
$app->register('session', Session::class, [ 'ruta/hacia/session_config.php', bin2hex(random_bytes(32)) ], function(Session $session) { $session->updateConfiguration([ Session::CONFIG_AUTO_COMMIT => true, ]); } );
Además podrías hacer Flight::after('start', function() { Flight::session()->commit(); }); para confirmar tus datos de sesión después de cada solicitud.
Flight::after('start', function() { Flight::session()->commit(); });
Visita el Readme de Github para ver la documentación completa. Las opciones de configuración están bien documentadas en default_config.php en sí. El código es fácil de entender si deseas inspeccionar este paquete tú mismo.
Pista es una aplicación CLI que te ayuda a gestionar tus aplicaciones Flight. Puede generar controladores, mostrar todas las rutas y más. Está basado en la excelente biblioteca adhocore/php-cli.
Instala con composer.
composer require flightphp/runway
La primera vez que ejecutes Pista, te guiará a través de un proceso de configuración y creará un archivo de configuración .runway.json en la raíz de tu proyecto. Este archivo contendrá algunas configuraciones necesarias para que Pista funcione correctamente.
.runway.json
Pista tiene varios comandos que puedes utilizar para gestionar tu aplicación Flight. Hay dos formas fáciles de usar Pista.
php runway [comando]
vendor/bin/runway [comando]
Para cualquier comando, puedes agregar la bandera --help para obtener más información sobre cómo usar el comando.
--help
php runway routes --help
Aquí tienes algunos ejemplos:
Basado en la configuración en tu archivo .runway.json, la ubicación predeterminada generará un controlador para ti en el directorio app/controllers/.
app/controllers/
php runway make:controller MyController
Basado en la configuración en tu archivo .runway.json, la ubicación predeterminada generará un controlador para ti en el directorio app/records/.
app/records/
php runway make:record users
Si por ejemplo tienes la tabla users con el esquema siguiente: id, name, email, created_at, updated_at, se creará un archivo similar al siguiente en el archivo app/records/UserRecord.php:
users
email
created_at
updated_at
app/records/UserRecord.php
<?php declare(strict_types=1); namespace app\records; /** * Clase ActiveRecord para la tabla de usuarios. * @link https://docs.flightphp.com/awesome-plugins/active-record * * @property int $id * @property string $name * @property string $email * @property string $created_at * @property string $updated_at */ class UserRecord extends \flight\ActiveRecord { /** * @var array $relations Establece las relaciones para el modelo * https://docs.flightphp.com/awesome-plugins/active-record#relationships */ protected array $relations = []; /** * Constructor * @param mixed $databaseConnection La conexión a la base de datos */ public function __construct($databaseConnection) { parent::__construct($databaseConnection, 'users'); } }
Esto mostrará todas las rutas que están actualmente registradas con Flight.
php runway routes
Si deseas ver solo rutas específicas, puedes agregar una bandera para filtrar las rutas.
# Mostrar solo rutas GET php runway routes --get # Mostrar solo rutas POST php runway routes --post # etc.
Si estás creando un paquete para Flight, o deseas agregar tus propios comandos personalizados en tu proyecto, puedes hacerlo creando un directorio src/commands/, flight/commands/, app/commands/ o commands/ para tu proyecto/paquete.
src/commands/
flight/commands/
app/commands/
commands/
Para crear un comando, simplemente extiende la clase AbstractBaseCommand e implementa como mínimo un método __construct y un método execute.
AbstractBaseCommand
__construct
execute
<?php declare(strict_types=1); namespace flight\commands; class ExampleCommand extends AbstractBaseCommand { /** * Constructor * * @param array<string,mixed> $config Configuración JSON de .runway-config.json */ public function __construct(array $config) { parent::__construct('make:example', 'Crear un ejemplo para la documentación', $config); $this->argument('<funny-gif>', 'El nombre del gif divertido'); } /** * Ejecuta la función * * @return void */ public function execute(string $controller) { $io = $this->app()->io(); $io->info('Creando ejemplo...'); // Haz algo aquí $io->ok('¡Ejemplo creado!'); } }
Consulta la Documentación de adhocore/php-cli para obtener más información sobre cómo crear tus propios comandos personalizados en tu aplicación Flight!
Este es un conjunto de extensiones para enriquecer un poco el trabajo con Flight.
$_GET
$_POST
$_FILES
$_SESSION
Este es el Panel
¡Y cada panel muestra información muy útil sobre tu aplicación!
Ejecuta composer require flightphp/tracy-extensions --dev ¡y estás listo para comenzar!
composer require flightphp/tracy-extensions --dev
Hay muy poca configuración que necesitas hacer para comenzar. Debes iniciar el depurador de Tracy antes de usar esto https://tracy.nette.org/en/guide:
<?php use Tracy\Debugger; use flight\debug\tracy\TracyExtensionLoader; // código de inicio require __DIR__ . '/vendor/autoload.php'; Debugger::enable(); // Puede que necesites especificar tu entorno con Debugger::enable(Debugger::DEVELOPMENT) // si utilizas conexiones de base de datos en tu aplicación, hay // un envoltorio PDO necesario para usar SOLO EN DESARROLLO (¡no en producción por favor!) // Tiene los mismos parámetros que una conexión PDO regular $pdo = new PdoQueryCapture('sqlite:test.db', 'user', 'pass'); // o si adjuntas esto al framework Flight Flight::register('db', PdoQueryCapture::class, ['sqlite:test.db', 'user', 'pass']); // ahora cada vez que hagas una consulta capturará la hora, la consulta y los parámetros // Esto conecta los puntos if(Debugger::$showBar === true) { // Esto debe ser false o Tracy no puede renderizar correctamente :( Flight::set('flight.content_length', false); new TracyExtensionLoader(Flight::app()); } // más código Flight::start();
Si tienes un controlador de sesión personalizado (como ghostff/session), puedes pasar cualquier matriz de datos de sesión a Tracy y automáticamente los mostrará. Puedes pasarlos con la clave session_data en el segundo parámetro del constructor de TracyExtensionLoader.
session_data
TracyExtensionLoader
use Ghostff\Session\Session; require 'vendor/autoload.php'; $app = Flight::app(); $app->register('session', Session::class); if(Debugger::$showBar === true) { // Esto debe ser false o Tracy no puede renderizar correctamente :( Flight::set('flight.content_length', false); new TracyExtensionLoader(Flight::app(), [ 'session_data' => Flight::session()->getAll() ]); } // rutas y otras cosas... Flight::start();
Si tienes Latte instalado en tu proyecto, puedes usar el panel de Latte para analizar tus plantillas. Puedes pasar la instancia de Latte al constructor de TracyExtensionLoader con la clave latte en el segundo parámetro.
latte
use Latte\Engine; require 'vendor/autoload.php'; $app = Flight::app(); $app->register('latte', Engine::class, [], function($latte) { $latte->setTempDirectory(__DIR__ . '/temp'); // aquí es donde agregas el Panel de Latte a Tracy $latte->addExtension(new Latte\Bridges\Tracy\TracyExtension); }); if(Debugger::$showBar === true) { // Esto debe ser false o Tracy no puede renderizar correctamente :( Flight::set('flight.content_length', false); new TracyExtensionLoader(Flight::app()); }
Tracy es un increíble manejador de errores que se puede utilizar con Flight. Tiene una serie de paneles que pueden ayudarte a depurar tu aplicación. También es muy fácil de extender y agregar tus propios paneles. El equipo de Flight ha creado algunos paneles específicamente para proyectos de Flight con el complemento flightphp/tracy-extensions.
Instala con composer. Y realmente querrás instalar esto sin la versión de desarrollo ya que Tracy viene con un componente de manejo de errores de producción.
composer require tracy/tracy
Hay algunas opciones de configuración básicas para comenzar. Puedes leer más sobre ellas en la Documentación de Tracy.
require 'vendor/autoload.php'; use Tracy\Debugger; // Habilitar Tracy Debugger::enable(); // Debugger::enable(Debugger::DEVELOPMENT) // a veces tienes que ser explícito (también Debugger::PRODUCTION) // Debugger::enable('23.75.345.200'); // también puedes proporcionar una matriz de direcciones IP // Aquí es donde se registrarán los errores y excepciones. Asegúrate de que este directorio exista y sea escribible. Debugger::$logDirectory = __DIR__ . '/../log/'; Debugger::$strictMode = true; // mostrar todos los errores // Debugger::$strictMode = E_ALL & ~E_DEPRECATED & ~E_USER_DEPRECATED; // todos los errores excepto avisos obsoletos if (Debugger::$showBar) { $app->set('flight.content_length', false); // si la barra Debugger es visible, entonces la longitud del contenido no puede ser establecida por Flight // Esto es específico para la Extensión de Tracy para Flight si la has incluido // de lo contrario, comenta esto. new TracyExtensionLoader($app); }
Cuando estés depurando tu código, hay algunas funciones muy útiles para mostrar datos para ti.
bdump($var)
dumpe($var)
Un active record está mapeando una entidad de la base de datos a un objeto PHP. Hablando claramente, si tienes una tabla de usuarios en tu base de datos, puedes "traducir" una fila de esa tabla a una clase User y un objeto $user en tu código base. Consulta ejemplo básico.
User
$user
Vamos a asumir que tienes la siguiente tabla:
CREATE TABLE users ( id INTEGER PRIMARY KEY, name TEXT, password TEXT );
Ahora puedes configurar una nueva clase para representar esta tabla:
/** * Una clase ActiveRecord suele ser singular * * Es muy recomendable añadir las propiedades de la tabla como comentarios aquí * * @property int $id * @property string $name * @property string $password */ class User extends flight\ActiveRecord { public function __construct($database_connection) { // puedes configurarlo de esta manera parent::__construct($database_connection, 'users'); // o de esta manera parent::__construct($database_connection, null, [ 'table' => 'users']); } }
¡Ahora observa cómo ocurre la magia!
// para sqlite $database_connection = new PDO('sqlite:test.db'); // esto es solo un ejemplo, probablemente usarías una conexión a base de datos real // para mysql $database_connection = new PDO('mysql:host=localhost;dbname=test_db&charset=utf8bm4', 'nombre_usuario', 'contraseña'); // o mysqli $database_connection = new mysqli('localhost', 'nombre_usuario', 'contraseña', 'test_db'); // o mysqli con creación no basada en objetos $database_connection = mysqli_connect('localhost', 'nombre_usuario', 'contraseña', 'test_db'); $user = new User($database_connection); $user->name = 'Bobby Tables'; $user->password = password_hash('una contraseña genial'); $user->insert(); // o $user->save(); echo $user->id; // 1 $user->name = 'Joseph Mamma'; $user->password = password_hash('¡otra contraseña genial!'); $user->insert(); // ¡no puedes usar $user->save() aquí, o pensará que es una actualización! echo $user->id; // 2
¡Y así de fácil fue agregar un nuevo usuario! Ahora que hay una fila de usuario en la base de datos, ¿cómo la extraes?
$user->find(1); // encuentra id = 1 en la base de datos y devuélvelo. echo $user->name; // 'Bobby Tables'
¿Y si quieres encontrar todos los usuarios?
$users = $user->findAll();
¿Qué pasa con una condición específica?
$users = $user->like('name', '%mamma%')->findAll();
¡Mira lo divertido que es esto! ¡Instalémoslo y empecemos!
Simplemente instálalo con Composer
composer require flightphp/active-record
Esto puede ser usado como una biblioteca independiente o con el Framework PHP Flight. Completamente depende de ti.
Solo asegúrate de pasar una conexión PDO al constructor.
$pdo_connection = new PDO('sqlite:test.db'); // esto es solo un ejemplo, probablemente usarías una conexión a base de datos real $User = new User($pdo_connection);
Si estás utilizando el Framework PHP Flight, puedes registrar la clase ActiveRecord como un servicio (pero honestamente no es necesario).
Flight::register('user', 'User', [ $pdo_connection ]); // luego puedes usarlo de esta manera en un controlador, una función, etc. Flight::user()->find(1);
find($id = null) : boolean|ActiveRecord
Encuentra un registro y asígnalo al objeto actual. Si pasas un $id de algún tipo, realizará una búsqueda en la clave principal con ese valor. Si no se pasa nada, solo encontrará el primer registro en la tabla.
Además, puedes pasarle otros métodos auxiliares para consultar tu tabla.
// encuentra un registro con algunas condiciones previamente $user->notNull('password')->orderBy('id DESC')->find(); // encuentra un registro por un id específico $id = 123; $user->find($id);
findAll(): array<int,ActiveRecord>
Encuentra todos los registros en la tabla que especificas.
$user->findAll();
isHydrated(): boolean
Devuelve true si el registro actual ha sido hidratado (recuperado de la base de datos).
$user->find(1); // si se encuentra un registro con datos... $user->isHydrated(); // true
insert(): boolean|ActiveRecord
Inserta el registro actual en la base de datos.
$user = new User($pdo_connection); $user->name = 'demo'; $user->password = md5('demo'); $user->insert();
Si tienes una clave primaria basada en texto (como un UUID), puedes establecer el valor de la clave primaria antes de insertarla de dos maneras.
$user = new User($pdo_connection, [ 'primaryKey' => 'uuid' ]); $user->uuid = 'algún-uuid'; $user->name = 'demo'; $user->password = md5('demo'); $user->insert(); // o $user->save();
o puedes generar la clave primaria automáticamente a través de eventos.
class User extends flight\ActiveRecord { public function __construct($database_connection) { parent::__construct($database_connection, 'users', [ 'primaryKey' => 'uuid' ]); // también puedes establecer la clave primaria de esta manera en lugar del array anterior. $this->primaryKey = 'uuid'; } protected function beforeInsert(self $self) { $self->uuid = uniqid(); // o como necesites generar tus ids únicos } }
Si no estableces la clave primaria antes de insertar, se establecerá en el rowid y la base de datos la generará por ti, pero no persistirá porque ese campo puede que no exista en tu tabla. Por esto se recomienda usar el evento para manejar esto automáticamente.
rowid
update(): boolean|ActiveRecord
Actualiza el registro actual en la base de datos.
$user->greaterThan('id', 0)->orderBy('id desc')->find(); $user->email = 'test@example.com'; $user->update();
save(): boolean|ActiveRecord
Inserta o actualiza el registro actual en la base de datos. Si el registro tiene un id, se actualizará, de lo contrario se insertará.
$user = new User($pdo_connection); $user->name = 'demo'; $user->password = md5('demo'); $user->save();
Nota: Si tienes relaciones definidas en la clase, guardará recursivamente esas relaciones también si han sido definidas, instanciadas y tienen datos sucios para actualizar. (v0.4.0 y superior)
delete(): boolean
Elimina el registro actual de la base de datos.
$user->gt('id', 0)->orderBy('id desc')->find(); $user->delete();
También puedes eliminar varios registros ejecutando una búsqueda previa.
$user->like('name', 'Bob%')->delete();
dirty(array $dirty = []): ActiveRecord
Datos "sucios" se refiere a los datos que han cambiado en un registro.
$user->greaterThan('id', 0)->orderBy('id desc')->find(); // nada está "sucio" hasta este momento. $user->email = 'test@example.com'; // ahora el correo electrónico se considera "sucio" porque ha cambiado. $user->update(); // ahora no hay datos sucios porque se han actualizado y persistido en la base de datos $user->password = password_hash()'nuevacontraseña'); // ahora esto está sucio $user->dirty(); // al pasar nada se borrarán todas las entradas sucias. $user->update(); // nada se actualizará porque nada se capturó como sucio. $user->dirty([ 'name' => 'algo', 'password' => password_hash('una contraseña diferente') ]); $user->update(); // tanto name como password se actualizarán.
copyFrom(array $data): ActiveRecord
Este es un alias para el método dirty(). Es un poco más claro lo que estás haciendo.
dirty()
$user->copyFrom([ 'name' => 'algo', 'password' => password_hash('una contraseña diferente') ]); $user->update(); // tanto name como password se actualizarán.
isDirty(): boolean
Devuelve true si el registro actual ha sido cambiado.
$user->greaterThan('id', 0)->orderBy('id desc')->find(); $user->email = 'test@email.com'; $user->isDirty(); // true
reset(bool $include_query_data = true): ActiveRecord
Restablece el registro actual a su estado inicial. Esto es realmente útil para usar en comportamientos de bucle. Si pasas true, también restablecerá los datos de la consulta que se usaron para encontrar el objeto actual (comportamiento predeterminado).
$users = $user->greaterThan('id', 0)->orderBy('id desc')->find(); $user_company = new UserCompany($pdo_connection); foreach($users as $user) { $user_company->reset(); // comenzar con una página en blanco $user_company->user_id = $user->id; $user_company->company_id = $some_company_id; $user_company->insert(); }
getBuiltSql(): string
Después de ejecutar un método find(), findAll(), insert(), update() o save(), puedes obtener el SQL que se construyó y usarlo para fines de depuración.
find()
findAll()
insert()
update()
save()
select(string $campo1 [, string $campo2 ... ])
Puedes seleccionar solo algunos de los campos de una tabla si así lo deseas (es más eficiente en tablas realmente anchas con muchos campos)
$user->select('id', 'name')->find();
from(string $tabla)
¡Incluso puedes elegir otra tabla también! ¿Por qué no?
$user->select('id', 'name')->from('usuario')->find();
join(string $nombre_tabla, string $condición_join)
También puedes unirte a otra tabla en la base de datos.
$user->join('contactos', 'contactos.id_usuario = usuarios.id')->find();
where(string $condiciones_where)
Puedes establecer algunos argumentos where personalizados (no puedes establecer parámetros en esta declaración where)
$user->where('id=1 AND name="demo"')->find();
Nota de seguridad - Podrías estar tentado a hacer algo como $user->where("id = '{$id}' AND name = '{$name}'")->find();. ¡Por favor NO HAGAS ESTO! ¡Esto es susceptible a lo que se conoce como ataques de Inyección SQL. Hay muchos artículos en línea, por favor busca en Google "ataques de inyección sql php" y encontrarás muchos artículos sobre este tema. La forma correcta de manejar esto con esta biblioteca es en lugar de este método where(), harías algo más como $user->eq('id', $id)->eq('name', $name)->find(); Si realmente tienes que hacer esto, la biblioteca PDO tiene $pdo->quote($var) para escaparlo por ti. Solo después de usar quote() puedes usarlo en una declaración where().
$user->where("id = '{$id}' AND name = '{$name}'")->find();
where()
$user->eq('id', $id)->eq('name', $name)->find();
$pdo->quote($var)
quote()
group(string $grupo_por_declaración)/groupBy(string $grupo_por_declaración)
Agrupa tus resultados por una condición específica.
$user->select('COUNT(*) as count')->groupBy('name')->findAll();
order(string $ordenado_por_declaración)/orderBy(string $ordenado_por_declaración)
Ordena la consulta devuelta de cierta manera.
$user->orderBy('name DESC')->find();
limit(string $límite)/limit(int $desplazamiento, int $límite)
Limita la cantidad de registros devueltos. Si se da un segundo entero, será un desplazamiento, luego un límite como en SQL.
$user->orderby('name DESC')->limit(0, 10)->findAll();
equal(string $campo, mixed $valor) / eq(string $campo, mixed $valor)
Donde campo = $valor
campo = $valor
$user->eq('id', 1)->find();
notEqual(string $campo, mixed $valor) / ne(string $campo, mixed $valor)
Donde campo <> $valor
campo <> $valor
$user->ne('id', 1)->find();
isNull(string $campo)
Donde campo IS NULL
campo IS NULL
$user->isNull('id')->find();
isNotNull(string $campo) / notNull(string $campo)
Donde campo IS NOT NULL
campo IS NOT NULL
$user->isNotNull('id')->find();
greaterThan(string $campo, mixed $valor) / gt(string $campo, mixed $valor)
Donde campo > $valor
campo > $valor
$user->gt('id', 1)->find();
lessThan(string $campo, mixed $valor) / lt(string $campo, mixed $valor)
Donde campo < $valor
campo < $valor
$user->lt('id', 1)->find();
greaterThanOrEqual(string $field, mixed $value) / ge(string $field, mixed $value) / gte(string $field, mixed $value)
Donde campo >= $valor
campo >= $valor
$user->ge('id', 1)->find();
lessThanOrEqual(string $campo, mixed $valor) / le(string $campo, mixed $valor) / lte(string $campo, mixed $valor)
Donde campo <= $valor
campo <= $valor
$user->le('id', 1)->find();
like(string $campo, mixed $valor) / notLike(string $campo, mixed $valor)
Donde campo LIKE $valor o campo NOT LIKE $valor
campo LIKE $valor
campo NOT LIKE $valor
$user->like('name', 'de')->find();
in(string $campo, array $valores) / notIn(string $campo, array $valores)
Donde campo IN($valor) o campo NOT IN($valor)
campo IN($valor)
campo NOT IN($valor)
$user->in('id', [1, 2])->find();
between(string $campo, array $valores)
Donde campo BETWEEN $valor AND $valor1
campo BETWEEN $valor AND $valor1
$user->between('id', [1, 2])->find();
Puedes establecer varios tipos de relaciones usando esta biblioteca. Puedes establecer relaciones uno a muchos y uno a uno entre tablas. Esto requiere un poco de configuración adicional en la clase de antemano.
Configurar el arreglo $relations no es difícil, pero adivinar la sintaxis correcta puede ser confuso.
$relations
protected array $relations = [ // puedes nombrar la clave como quieras. El nombre del ActiveRecord es probablemente bueno. Ejemplo: user, contact, client 'user' => [ // requerido // self::HAS_MANY, self::HAS_ONE, self::BELONGS_TO self::HAS_ONE, // este es el tipo de relación // requerido 'Alguna_Clase', // este es el ActiveRecord "otro" que esta referencia // requerido // según el tipo de relación // self::HAS_ONE = la clave externa que hace referencia a la unión // self::HAS_MANY = la clave externa que hace referencia a la unión // self::BELONGS_TO = la clave local que hace referencia a la unión 'clave_local_o_externa', // solo como información, esto también se une a la clave primaria del modelo "otro" // opcional [ 'eq' => [ 'client_id', 5 ], 'select' => 'COUNT(*) as count', 'limit' 5 ], // condiciones adicionales que desees al unir la relación // $registro->eq('client_id', 5)->select('COUNT(*) as count')->limit(5)) // opcional 'nombre_referencia_trasera' // esto es si deseas hacer referencia a esta relación hacia atrás en sí misma Ej: $user->contact->user; ]; ]
class User extends ActiveRecord{ protected array $relations = [ 'contacts' => [ self::HAS_MANY, Contact::class, 'id_user' ], 'contact' => [ self::HAS_ONE, Contact::class, 'id_user' ], ]; public function __construct($database_connection) { parent::__construct($database_connection, 'users'); } } class Contact extends ActiveRecord{ protected array $relations = [ 'user' => [ self::BELONGS_TO, User::class, 'id_user' ], 'user_with_backref' => [ self::BELONGS_TO, User::class, 'id_user', [], 'contact' ], ]; public function __construct($database_connection) { parent::__construct($database_connection, 'contacts'); } }
¡Ahora tenemos las referencias configuradas para que podamos usarlas muy fácilmente!
$user = new User($pdo_connection); // encuentra al usuario más reciente $user->notNull('id')->orderBy('id desc')->find(); // obtén contactos usando la relación: foreach($user->contacts as $contact) { echo $contact->id; } // o podemos ir en la otra dirección. $contact = new Contact(); // encuentra un$user = new User(configuración_pdo); // encuentra un contacto $contact->find(); // obtén al usuario usando la relación: echo $contact->user->name; // este es el nombre de usuario
¡Bastante genial!
A veces puede que necesites adjuntar algo único a tu ActiveRecord como un cálculo personalizado que podría ser más fácil simplemente adjuntarlo al objeto que luego se pasaría, digamos, a una plantilla.
setCustomData(string $campo, mixed $valor)
Adjuntas los datos personalizados con el método setCustomData().
setCustomData()
$user->setCustomData('numero_visualizaciones_pagina', $numero_visualizaciones_pagina);
Y luego simplemente lo mencionas como una propiedad de objeto normal.
echo $user->numero_visualizaciones_pagina;
Otra característica súper impresionante de esta biblioteca son los eventos. Los eventos se desencadenan en ciertos momentos basados en ciertos métodos que llamas. Son muy, muy útiles para configurar datos automáticamente.
onConstruct(ActiveRecord $ActiveRecord, array &config)
Esto es realmente útil si necesitas establecer una conexión predeterminada o algo así.
// index.php o bootstrap.php Flight::register('db', 'PDO', [ 'sqlite:test.db' ]); // // // // User.php class User extends flight\ActiveRecord { protected function onConstruct(self $self, array &$config) { // no olvides la referencia & // podrías hacer esto para establecer automáticamente la conexión $config['connection'] = Flight::db(); // o esto $self->transformAndPersistConnection(Flight::db()); // También puedes establecer el nombre de la tabla de esta manera. $config['table'] = 'usuarios'; } }
beforeFind(ActiveRecord $ActiveRecord)
Esto probablemente solo sea útil si necesitas una manipulación de consulta cada vez.
class User extends flight\ActiveRecord { public function __construct($database_connection) { parent::__construct($database_connection, 'users'); } protected function beforeFind(self $self) { // siempre se ejecuta id >= 0 si es lo que prefieres $self->gte('id', 0); } }
afterFind(ActiveRecord $ActiveRecord)
Este es probablemente más útil si necesitas ejecutar alguna lógica cada vez que se recupera este registro. ¿Necesitas descifrar algo? ¿Necesitas ejecutar una consulta de recuento personalizada cada vez (no es eficiente, pero lo que sea)?
class User extends flight\ActiveRecord { public function __construct($database_connection) { parent::__construct($database_connection, 'users'); } protected function afterFind(self $self) { // descifrando algo $self->secreto = tuFuncionParaDescifrar($self->secreto, $alguna_clave); // quizás almacenar algo personalizado como una consulta??? $self->setCustomData('visualizaciones', $self->select('COUNT(*) count')->from('visualizaciones_usuario')->eq('id_usuario', $self->id)['count']; } }
beforeFindAll(ActiveRecord $ActiveRecord)
class User extends flight\ActiveRecord { public function __construct($database_connection) { parent::__construct($database_connection, 'users'); } protected function beforeFindAll(self $self) { // siempre se ejecuta id >= 0 si es lo que prefieres $self->gte('id', 0); } }
afterFindAll(array<int,ActiveRecord> $results)
Similar a afterFind() ¡Pero puedes hacerlo con todos los registros!
afterFind()
class User extends flight\ActiveRecord { public function __construct($database_connection) { parent::__construct($database_connection, 'users'); } protected function afterFindAll(array $results) { foreach($results as $self) { // haz algo genial como después de encontrar() } } }
beforeInsert(ActiveRecord $ActiveRecord)
Realmente útil si necesitas que se establezcan algunos valores predeterminados cada vez.
class User extends flight\ActiveRecord { public function __construct($database_connection) { parent::__construct($database_connection, 'users'); } protected function beforeInsert(self $self) { // establece algunos valores predeterminados sólidos if(!$self->fecha_creacion) { $self->fecha_creacion = gmdate('Y-m-d'); } if(!$self->contrasena) { $self->contrasena = password_hash((string) microtime(true)); } } }
afterInsert(ActiveRecord $ActiveRecord)
¿Quizás tienes un caso de uso para cambiar datos después de insertarlos?
class User extends flight\ActiveRecord { public function __construct($database_connection) { parent::__construct($database_connection, 'users'); } protected function afterInsert(self $self) { // haz lo que necesites Flight::cache()->set('id_mas_reciente_insertado', $self->id); // o lo que sea.... } }
beforeUpdate(ActiveRecord $ActiveRecord)
Realmente útil si necesitas que se establezcan algunos valores predeterminados cada vez al actualizar.
class User extends flight\ActiveRecord { public function __construct($database_connection) { parent::__construct($database_connection, 'users'); } protected function beforeInsert(self $self) { // establece algunos valores predeterminados sólidos if(!$self->fecha_actualizacion) { $self->fecha_actualizacion = gmdate('Y-m-d'); } } }
afterUpdate(ActiveRecord $ActiveRecord)
¿Quizás tienes un caso de uso para cambiar datos después de actualizarlos?
class User extends flight\ActiveRecord { public function __construct($database_connection) { parent::__construct($database_connection, 'users'); } protected function afterInsert(self $self) { // haz lo que necesites Flight::cache()->set('id_usuario_mas_recientemente_actualizado', $self->id); // o lo que sea.... } }
beforeSave(ActiveRecord $ActiveRecord)/afterSave(ActiveRecord $ActiveRecord)
Es útil si quieres que eventos sucedan tanto cuando se inserta como cuando se actualiza. Te ahorraré la larga explicación, pero estoy seguro de que puedes adivinar lo que es.
class User extends flight\ActiveRecord { public function __construct($database_connection) { parent::__construct($database_connection, 'users'); } protected function beforeSave(self $self) { $self->ultima_actualizacion = gmdate('Y-m-d H:i:s'); } }
beforeDelete(ActiveRecord $ActiveRecord)/afterDelete(ActiveRecord $ActiveRecord)
¡No está claro qué podrías querer hacer aquí, pero no hay juicios aquí! ¡Adelante!
class User extends flight\ActiveRecord { public function __construct($database_connection) { parent::__construct($database_connection, 'users'); } protected function beforeDelete(self $self) { echo 'Era un valiente soldado... :cara_llorando:'; } }
Cuando estás utilizando esta biblioteca, puedes configurar la conexión a la base de datos de varias maneras. Puedes configurar la conexión en el constructor, puedes configurarla a través de una variable de configuración $config['connection'] o puedes configurarla a través de setDatabaseConnection() (v0.4.1).
$config['connection']
setDatabaseConnection()
$conexion_pdo = new PDO('sqlite:test.db'); // por ejemplo $user = new User(consulta_pdo); // o $user = new User(null, [ 'conexion' => $conexion_pdo ]); // o $user = new User(); $user->setDatabaseConnection($conexion_pdo);
Si necesitas actualizar la conexión a la base de datos, por ejemplo, si estás ejecutando un script CLI de larga duración y necesitas actualizar la conexión cada cierto tiempo, puedes restablecer la conexión con $tu_registro->setDatabaseConnection($conexion_pdo).
$tu_registro->setDatabaseConnection($conexion_pdo)
Por favor hazlo. :D
Cuando contribuyas, asegúrate de ejecutar composer test-coverage para mantener una cobertura del 100% en las pruebas (esto no es una cobertura de prueba unitaria real, es más como pruebas de integración).
composer test-coverage
También asegúrate de ejecutar composer beautify y composer phpcs para corregir cualquier error de linting.
composer beautify
composer phpcs
MIT
Latte es un motor de plantillas completo que es muy fácil de usar y se siente más cercano a una sintaxis de PHP que Twig o Smarty. También es muy fácil de extender y agregar tus propios filtros y funciones.
composer require latte/latte
Existen algunas opciones de configuración básicas para comenzar. Puedes leer más sobre ellas en la Documentación de Latte.
use Latte\Engine as LatteEngine; require 'vendor/autoload.php'; $app = Flight::app(); $app->register('latte', LatteEngine::class, [], function(LatteEngine $latte) use ($app) { // Aquí es donde Latte almacenará en caché tus plantillas para acelerar las cosas // ¡Una característica genial de Latte es que actualiza automáticamente tu // caché cuando realizas cambios en tus plantillas! $latte->setTempDirectory(__DIR__ . '/../cache/'); // Indica a Latte dónde estará el directorio raíz de tus vistas. $latte->setLoader(new \Latte\Loaders\FileLoader($app->get('flight.views.path'))); });
Aquí tienes un ejemplo simple de un archivo de diseño. Este es el archivo que se utilizará para envolver todas tus otras vistas.
<!-- app/views/layout.latte --> <!doctype html> <html lang="es"> <head> <title>{$title ? $title . ' - '}Mi Aplicación</title> <link rel="stylesheet" href="style.css"> </head> <body> <header> <nav> <!-- tus elementos de navegación aquí --> </nav> </header> <div id="content"> <!-- Aquí está la magia --> {block content}{/block} </div> <div id="footer"> © Derechos de autor </div> </body> </html>
Y ahora tenemos tu archivo que se va a renderizar dentro de ese bloque de contenido:
<!-- app/views/home.latte --> <!-- Esto le dice a Latte que este archivo está "dentro" del archivo layout.latte --> {extends layout.latte} <!-- Este es el contenido que se renderizará dentro del diseño dentro del bloque de contenido --> {block content} <h1>Página de Inicio</h1> <p>¡Bienvenido a mi aplicación!</p> {/block}
Entonces, cuando vayas a renderizar esto en tu función o controlador, harías algo así:
// ruta simple Flight::route('/', function () { Flight::latte()->render('home.latte', [ 'title' => 'Página de Inicio' ]); }); // o si estás usando un controlador Flight::route('/', [HomeController::class, 'index']); // HomeController.php class HomeController { public function index() { Flight::latte()->render('home.latte', [ 'title' => 'Página de Inicio' ]); } }
¡Consulta la Documentación de Latte para obtener más información sobre cómo aprovechar al máximo Latte!
Flight es increíblemente extensible. Hay varios complementos que se pueden usar para añadir funcionalidad a su aplicación Flight. Algunos son oficialmente compatibles con el Equipo de Flight y otros son bibliotecas micro/lite para ayudarlo a empezar.
La caché es una excelente manera de acelerar su aplicación. Hay varias bibliotecas de caché que se pueden usar con Flight.
Las aplicaciones de CLI son una excelente manera de interactuar con su aplicación. Puede usarlas para generar controladores, mostrar todas las rutas y más.
Las cookies son una excelente manera de almacenar pequeños fragmentos de datos en el lado del cliente. Se pueden utilizar para almacenar preferencias de usuario, configuraciones de la aplicación y más.
La depuración es crucial cuando está desarrollando en su entorno local. Hay algunos complementos que pueden mejorar su experiencia de depuración.
Las bases de datos son el núcleo de la mayoría de las aplicaciones. Así es como se almacenan y recuperan datos. Algunas bibliotecas de bases de datos son simplemente envolturas para escribir consultas y otras son ORM completos.
La encriptación es crucial para cualquier aplicación que almacene datos sensibles. Encriptar y desencriptar los datos no es muy difícil, pero almacenar correctamente la clave de encriptación puede ser dificil. Lo más importante es nunca almacenar su clave de encriptación en un directorio público o hacer un commit a su repositorio de código.
Las sesiones no son realmente útiles para APIs, pero para desarrollar una aplicación web completo, las sesiones pueden ser cruciales para mantener el estado e información de inicio de sesión.
Las plantillas son fundamentales para cualquier aplicación web con una interfaz de usuario. Hay varios motores de plantillas que se pueden utilizar con Flight.
¿Tiene un complemento que le gustaría compartir? ¡Envíe una solicitud de extracción para agregarlo a la lista!
Tienes dos opciones para comenzar con Flight:
¡Aunque estos no están oficialmente patrocinados por el Equipo de Flight, podrían darte ideas sobre cómo estructurar tus propios proyectos construidos con Flight!
Si tienes un proyecto que deseas compartir, ¡envía una solicitud de extracción para agregarlo a esta lista!