Learn

Aprenda sobre o Flight

Flight é um framework rápido, simples e extensível para PHP. É bastante versátil e pode ser usado para construir qualquer tipo de aplicação web. Ele é construído com simplicidade em mente e é escrito de uma maneira fácil de entender e usar.

Conceitos Importantes do Framework

Por que um Framework?

Aqui está um artigo breve sobre por que você deve usar um framework. É uma boa ideia entender os benefícios de usar um framework antes de começar a usá-lo.

Além disso, um excelente tutorial foi criado por @lubiana. Embora não entre em muitos detalhes sobre o Flight especificamente, este guia irá ajudá-lo a entender alguns dos principais conceitos em torno de um framework e por que eles são benéficos de usar. Você pode encontrar o tutorial aqui.

Flight Comparado a Outros Frameworks

Se você está migrando de outro framework como Laravel, Slim, Fat-Free ou Symfony para o Flight, esta página irá ajudá-lo a entender as diferenças entre os dois.

Tópicos Principais

Carregamento Automático

Aprenda a carregar automaticamente suas próprias classes em sua aplicação.

Roteamento

Aprenda como gerenciar rotas para sua aplicação web. Isso também inclui agrupamento de rotas, parâmetros de rota e middleware.

Middleware

Aprenda como usar middleware para filtrar solicitações e respostas em sua aplicação.

Solicitações

Aprenda como lidar com solicitações e respostas em sua aplicação.

Respostas

Aprenda como enviar respostas para seus usuários.

Modelos HTML

Aprenda como usar o mecanismo de visualização incorporado para renderizar seus modelos HTML.

Segurança

Aprenda como proteger sua aplicação contra ameaças de segurança comuns.

Configuração

Aprenda como configurar o framework para sua aplicação.

Estendendo o Flight

Aprenda como estender o framework adicionando seus próprios métodos e classes.

Eventos e Filtragem

Aprenda como usar o sistema de eventos para adicionar ganchos aos seus métodos e métodos internos do framework.

Contêiner de Injeção de Dependência

Aprenda como usar contêineres de injeção de dependência (DIC) para gerenciar as dependências de sua aplicação.

API do Framework

Saiba mais sobre os métodos principais do framework.

Migrando para v3

A compatibilidade com versões anteriores foi em grande parte mantida, mas existem algumas alterações das quais você deve estar ciente ao migrar da v2 para a v3.

Resolução de Problemas

Existem alguns problemas comuns com os quais você pode se deparar ao usar o Flight. Esta página irá ajudá-lo a solucionar esses problemas.

Learn/stopping

Parando

Você pode parar o framework a qualquer momento chamando o método halt:

Flight::halt();

Você também pode especificar um código de status HTTP opcional e uma mensagem:

Flight::halt(200, 'Volto em breve...');

Chamar halt irá descartar qualquer conteúdo de resposta até esse ponto. Se você quiser parar o framework e exibir a resposta atual, use o método stop:

Flight::stop();

Learn/errorhandling

Manipulação de Erros

Erros e Exceções

Todos os erros e exceções são interceptados pelo Flight e passados para o método error. O comportamento padrão é enviar uma resposta genérica de HTTP 500 Erro Interno do Servidor com algumas informações de erro.

Você pode substituir esse comportamento para suas próprias necessidades:

Flight::map('error', function (Throwable $error) {
  // Lidar com o erro
  echo $error->getTraceAsString();
});

Por padrão, os erros não são registrados no servidor web. Você pode habilitar isso alterando a configuração:

Flight::set('flight.log_errors', true);

Não Encontrado

Quando um URL não pode ser encontrado, o Flight chama o método notFound. O comportamento padrão é enviar uma resposta de HTTP 404 Não Encontrado com uma mensagem simples.

Você pode substituir esse comportamento para suas próprias necessidades:

Flight::map('notFound', function () {
  // Lidar com não encontrado
});

Learn/flight_vs_laravel

Comparação Entre Flight e Laravel

O que é Laravel?

Laravel é um framework completo que possui todas as funcionalidades e uma incrível ecossistema focado no desenvolvedor, mas com um custo em termos de desempenho e complexidade. O objetivo do Laravel é fornecer ao desenvolvedor o mais alto nível de produtividade e tornar as tarefas comuns fáceis. Laravel é uma ótima escolha para desenvolvedores que desejam construir aplicações web empresariais completas. Isso vem com alguns compromissos, especificamente em termos de desempenho e complexidade. Aprender o básico do Laravel pode ser fácil, mas ganhar proficiência no framework pode levar algum tempo.

Também existem tantos módulos do Laravel que os desenvolvedores frequentemente sentem que a única maneira de solucionar problemas é através desses módulos, quando na verdade você poderia usar apenas outra biblioteca ou escrever seu próprio código.

Prós Comparados ao Flight

• Laravel possui um amplo ecossistema de desenvolvedores e módulos que podem ser usados para solucionar problemas comuns.
• Laravel possui um ORM completo que pode ser utilizado para interagir com seu banco de dados.
• Laravel tem uma quantidade incrível de documentação e tutoriais que podem ser utilizados para aprender o framework.
• Laravel possui um sistema de autenticação integrado que pode ser usado para proteger sua aplicação.
• Laravel possui podcasts, conferências, reuniões, vídeos e outros recursos que podem ser utilizados para aprender o framework.
• Laravel é direcionado para um desenvolvedor experiente que deseja construir uma aplicação web empresarial completa.

Contras Comparados ao Flight

• Laravel tem muito mais acontecendo sob o capô do que o Flight. Isso tem um custo dramático em termos de desempenho. Consulte os benchmarks do TechEmpower para mais informações.
• Flight é direcionado para um desenvolvedor que deseja construir uma aplicação web leve, rápida e fácil de usar.
• Flight é voltado para a simplicidade e facilidade de uso.
• Uma das características principais do Flight é fazer o seu melhor para manter a compatibilidade com versões anteriores. Laravel causa muita frustração entre versões principais.
• Flight é destinado a desenvolvedores que estão entrando no mundo dos frameworks pela primeira vez.
• Flight não possui dependências, enquanto o Laravel possui uma quantidade atroz de dependências.
• Flight também pode lidar com aplicações de nível empresarial, mas não possui tanto código de boilerplate quanto o Laravel. Também exigirá mais disciplina por parte do desenvolvedor para manter as coisas organizadas e bem estruturadas.
• O Flight dá ao desenvolvedor mais controle sobre a aplicação, enquanto o Laravel possui muita magia nos bastidores que pode ser frustrante.

Learn/migrating_to_v3

Migração para v3

A compatibilidade com versões anteriores foi em grande parte mantida, mas há algumas mudanças das quais você deve estar ciente ao fazer a migração da v2 para a v3.

Comportamento do Buffer de Saída (3.5.0)

O buffering de saída é o processo pelo qual a saída gerada por um script PHP é armazenada em um buffer (interno ao PHP) antes de ser enviada ao cliente. Isso permite que você modifique a saída antes de enviá-la ao cliente.

Em uma aplicação MVC, o Controlador é o "gerente" e ele gerencia o que a visualização faz. Ter saída gerada fora do controlador (ou no caso do Flight, às vezes em uma função anônima) quebra o padrão MVC. Essa mudança visa estar mais alinhada com o padrão MVC e tornar o framework mais previsível e fácil de usar.

Na v2, o buffering de saída era tratado de uma maneira em que não estava consistentemente fechando seu próprio buffer de saída, o que tornava os testes unitários e streaming mais difíceis. Para a maioria dos usuários, essa mudança pode não afetá-lo de fato. No entanto, se você estiver dando um echo no conteúdo fora de callables e controladores (por exemplo, em um hook), provavelmente terá problemas. Dar echo no conteúdo em hooks e antes do framework realmente executar pode ter funcionado no passado, mas não funcionará mais para frente.

Onde você pode ter problemas

// index.php
require 'vendor/autoload.php';

// apenas um exemplo
define('START_TIME', microtime(true));

function hello() {
    echo 'Olá Mundo';
}

Flight::map('hello', 'hello');
Flight::after('hello', function(){
    // isso na verdade está bem
    echo '<p>Esta frase de Olá Mundo foi trazida para você pela letra "H"</p>';
});

Flight::before('start', function(){
    // coisas como esta causarão um erro
    echo '<html><head><title>Minha Página</title></head><body>';
});

Flight::route('/', function(){
    // isso na verdade está ok
    echo 'Olá Mundo';

    // Isso também deve estar ok
    Flight::hello();
});

Flight::after('start', function(){
    // isso causará um erro
    echo '<div>Sua página carregou em '.(microtime(true) - START_TIME).' segundos</div></body></html>';
});

Ativando o Comportamento de Renderização v2

Ainda é possível manter o seu código antigo exatamente como está sem a necessidade de uma reescrita para fazê-lo funcionar com a v3? Sim, é possível! Você pode ativar o comportamento de renderização v2 definindo a opção de configuração flight.v2.output_buffering como true. Isso permitirá que você continue usando o antigo comportamento de renderização, mas é recomendado corrigi-lo para o futuro. Na v4 do framework, isso será removido.

// index.php
require 'vendor/autoload.php';

Flight::set('flight.v2.output_buffering', true);

Flight::before('start', function(){
    // Agora isso estará bem
    echo '<html><head><title>Minha Página</title></head><body>';
});

// mais código 

Mudanças no Dispatcher (3.7.0)

Se você estava chamando diretamente métodos estáticos para Dispatcher como Dispatcher::invokeMethod(), Dispatcher::execute(), etc., você precisará atualizar seu código para não chamar diretamente esses métodos. Dispatcher foi convertido para ser mais orientado a objeto, de modo que Contêineres de Injeção de Dependência possam ser usados de forma mais simples. Se você precisar invocar um método semelhante ao que o Dispatcher fazia, você pode usar manualmente algo como $result = $class->$method(...$params); ou call_user_func_array() em vez disso.

Mudanças em halt() stop() redirect() e error() (3.10.0)

O comportamento padrão antes da versão 3.10.0 era limpar tanto os cabeçalhos quanto o corpo da resposta. Isso foi alterado para limpar apenas o corpo da resposta. Se você precisar limpar também os cabeçalhos, você pode usar Flight::response()->clear().

Learn/configuration

Configuração

Você pode personalizar determinados comportamentos do Flight definindo valores de configuração através do método set.

Flight::set('flight.log_errors', true);

Configurações Disponíveis

A seguir está uma lista de todas as configurações disponíveis:

• flight.base_url ?string - Substituir a URL base da solicitação. (padrão: null)
• flight.case_sensitive bool - Correspondência com distinção entre maiúsculas e minúsculas para URLs. (padrão: false)
• flight.handle_errors bool - Permitir que o Flight gerencie todos os erros internamente. (padrão: true)
• flight.log_errors bool - Registrar erros no arquivo de log de erros do servidor web. (padrão: false)
• flight.views.path string - Diretório contendo arquivos de modelo de visualização. (padrão: ./views)
• flight.views.extension string - Extensão do arquivo de modelo de visualização. (padrão: .php)
• flight.content_length bool - Definir o cabeçalho Content-Length. (padrão: true)
• flight.v2.output_buffering bool - Usar o antigo buffer de saída. Consulte migrando para o v3. (padrão: false)

Configuração do Carregador

Existe adicionalmente uma outra configuração para o carregador. Isso permitirá que você carregue classes com _ no nome da classe.

// Ativar o carregamento de classe com underscores
// Por padrão é verdadeiro
Loader::$v2ClassLoading = false;

Variáveis

O Flight permite que você salve variáveis para que possam ser usadas em qualquer lugar de sua aplicação.

// Salve sua variável
Flight::set('id', 123);

// Em outro lugar de sua aplicação
$id = Flight::get('id');

Para ver se uma variável foi definida, você pode fazer:

if (Flight::has('id')) {
  // Faça algo
}

Você pode limpar uma variável fazendo:

// Limpa a variável id
Flight::clear('id');

// Limpa todas as variáveis
Flight::clear();

O Flight também utiliza variáveis para fins de configuração.

Flight::set('flight.log_errors', true);

Manipulação de Erros

Erros e Exceções

Todos os erros e exceções são capturados pelo Flight e passados para o método error. O comportamento padrão é enviar uma resposta genérica de HTTP 500 Erro interno do servidor com algumas informações de erro.

Você pode substituir esse comportamento conforme suas necessidades:

Flight::map('error', function (Throwable $error) {
  // Manipular erro
  echo $error->getTraceAsString();
});

Por padrão, os erros não são registrados no servidor web. Você pode ativá-los alterando a configuração:

Flight::set('flight.log_errors', true);

Não Encontrado

Quando uma URL não pode ser encontrada, o Flight chama o método notFound. O comportamento padrão é enviar uma resposta de HTTP 404 Não encontrado com uma mensagem simples.

Você pode substituir esse comportamento conforme suas necessidades:

Flight::map('notFound', function () {
  // Lidar com não encontrado
});

Learn/security

Segurança

A segurança é muito importante quando se trata de aplicações web. Você deseja garantir que sua aplicação seja segura e que os dados de seus usuários estejam protegidos. Flight fornece uma série de recursos para ajudá-lo a proteger suas aplicações web.

Cabeçalhos

Os cabeçalhos HTTP são uma das maneiras mais fáceis de proteger suas aplicações web. Você pode usar cabeçalhos para evitar clickjacking, XSS e outros ataques. Existem várias maneiras de adicionar esses cabeçalhos à sua aplicação.

Dois ótimos sites para verificar a segurança de seus cabeçalhos são securityheaders.com e observatory.mozilla.org.

Adicionar Manualmente

Você pode adicionar manualmente esses cabeçalhos usando o método header no objeto Flight\Response.

// Defina o cabeçalho X-Frame-Options para evitar clickjacking
Flight::response()->header('X-Frame-Options', 'SAMEORIGIN');

// Defina o cabeçalho Content-Security-Policy para evitar XSS
// Nota: este cabeçalho pode se tornar muito complexo, então você vai querer
// consultar exemplos na internet para a sua aplicação
Flight::response()->header("Content-Security-Policy", "default-src 'self'");

// Defina o cabeçalho X-XSS-Protection para evitar XSS
Flight::response()->header('X-XSS-Protection', '1; mode=block');

// Defina o cabeçalho X-Content-Type-Options para evitar sniffing MIME
Flight::response()->header('X-Content-Type-Options', 'nosniff');

// Defina o cabeçalho Referrer-Policy para controlar quanto informações de referência são enviadas
Flight::response()->header('Referrer-Policy', 'no-referrer-when-downgrade');

// Defina o cabeçalho Strict-Transport-Security para forçar HTTPS
Flight::response()->header('Strict-Transport-Security', 'max-age=31536000; includeSubDomains; preload');

// Defina o cabeçalho Permissions-Policy para controlar quais recursos e APIs podem ser usados
Flight::response()->header('Permissions-Policy', 'geolocation=()');

Esses cabeçalhos podem ser adicionados no início de seus arquivos bootstrap.php ou index.php.

Adicionar como Filtro

Você também pode adicioná-los em um filtro/gatilho como o seguinte:

// Adicione os cabeçalhos em um 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=()');
});

Adicionar como um Middleware

Você também pode adicioná-los como uma classe de middleware. Esta é uma boa maneira de manter seu código limpo e organizado.

// 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 ou onde quer que você tenha suas rotas
// FYI, este grupo de string vazia funciona como um middleware global para
// todas as rotas. Claro que você também poderia fazer o mesmo e adicionar
// isso apenas a rotas específicas.
Flight::group('', function(Router $router) {
    $router->get('/users', [ 'UserController', 'getUsers' ]);
    // mais rotas
}, [ new SecurityHeadersMiddleware() ]);

Cross Site Request Forgery (CSRF)

A Falsificação de Solicitação entre Sites (CSRF) é um tipo de ataque no qual um site malicioso pode fazer com que o navegador de um usuário envie uma solicitação para o seu site. Isso pode ser usado para realizar ações no seu site sem o conhecimento do usuário. Flight não fornece um mecanismo de proteção CSRF integrado, mas você pode implementar facilmente o seu próprio usando middleware.

Configuração

Primeiro, você precisa gerar um token CSRF e armazená-lo na sessão do usuário. Você pode então usar esse token em seus formulários e verificá-lo quando o formulário for enviado.

// Gere um token CSRF e armazene-o na sessão do usuário
// (assumindo que você tenha criado um objeto de sessão e o tenha vinculado ao Flight)
// consulte a documentação da sessão para mais informações
Flight::register('session', \Ghostff\Session\Session::class);

// Você só precisa gerar um token único por sessão (para que funcione
// em várias abas e solicitações para o mesmo usuário)
if(Flight::session()->get('csrf_token') === null) {
    Flight::session()->set('csrf_token', bin2hex(random_bytes(32)) );
}

<!-- Use o token CSRF em seu formulário -->
<form method="post">
    <input type="hidden" name="csrf_token" value="<?= Flight::session()->get('csrf_token') ?>">
    <!-- outros campos do formulário -->
</form>

Usando Latte

Você também pode configurar uma função personalizada para exibir o token CSRF em seus templates Latte.

// Configure uma função personalizada para exibir o token CSRF
// Nota: a View foi configurada com Latte como mecanismo de visualização
Flight::view()->addFunction('csrf', function() {
    $csrfToken = Flight::session()->get('csrf_token');
    return new \Latte\Runtime\Html('<input type="hidden" name="csrf_token" value="' . $csrfToken . '">');
});

Agora, em seus templates Latte, você pode usar a função csrf() para exibir o token CSRF.

<form method="post">
    {csrf()}
    <!-- outros campos do formulário -->
</form>

Curto e simples, certo?

Verifique o Token CSRF

Você pode verificar o token CSRF usando filtros de evento:

// Este middleware verifica se a solicitação é uma solicitação POST e, se for, verifica se o token CSRF é válido
Flight::before('start', function() {
    if(Flight::request()->method == 'POST') {

        // capture o token csrf dos valores do formulário
        $token = Flight::request()->data->csrf_token;
        if($token !== Flight::session()->get('csrf_token')) {
            Flight::halt(403, 'Token CSRF inválido');
            // ou para uma resposta JSON
            Flight::jsonHalt(['error' => 'Token CSRF inválido'], 403);
        }
    }
});

Ou você pode usar uma classe 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 ou onde quer que você tenha suas rotas
Flight::group('', function(Router $router) {
    $router->get('/users', [ 'UserController', 'getUsers' ]);
    // mais rotas
}, [ new CsrfMiddleware() ]);

Cross Site Scripting (XSS)

A Injeção de Script entre Sites (XSS) é um tipo de ataque no qual um site malicioso pode injetar código em seu site. A maioria dessas oportunidades vem de valores de formulários que seus usuários preencherão. Você nunca deve confiar na saída de seus usuários! Sempre assuma que todos são os melhores hackers do mundo. Eles podem injetar JavaScript ou HTML malicioso em sua página. Esse código pode ser usado para roubar informações de seus usuários ou realizar ações em seu site. Usando a classe de visualização do Flight, você pode escapar facilmente a saída para evitar ataques XSS.

// Vamos assumir que o usuário é inteligente e tenta usar isso como seu nome
$nome = '<script>alert("XSS")</script>';

// Isso irá escapar a saída
Flight::view()->set('name', $nome);
// Isso irá resultar em: &lt;script&gt;alert(&quot;XSS&quot;)&lt;/script&gt;

// Se você usar algo como Latte registrado como sua classe de visualização, ele também irá auto escapar isso.
Flight::view()->render('template', ['name' => $nome]);

Injeção de SQL

A Injeção de SQL é um tipo de ataque no qual um usuário malicioso pode injetar código SQL em seu banco de dados. Isso pode ser usado para roubar informações do seu banco de dados ou realizar ações no banco de dados. Novamente, você nunca deve confiar na entrada de seus usuários! Sempre assuma que eles estão atrás de você. Você pode usar declarações preparadas em seus objetos PDO para prevenir a injeção de SQL.

// Assumindo que você tem Flight::db() registrado como seu objeto PDO
$declaracao = Flight::db()->prepare('SELECT * FROM users WHERE username = :username');
$declaracao->execute([':username' => $username]);
$usuarios = $declaracao->fetchAll();

// Se você usar a classe PdoWrapper, isso pode ser feito facilmente em uma linha
$usuarios = Flight::db()->fetchAll('SELECT * FROM users WHERE username = :username', [ 'username' => $username ]);

// Você pode fazer a mesma coisa com um objeto PDO com espaços reservados ?
$declaracao = Flight::db()->fetchAll('SELECT * FROM users WHERE username = ?', [ $username ]);

// Apenas prometa que nunca JAMAIS fará algo assim...
$usuarios = Flight::db()->fetchAll("SELECT * FROM users WHERE username = '{$username}' LIMIT 5");
// porque e se $username = "' OR 1=1; -- "; 
// Depois que a consulta é construída, ela se parece com isso:
// SELECT * FROM users WHERE username = '' OU 1=1; -- LIMIT 5
// Parece estranho, mas é uma consulta válida que funcionará. Na verdade,
// é um ataque de injeção SQL muito comum que retornará todos os usuários.

CORS

O Compartilhamento de Recursos entre Origens (CORS) é um mecanismo que permite que muitos recursos (por exemplo, fontes, JavaScript, etc.) em uma página da web sejam solicitados de outro domínio fora do domínio de onde o recurso se originou. Flight não possui funcionalidade embutida para CORS, mas isso pode ser facilmente tratado com um gancho para ser executado antes que o método Flight::start() seja chamado.

// app/utils/CorsUtil.php

namespace app\utils;

class CorsUtil
{
    public function set(array $params): void
    {
        $request = Flight::request();
        $response = Flight::response();
        if ($request->getVar('HTTP_ORIGIN') !== '') {
            $this->allowOrigins();
            $response->header('Access-Control-Allow-Credentials', 'true');
            $response->header('Access-Control-Max-Age', '86400');
        }

        if ($request->method === 'OPTIONS') {
            if ($request->getVar('HTTP_ACCESS_CONTROL_REQUEST_METHOD') !== '') {
                $response->header(
                    'Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, PATCH, OPTIONS, HEAD'
                );
            }
            if ($request->getVar('HTTP_ACCESS_CONTROL_REQUEST_HEADERS') !== '') {
                $response->header(
                    "Access-Control-Allow-Headers",
                    $request->getVar('HTTP_ACCESS_CONTROL_REQUEST_HEADERS')
                );
            }

            $response->status(200);
            $response->send();
            exit;
        }
    }

    private function allowOrigins(): void
    {
        // personalize seus hosts permitidos aqui.
        $permitidos = [
            'capacitor://localhost',
            'ionic://localhost',
            'http://localhost',
            'http://localhost:4200',
            'http://localhost:8080',
            'http://localhost:8100',
        ];

        $request = Flight::request();

        if (in_array($request->getVar('HTTP_ORIGIN'), $permitidos, true) === true) {
            $resposta = Flight::response();
            $resposta->header("Access-Control-Allow-Origin", $request->getVar('HTTP_ORIGIN'));
        }
    }
}

// index.php ou onde quer que você tenha suas rotas
$CorsUtil = new CorsUtil();

// Isso precisa ser executado antes de start.
Flight::before('start', [ $CorsUtil, 'setupCors' ]);

Conclusão

A segurança é muito importante e é fundamental garantir que suas aplicações web sejam seguras. Flight fornece uma série de recursos para ajudá-lo a proteger suas aplicações web, mas é importante estar sempre vigilante e garantir que você esteja fazendo tudo o que puder para manter os dados de seus usuários seguros. Sempre assuma o pior e nunca confie na entrada de seus usuários. Sempre escape a saída e use declarações preparadas para prevenir a injeção de SQL. Sempre use middleware para proteger suas rotas de ataques CSRF e CORS. Se você fizer todas essas coisas, estará no caminho certo para construir aplicações web seguras.

Learn/overriding

Substituição

O Flight permite que você substitua sua funcionalidade padrão para atender às suas próprias necessidades, sem ter que modificar nenhum código.

Por exemplo, quando o Flight não consegue corresponder a uma URL a uma rota, ele invoca o método notFound, que envia uma resposta genérica de HTTP 404. Você pode substituir esse comportamento usando o método map:

Flight::map('notFound', function() {
  // Exibir página 404 personalizada
  include 'errors/404.html';
});

O Flight também permite que você substitua componentes principais do framework. Por exemplo, você pode substituir a classe do Roteador padrão pela sua própria classe personalizada:

// Registre sua classe personalizada
Flight::register('router', MyRouter::class);

// Quando o Flight carrega a instância do Roteador, ele carregará sua classe
$myrouter = Flight::router();

Métodos do framework como map e register, no entanto, não podem ser substituídos. Você receberá um erro se tentar fazê-lo.

Learn/routing

Roteamento

Nota: Quer entender mais sobre roteamento? Confira a página "por que um framework?" para uma explicação mais aprofundada.

O roteamento básico no Flight é feito correspondendo um padrão de URL com uma função de retorno ou um array de uma classe e método.

Flight::route('/', function(){
    echo 'olá mundo!';
});

As rotas são correspondidas na ordem em que são definidas. A primeira rota a corresponder a uma solicitação será invocada.

Callbacks/Funções

O callback pode ser qualquer objeto que seja chamável. Você pode usar uma função regular:

function hello() {
    echo 'olá mundo!';
}

Flight::route('/', 'hello');

Classes

Você também pode usar um método estático de uma classe:

class Greeting {
    public static function hello() {
        echo 'olá mundo!';
    }
}

Flight::route('/', [ 'Greeting','hello' ]);

Ou criando um objeto primeiro e depois chamando o método:

// Saudacao.php
class Greeting
{
    public function __construct() {
        $this->name = 'Fulano';
    }

    public function hello() {
        echo "Olá, {$this->name}!";
    }
}

// index.php
$greeting = new Greeting();

Flight::route('/', [ $greeting, 'hello' ]);
// Você também pode fazer isso sem criar o objeto primeiro
// Nota: Nenhum argumento será injetado no construtor
Flight::route('/', [ 'Greeting', 'hello' ]);
// Além disso, você pode usar essa sintaxe mais curta
Flight::route('/', 'Greeting->hello');
// ou
Flight::route('/', Greeting::class.'->hello');

Injeção de Dependência via DIC (Container de Injeção de Dependência)

Se você deseja usar injeção de dependência via um container (PSR-11, PHP-DI, Dice, etc), o único tipo de rotas onde isso está disponível é criando o objeto diretamente e usando o container para criar seu objeto ou você pode usar strings para definir a classe e o método a serem chamados. Você pode ir para a página Injeção de Dependência para obter mais informações.

Aqui está um exemplo rápido:

use flight\database\PdoWrapper;

// Saudacao.php
class Greeting
{
    protected PdoWrapper $pdoWrapper;
    public function __construct(PdoWrapper $pdoWrapper) {
        $this->pdoWrapper = $pdoWrapper;
    }

    public function hello(int $id) {
        // faça algo com $this->pdoWrapper
        $nome = $this->pdoWrapper->fetchField("SELECT nome FROM users WHERE id = ?", [ $id ]);
        echo "Olá, mundo! Meu nome é {$nome}!";
    }
}

// index.php

// Configure o container com os parâmetros de que você precisa
// Veja a página de Injeção de Dependência para mais informações sobre PSR-11
$dice = new \Dice\Dice();

// Não se esqueça de reatribuir a variável com '$dice = '!!!!!
$dice = $dice->addRule('flight\database\PdoWrapper', [
    'shared' => true,
    'constructParams' => [ 
        'mysql:host=localhost;dbname=test', 
        'root',
        'password'
    ]
]);

// Registre o manipulador do container
Flight::registerContainerHandler(function($class, $params) use ($dice) {
    return $dice->create($class, $params);
});

// Rotas como de costume
Flight::route('/hello/@id', [ 'Greeting', 'hello' ]);
// ou
Flight::route('/hello/@id', 'Greeting->hello');
// ou
Flight::route('/hello/@id', 'Greeting::hello');

Flight::start();

Roteamento de Método

Por padrão, os padrões de rota são correspondidos a todos os métodos de solicitação. Você pode responder a métodos específicos colocando um identificador antes da URL.

Flight::route('GET /', function () {
  echo 'Recebi um pedido GET.';
});

Flight::route('POST /', function () {
  echo 'Recebi um pedido POST.';
});

// Você não pode usar Flight::get() para rotas, pois isso é um método
//    para obter variáveis, não criar uma rota.
// Flight::post('/', function() { /* código */ });
// Flight::patch('/', function() { /* código */ });
// Flight::put('/', function() { /* código */ });
// Flight::delete('/', function() { /* código */ });

Você também pode mapear vários métodos para um único callback usando um delimitador |:

Flight::route('GET|POST /', function () {
  echo 'Recebi um pedido GET ou POST.';
});

Além disso, você pode pegar o objeto Router que possui alguns métodos auxiliares para você usar:

$router = Flight::router();

// mapeia todos os métodos
$router->map('/', function() {
    echo 'olá mundo!';
});

// pedido GET
$router->get('/users', function() {
    echo 'usuários';
});
// $router->post();
// $router->put();
// $router->delete();
// $router->patch();

Expressões Regulares

Você pode usar expressões regulares em suas rotas:

Flight::route('/usuario/[0-9]+', function () {
  // Isso corresponderá a /usuario/1234
});

Embora este método esteja disponível, é recomendado usar parâmetros nomeados, ou parâmetros nomeados com expressões regulares, pois eles são mais legíveis e mais fáceis de manter.

Parâmetros Nomeados

Você pode especificar parâmetros nomeados em suas rotas que serão passados para sua função de retorno.

Flight::route('/@nome/@id', function (string $nome, string $id) {
  echo "olá, $nome ($id)!";
});

Você também pode incluir expressões regulares com seus parâmetros nomeados usando o delimitador ::

Flight::route('/@nome/@id:[0-9]{3}', function (string $nome, string $id) {
  // Isso corresponderá a /bob/123
  // Mas não corresponderá a /bob/12345
});

Nota: A correspondência de grupos regex () com parâmetros nomeados não é suportada. :'(

Parâmetros Opcionais

Você pode especificar parâmetros nomeados que são opcionais para corresponder envolvendo segmentos entre parênteses.

Flight::route(
  '/blog(/@ano(/@mes(/@dia)))',
  function(?string $ano, ?string $mes, ?string $dia) {
    // Isso corresponderá às seguintes URLs:
    // /blog/2012/12/10
    // /blog/2012/12
    // /blog/2012
    // /blog
  }
);

Quaisquer parâmetros opcionais que não forem correspondidos serão passados como NULL.

Curelas

A correspondência é feita apenas em segmentos individuais de URL. Se você deseja corresponder a vários segmentos, você pode usar o curinga *.

Flight::route('/blog/*', function () {
  // Isso corresponderá a /blog/2000/02/01
});

Para rotear todas as solicitações para um único callback, você pode fazer:

Flight::route('*', function () {
  // Faça algo
});

Passando

Você pode passar a execução para a próxima rota correspondente retornando true de sua função de retorno.

Flight::route('/usuario/@nome', function (string $nome) {
  // Verifique alguma condição
  if ($nome !== "João") {
    // Continue para a próxima rota
    return true;
  }
});

Flight::route('/usuario/*', function () {
  // Isso será chamado
});

Alias de Rota

Você pode atribuir um alias a uma rota, para que a URL possa ser gerada dinamicamente mais tarde em seu código (como em um modelo, por exemplo).

Flight::route('/usuarios/@id', function($id) { echo 'usuário:'.$id; }, false, 'visualizacao_usuario');

// mais tarde em algum lugar do código
Flight::getUrl('visualizacao_usuario', [ 'id' => 5 ]); // retornará '/usuarios/5'

Isso é especialmente útil se sua URL mudar. No exemplo acima, digamos que usuários foram movidos para /admin/usuarios/@id ao invés disso. Com o uso de alias, você não precisa alterar em qualquer lugar que faça referência ao alias, porque o alias agora retornará /admin/usuarios/5 como no exemplo acima.

O alias de rota ainda funciona em grupos também:

Flight::group('/usuarios', function() {
    Flight::route('/@id', function($id) { echo 'usuário:'.$id; }, false, 'visualizacao_usuario');
});

// mais tarde em algum lugar do código
Flight::getUrl('visualizacao_usuario', [ 'id' => 5 ]); // retornará '/usuarios/5'

Informações da Rota

Se você quiser inspecionar as informações da rota correspondente, pode solicitar que o objeto da rota seja passado para sua função de retorno passando true como terceiro parâmetro no método de roteamento. O objeto da rota sempre será o último parâmetro passado para sua função de retorno.

Flight::route('/', function(\flight\net\Route $route) {
  // Array de métodos HTTP correspondentes
  $route->methods;

  // Array de parâmetros nomeados
  $route->params;

  // Expressão regular correspondente
  $route->regex;

  // Contém o conteúdo de qualquer '*' usado no padrão de URL
  $route->splat;

  // Mostra o caminho da URL.... se você realmente precisar
  $route->pattern;

  // Mostra qual middleware está atribuído a isto
  $route->middleware;

  // Mostra o alias atribuído a esta rota
  $route->alias;
}, true);

Agrupamento de Rotas

Pode haver momentos em que você deseja agrupar rotas relacionadas juntas (como /api/v1). Você pode fazer isso usando o método group:

Flight::group('/api/v1', function () {
  Flight::route('/usuarios', function () {
    // Corresponde a /api/v1/usuarios
  });

  Flight::route('/posts', function () {
    // Corresponde a /api/v1/posts
  });
});

Você pode até aninhar grupos de grupos:

Flight::group('/api', function () {
  Flight::group('/v1', function () {
    // Flight::get() obtém variáveis, não define uma rota! Veja abaixo o contexto do objeto
    Flight::route('GET /usuarios', function () {
      // Corresponde a GET /api/v1/usuarios
    });

    Flight::post('/posts', function () {
      // Corresponde a POST /api/v1/posts
    });

    Flight::put('/posts/1', function () {
      // Corresponde a PUT /api/v1/posts
    });
  });
  Flight::group('/v2', function () {

    // Flight::get() obtém variáveis, não define uma rota! Veja abaixo o contexto do objeto
    Flight::route('GET /usuarios', function () {
      // Corresponde a GET /api/v2/usuarios
    });
  });
});

Agrupamento com Contexto de Objeto

Você ainda pode usar o agrupamento de rotas com o objeto Engine da seguinte maneira:

$app = new \flight\Engine();
$app->group('/api/v1', function (Router $router) {

  // use a variável $router
  $router->get('/usuarios', function () {
    // Corresponde a GET /api/v1/usuarios
  });

  $router->post('/posts', function () {
    // Corresponde a POST /api/v1/posts
  });
});

Streaming

Agora é possível transmitir respostas para o cliente usando o método streamWithHeaders(). Isso é útil para enviar arquivos grandes, processos em execução longa ou gerar respostas grandes. A transmissão de uma rota é tratada de forma um pouco diferente de uma rota regular.

Nota: A transmissão de respostas só está disponível se você tiver flight.v2.output_buffering configurado como false.

Transmitir com Cabeçalhos Manuais

Você pode transmitir uma resposta para o cliente usando o método stream() em uma rota. Se você fizer isso, deve definir todos os métodos manualmente antes de enviar qualquer coisa para o cliente. Isso é feito com a função header() do PHP ou o método Flight::response()->setRealHeader().

Flight::route('/@nome_arquivo', function($nome_arquivo) {

    // obviamente você sanitizaria o caminho e tudo o mais.
    $nomeArquivoSeguro = basename($nome_arquivo);

    // Se você tiver cabeçalhos adicionais a definir aqui depois que a rota for executada
    // você deve defini-los antes de qualquer coisa ser ecoada.
    // Eles devem todos ser chamada direta para a função header() ou
    // uma chamada para o método Flight::response()->setRealHeader()
    header('Content-Disposition: attachment; filename="'.$nomeArquivoSeguro.'"');
    // ou
    Flight::response()->setRealHeader('Content-Disposition', 'attachment; filename="'.$nomeArquivoSeguro.'"');

    $dadosArquivo = file_get_contents('/algum/caminho/para/arquivos/'.$nomeArquivoSeguro);

    // Captura de erro e o que mais
    if(empty($dadosArquivo)) {
        Flight::halt(404, 'Arquivo não encontrado');
    }

    // defina manualmente o tamanho do conteúdo se desejar
    header('Content-Length: '.filesize($nome_arquivo));

    // Transmita os dados para o cliente
    echo $dadosArquivo;

// Esta é a linha mágica aqui
})->stream();

Transmitir com Cabeçalhos

Você também pode usar o método streamWithHeaders() para definir os cabeçalhos antes de começar a transmitir.

Flight::route('/stream-usuarios', function() {

    // você pode adicionar quaisquer cabeçalhos adicionais que desejar aqui
    // você só precisa usar header() ou Flight::response()->setRealHeader()

    // como você puxa seus dados, apenas como exemplo...
    $usuarios_stmt = Flight::db()->query("SELECT id, nome, sobrenome FROM usuarios");

    echo '{';
    $contador_usuarios = count($usuarios);
    while($usuario = $usuarios_stmt->fetch(PDO::FETCH_ASSOC)) {
        echo json_encode($usuario);
        if(--$contador_usuarios > 0) {
            echo ',';
        }

        // Isso é necessário para enviar os dados para o cliente
        ob_flush();
    }
    echo '}';

// É assim que você definirá os cabeçalhos antes de começar a transmitir.
})->streamWithHeaders([
    'Content-Type' => 'application/json',
    'Content-Disposition' => 'attachment; filename="usuarios.json"',
    // código de status opcional, padrão é 200
    'status' => 200
]);

Learn/flight_vs_symfony

Flight vs Symfony

O que é Symfony?

Symfony é um conjunto de componentes PHP reutilizáveis e um framework PHP para projetos web.

A base padrão na qual as melhores aplicações PHP são construídas. Escolha qualquer um dos 50 componentes independentes disponíveis para suas próprias aplicações.

Acelere a criação e manutenção de suas aplicações web PHP. Encerre tarefas repetitivas de codificação e aproveite o poder de controlar seu código.

Prós comparados ao Flight

• Symfony possui um ecossistema enorme de desenvolvedores e módulos que podem ser usados para resolver problemas comuns.
• Symfony possui um ORM completo (Doctrine) que pode ser usado para interagir com seu banco de dados.
• Symfony possui uma grande quantidade de documentação e tutoriais que podem ser usados para aprender o framework.
• Symfony possui podcasts, conferências, reuniões, vídeos e outros recursos que podem ser usados para aprender o framework.
• Symfony é voltado para um desenvolvedor experiente que procura construir um aplicativo web empresarial completo.

Contras comparados ao Flight

• Symfony tem muito mais acontecendo sob o capô do que o Flight. Isso tem um custo drástico em termos de desempenho. Veja os benchmarks TechEmpower para mais informações.
• Flight é voltado para um desenvolvedor que procura construir um aplicativo web leve, rápido e fácil de usar.
• Flight é voltado para simplicidade e facilidade de uso.
• Uma das principais características do Flight é que ele faz o possível para manter a compatibilidade com versões anteriores.
• Flight não possui dependências, enquanto Symfony possui uma série de dependências
• Flight é destinado a desenvolvedores que estão se aventurando no mundo dos frameworks pela primeira vez.
• Flight também pode lidar com aplicações de nível empresarial, mas não possui tantos exemplos e tutoriais quanto Symfony. Também exigirá mais disciplina por parte do desenvolvedor para manter as coisas organizadas e bem estruturadas.
• Flight dá ao desenvolvedor mais controle sobre a aplicação, enquanto o Symfony pode incluir alguma magia nos bastidores.

Learn/flight_vs_another_framework

Comparando Flight com Outro Framework

Se você está migrando de outro framework como Laravel, Slim, Fat-Free, ou Symfony para o Flight, esta página irá ajudá-lo a entender as diferenças entre os dois.

Laravel

Laravel é um framework completo que possui todos os recursos e uma incrível ecossistema focado no desenvolvedor, mas com um custo em desempenho e complexidade.

Veja a comparação entre Laravel e Flight.

Slim

Slim é um micro-framework que é semelhante ao Flight. Ele é projetado para ser leve e fácil de usar, mas pode ser um pouco mais complexo do que o Flight.

Veja a comparação entre Slim e Flight.

Fat-Free

Fat-Free é um framework full-stack em um pacote muito menor. Embora tenha todas as ferramentas necessárias, ele possui uma arquitetura de dados que pode tornar alguns projetos mais complexos do que precisam ser.

Veja a comparação entre Fat-Free e Flight.

Symfony

Symfony é um framework modular de nível empresarial projetado para ser flexível e escalável. Para projetos menores ou desenvolvedores mais novos, Symfony pode ser um pouco avassalador.

Veja a comparação entre Symfony e Flight.

Learn/variables

Variáveis

O Flight permite que você salve variáveis para que possam ser usadas em qualquer lugar de sua aplicação.

// Salve sua variável
Flight::set('id', 123);

// Em outro lugar de sua aplicação
$id = Flight::get('id');

Para verificar se uma variável foi definida, você pode fazer:

if (Flight::has('id')) {
  // Faça algo
}

Você pode limpar uma variável fazendo:

// Limpa a variável id
Flight::clear('id');

// Limpa todas as variáveis
Flight::clear();

O Flight também usa variáveis para fins de configuração.

Flight::set('flight.log_errors', true);

Learn/dependency_injection_container

Contentor de Injeção de Dependência

Introdução

O Contentor de Injeção de Dependência (CID) é uma ferramenta poderosa que permite gerenciar as dependências de sua aplicação. É um conceito-chave nos frameworks PHP modernos e é usado para gerenciar a instanciação e configuração de objetos. Alguns exemplos de bibliotecas CID são: Dice, Pimple, PHP-DI e league/container.

Um CID é uma forma sofisticada de dizer que permite criar e gerenciar suas classes em um local centralizado. Isso é útil quando você precisa passar o mesmo objeto para múltiplas classes (como seus controladores). Um exemplo simples pode ajudar a tornar isso mais claro.

Exemplo Básico

A maneira antiga de fazer as coisas poderia parecer assim:

require 'vendor/autoload.php';

// classe para gerenciar usuários no banco de dados
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();

Você pode ver a partir do código acima que estamos criando um novo objeto PDO e passando-o para nossa classe UserController. Isso é bom para uma aplicação pequena, mas à medida que a aplicação cresce, você descobrirá que está criando o mesmo objeto PDO em múltiplos lugares. É aqui que um CID se torna útil.

Aqui está o mesmo exemplo usando um CID (usando Dice):

require 'vendor/autoload.php';

// mesma classe que acima. Nada mudou
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());
    }
}

// criar um novo contentor
$container = new \Dice\Dice;
// não se esqueça de reatribuí-lo a si mesmo como abaixo!
$container = $container->addRule('PDO', [
    // shared significa que o mesmo objeto será retornado toda vez
    'shared' => true,
    'constructParams' => ['mysql:host=localhost;dbname=test', 'user', 'pass' ]
]);

// Isso registra o manipulador do contentor para que o Flight saiba usá-lo.
Flight::registerContainerHandler(function($class, $params) use ($container) {
    return $container->create($class, $params);
});

// agora podemos usar o contentor para criar nosso UserController
Flight::route('/user/@id', [ 'UserController', 'view' ]);
// ou alternativamente você pode definir a rota assim
Flight::route('/user/@id', 'UserController->view');
// ou
Flight::route('/user/@id', 'UserController::view');

Flight::start();

Aposto que você pode estar pensando que houve muito código extra adicionado ao exemplo. A magia acontece quando você tem outro controlador que precisa do objeto PDO.

// Se todos os seus controladores têm um construtor que precisa de um objeto PDO
// cada uma das rotas abaixo terá automaticamente ele injetado!!!
Flight::route('/empresa/@id', 'CompanyController->view');
Flight::route('/organizacao/@id', 'OrganizationController->view');
Flight::route('/categoria/@id', 'CategoryController->view');
Flight::route('/configuracoes', 'SettingsController->view');

O benefício adicional de utilizar um CID é que os testes unitários se tornam muito mais fáceis. Você pode criar um objeto falso e passá-lo para sua classe. Isso é um grande benefício ao escrever testes para sua aplicação!

PSR-11

O Flight também pode usar qualquer contentor compatível com o PSR-11. Isso significa que você pode usar qualquer contentor que implemente a interface PSR-11. Aqui está um exemplo usando o contentor PSR-11 da League:

require 'vendor/autoload.php';

// mesma classe UserController que acima

$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();

Embora isso possa ser um pouco mais verboso do que o exemplo anterior com Dice, ainda faz o trabalho com os mesmos benefícios!

Manipulador CID Personalizado

Você também pode criar seu próprio manipulador CID. Isso é útil se você tiver um contentor personalizado que deseja usar que não seja PSR-11 (Dice). Veja o exemplo básico de como fazer isso.

Além disso, existem alguns padrões úteis que facilitarão sua vida ao usar o Flight.

Instância do Motor

Se você estiver usando a instância Engine em seus controladores/funções intermediárias, aqui está como você configuraria:

// Em algum lugar do seu arquivo de inicialização
$engine = Flight::app();

$container = new \Dice\Dice;
$container = $container->addRule('*', [
    'substitutions' => [
        // Aqui é onde você passa a instância
        Engine::class => $engine
    ]
]);

$engine->registerContainerHandler(function($class, $params) use ($container) {
    return $container->create($class, $params);
});

// Agora você pode usar a instância do Engine em seus controladores/funções intermediárias

class MeuControlador {
    public function __construct(Engine $app) {
        $this->app = $app;
    }

    public function index() {
        $this->app->render('index');
    }
}

Adicionando Outras Classes

Se você tem outras classes que deseja adicionar ao contentor, com Dice é fácil, pois elas serão automaticamente resolvidas pelo contentor. Aqui está um exemplo:

$container = new \Dice\Dice;
// Se você não precisa injetar nada em sua classe
// você não precisa definir nada!
Flight::registerContainerHandler(function($class, $params) use ($container) {
    return $container->create($class, $params);
});

class MinhaClassePersonalizada {
    public function parseCoisa() {
        return 'coisa';
    }
}

class UserController {

    protected MyCustomClass $MyCustomClass;

    public function __construct(MyCustomClass $MyCustomClass) {
        $this->MyCustomClass = $MyCustomClass;
    }

    public function index() {
        echo $this->MyCustomClass->parseThing();
    }
}

Flight::route('/user', 'UserController->index');

Learn/middleware

Middleware de Rota

O Flight suporta middleware de rota e de grupo de rotas. O middleware é uma função que é executada antes (ou depois) do retorno da rota. Esta é uma ótima maneira de adicionar verificações de autenticação da API em seu código, ou para validar se o usuário tem permissão para acessar a rota.

Middleware Básico

Aqui está um exemplo básico:

// Se você fornecer apenas uma função anônima, ela será executada antes do retorno da rota.
// não existem funções de middleware "after" exceto para classes (veja abaixo)
Flight::route('/caminho', function() { echo ' Aqui estou!'; })->addMiddleware(function() {
    echo 'Middleware primeiro!';
});

Flight::start();

// Isso irá produzir "Middleware primeiro! Aqui estou!"

Existem algumas notas muito importantes sobre middleware que você deve ter em mente antes de usá-los:

• As funções do middleware são executadas na ordem em que são adicionadas à rota. A execução é semelhante a como o Framework Slim lida com isso.
  • Os "Befores" são executados na ordem adicionada, e os "Afters" são executados na ordem inversa.
• Se sua função de middleware retornar falso, toda a execução será interrompida e um erro 403 Forbidden será lançado. Provavelmente você vai querer lidar com isso de maneira mais graciosa com um Flight::redirect() ou algo similar.
• Se você precisar de parâmetros de sua rota, eles serão passados em um único array para sua função de middleware. (function($params) { ... } ou public function before($params) {}). A razão para isso é que você pode estruturar seus parâmetros em grupos e em alguns desses grupos, seus parâmetros podem realmente aparecer em uma ordem diferente que quebraria a função de middleware ao se referir ao parâmetro errado. Dessa forma, você pode acessá-los pelo nome em vez da posição.
• Se você passar apenas o nome do middleware, ele será executado automaticamente pelo contêiner de injeção de dependência e o middleware será executado com os parâmetros necessários. Se você não tiver um contêiner de injeção de dependência registrado, ele passará a instância flight\Engine para o __construct().

Classes de Middleware

O middleware pode ser registrado como uma classe também. Se você precisa da funcionalidade "after", você deve usar uma classe.

class MeuMiddleware {
    public function before($params) {
        echo 'Middleware primeiro!';
    }

    public function after($params) {
        echo 'Middleware último!';
    }
}

$MeuMiddleware = new MeuMiddleware();
Flight::route('/caminho', function() { echo ' Aqui estou! '; })->addMiddleware($MeuMiddleware); // também ->addMiddleware([ $MeuMiddleware, $MeuMiddleware2 ]);

Flight::start();

// Isso irá exibir "Middleware primeiro! Aqui estou! Middleware último!"

Lidando com Erros de Middleware

Digamos que você tenha um middleware de autenticação e deseje redirecionar o usuário para uma página de login se ele não estiver autenticado. Você tem algumas opções à sua disposição:

1. Você pode retornar falso da função do middleware e o Flight retornará automaticamente um erro 403 Forbidden, mas sem personalização.
2. Você pode redirecionar o usuário para uma página de login usando Flight::redirect().
3. Você pode criar um erro personalizado dentro do middleware e interromper a execução da rota.

Exemplo Básico

Aqui está um exemplo simples de retorno falso:

class MeuMiddleware {
    public function before($params) {
        if (isset($_SESSION['user']) === false) {
            return false;
        }

        // como é verdadeiro, tudo continua normalmente
    }
}

Exemplo de Redirecionamento

Aqui está um exemplo de redirecionamento do usuário para uma página de login:

class MeuMiddleware {
    public function before($params) {
        if (isset($_SESSION['user']) === false) {
            Flight::redirect('/login');
            exit;
        }
    }
}

Exemplo de Erro Personalizado

Digamos que você precise lançar um erro JSON porque está construindo uma API. Você pode fazer isso assim:

class MeuMiddleware {
    public function before($params) {
        $autorizacao = Flight::request()->headers['Authorization'];
        if(empty($autorizacao)) {
            Flight::jsonHalt(['error' => 'Você deve estar logado para acessar esta página.'], 403);
            // ou
            Flight::json(['error' => 'Você deve estar logado para acessar esta página.'], 403);
            exit;
            // ou
            Flight::halt(403, json_encode(['error' => 'Você deve estar logado para acessar esta página.']);
        }
    }
}

Agrupando Middleware

Você pode adicionar um grupo de rota e, em seguida, cada rota nesse grupo terá o mesmo middleware também. Isso é útil se você precisar agrupar um monte de rotas, digamos por um middleware de Autenticação para verificar a chave da API no cabeçalho.

// adicionado no final do método de grupo
Flight::group('/api', function() {

    // Esta rota com aparência "vazia" na verdade corresponderá a /api
    Flight::route('', function() { echo 'api'; }, false, 'api');
    // Esta corresponderá a /api/usuarios
    Flight::route('/usuarios', function() { echo 'usuários'; }, false, 'usuários');
    // Esta corresponderá a /api/usuarios/1234
    Flight::route('/usuarios/@id', function($id) { echo 'usuário:'.$id; }, false, 'visualização_de_usuario');
}, [ new MiddlewaredeAutenticacaoApi() ]);

Se você deseja aplicar um middleware global a todas as suas rotas, pode adicionar um grupo "vazio":

// adicionado no final do método de grupo
Flight::group('', function() {

    // Isto ainda é /usuários
    Flight::route('/usuários', function() { echo 'usuários'; }, false, 'usuários');
    // E isto ainda é /usuários/1234
    Flight::route('/usuários/@id', function($id) { echo 'usuário:'.$id; }, false, 'visualização_de_usuario');
}, [ new MiddlewaredeAutenticacaoApi() ]);

Learn/filtering

Filtragem

O Flight permite que você filtre métodos antes e depois de serem chamados. Não há ganchos predefinidos que você precise memorizar. Você pode filtrar qualquer um dos métodos padrão do framework, bem como quaisquer métodos personalizados que você tenha mapeado.

Uma função de filtro parece com isso:

function (array &$params, string &$output): bool {
  // Código do filtro
}

Usando as variáveis passadas, você pode manipular os parâmetros de entrada e/ou a saída.

Você pode ter um filtro sendo executado antes de um método fazendo:

Flight::before('start', function (array &$params, string &$output): bool {
  // Faça algo
});

Você pode ter um filtro sendo executado após um método fazendo:

Flight::after('start', function (array &$params, string &$output): bool {
  // Faça algo
});

Você pode adicionar quantos filtros quiser a qualquer método. Eles serão chamados na ordem em que são declarados.

Aqui está um exemplo do processo de filtragem:

// Mapeie um método personalizado
Flight::map('hello', function (string $name) {
  return "Olá, $name!";
});

// Adicione um filtro antes
Flight::before('hello', function (array &$params, string &$output): bool {
  // Manipule o parâmetro
  $params[0] = 'Fred';
  return true;
});

// Adicione um filtro após
Flight::after('hello', function (array &$params, string &$output): bool {
  // Manipule a saída
  $output .= " Tenha um bom dia!";
  return true;
});

// Invoque o método personalizado
echo Flight::hello('Bob');

Isso deve exibir:

Olá Fred! Tenha um bom dia!

Se você definiu vários filtros, você pode interromper a cadeia retornando false em qualquer uma de suas funções de filtro:

Flight::before('start', function (array &$params, string &$output): bool {
  echo 'um';
  return true;
});

Flight::before('start', function (array &$params, string &$output): bool {
  echo 'dois';

  // Isso irá encerrar a cadeia
  return false;
});

// Isso não será chamado
Flight::before('start', function (array &$params, string &$output): bool {
  echo 'três';
  return true;
});

Observação, métodos principais como map e register não podem ser filtrados porque são chamados diretamente e não invocados dinamicamente.

Learn/requests

Requisições

Flight encapsula a requisição HTTP em um único objeto, que pode ser acessado fazendo:

$request = Flight::request();

Casos de Uso Típicos

Quando você está trabalhando com uma requisição em uma aplicação web, tipicamente você vai querer extrair um cabeçalho, ou um parâmetro $_GET ou $_POST, ou talvez até mesmo o corpo bruto da requisição. Flight fornece uma interface simples para fazer todas essas coisas.

Aqui está um exemplo obtendo um parâmetro de string de consulta:

Flight::route('/search', function(){
    $keyword = Flight::request()->query['keyword'];
    echo "Você está pesquisando por: $keyword";
    // consultar um banco de dados ou algo assim com o $keyword
});

Aqui está um exemplo de talvez um formulário com um método POST:

Flight::route('POST /submit', function(){
    $name = Flight::request()->data['name'];
    $email = Flight::request()->data['email'];
    echo "Você enviou: $name, $email";
    // salvar em um banco de dados ou algo assim com o $name e $email
});

Propriedades do Objeto de Requisição

O objeto de requisição fornece as seguintes propriedades:

• body - O corpo bruto da requisição HTTP
• url - A URL sendo requisitada
• base - O subdiretório pai da URL
• method - O método da requisição (GET, POST, PUT, DELETE)
• referrer - A URL de referência
• ip - Endereço IP do cliente
• ajax - Se a requisição é uma requisição AJAX
• scheme - O protocolo do servidor (http, https)
• user_agent - Informações do navegador
• type - O tipo de conteúdo
• length - O comprimento do conteúdo
• query - Parâmetros de string de consulta
• data - Dados POST ou dados JSON
• cookies - Dados de cookie
• files - Arquivos enviados
• secure - Se a conexão é segura
• accept - Parâmetros de aceitação HTTP
• proxy_ip - Endereço IP do proxy do cliente. Escaneia o array $_SERVER para HTTP_CLIENT_IP, HTTP_X_FORWARDED_FOR, HTTP_X_FORWARDED, HTTP_X_CLUSTER_CLIENT_IP, HTTP_FORWARDED_FOR, HTTP_FORWARDED nessa ordem.
• host - O nome do host da requisição

Você pode acessar as propriedades query, data, cookies e files como arrays ou objetos.

Então, para obter um parâmetro de string de consulta, você pode fazer:

$id = Flight::request()->query['id'];

Ou você pode fazer:

$id = Flight::request()->query->id;

Corpo Bruto da Requisição

Para obter o corpo bruto da requisição HTTP, por exemplo, ao lidar com requisições PUT, você pode fazer:

$body = Flight::request()->getBody();

Entrada JSON

Se você enviar uma requisição com o tipo application/json e os dados {"id": 123} eles estarão disponíveis na propriedade data:

$id = Flight::request()->data->id;

$_GET

Você pode acessar o array $_GET através da propriedade query:

$id = Flight::request()->query['id'];

$_POST

Você pode acessar o array $_POST através da propriedade data:

$id = Flight::request()->data['id'];

$_COOKIE

Você pode acessar o array $_COOKIE através da propriedade cookies:

$myCookieValue = Flight::request()->cookies['myCookieName'];

$_SERVER

Há um atalho disponível para acessar o array $_SERVER através do método getVar():

$host = Flight::request()->getVar['HTTP_HOST'];

Acessando Arquivos Enviados via $_FILES

Você pode acessar arquivos enviados através da propriedade files:

$uploadedFile = Flight::request()->files['myFile'];

Processando Envio de Arquivos

Você pode processar o envio de arquivos usando o framework com alguns métodos auxiliares. Basicamente resume-se a puxar os dados do arquivo da requisição e movê-los para um novo local.

Flight::route('POST /upload', function(){
    // Se você tiver um campo de entrada como <input type="file" name="myFile">
    $uploadedFileData = Flight::request()->getUploadedFiles();
    $uploadedFile = $uploadedFileData['myFile'];
    $uploadedFile->moveTo('/caminho/para/uploads/' . $uploadedFile->getClientFilename());
});

Se você tiver vários arquivos enviados, você pode percorrê-los:

Flight::route('POST /upload', function(){
    // Se você tiver um campo de entrada como <input type="file" name="myFiles[]">
    $uploadedFiles = Flight::request()->getUploadedFiles()['myFiles'];
    foreach ($uploadedFiles as $uploadedFile) {
        $uploadedFile->moveTo('/caminho/para/uploads/' . $uploadedFile->getClientFilename());
    }
});

Nota de Segurança: Sempre valide e sanitize a entrada do usuário, especialmente ao lidar com envios de arquivos. Sempre valide o tipo de extensões que você permitirá que sejam enviadas, mas você também deve validar os "bytes mágicos" do arquivo para garantir que ele é realmente do tipo de arquivo que o usuário afirma que é. Existem artigos e bibliotecas disponíveis para ajudar com isso.

Cabeçalhos da Requisição

Você pode acessar os cabeçalhos da requisição usando o método getHeader() ou getHeaders():

// Talvez você precise do cabeçalho Authorization
$host = Flight::request()->getHeader('Authorization');
// ou
$host = Flight::request()->header('Authorization');

// Se você precisar obter todos os cabeçalhos
$headers = Flight::request()->getHeaders();
// ou
$headers = Flight::request()->headers();

Corpo da Requisição

Você pode acessar o corpo bruto da requisição usando o método getBody():

$body = Flight::request()->getBody();

Método da Requisição

Você pode acessar o método da requisição usando a propriedade method ou o método getMethod():

$method = Flight::request()->method; // na verdade chama getMethod()
$method = Flight::request()->getMethod();

Nota: O método getMethod() primeiro puxa o método de $_SERVER['REQUEST_METHOD'], depois pode ser substituído por $_SERVER['HTTP_X_HTTP_METHOD_OVERRIDE'] se existir ou $_REQUEST['_method'] se existir.

URLs da Requisição

Há alguns métodos auxiliares para juntar partes de uma URL para sua conveniência.

URL Completa

Você pode acessar a URL completa da requisição usando o método getFullUrl():

$url = Flight::request()->getFullUrl();
// https://example.com/some/path?foo=bar

URL Base

Você pode acessar a URL base usando o método getBaseUrl():

$url = Flight::request()->getBaseUrl();
// Aviso, sem barra final.
// https://example.com

Análise de Consulta

Você pode passar uma URL para o método parseQuery() para analisar a string de consulta em um array associativo:

$query = Flight::request()->parseQuery('https://example.com/some/path?foo=bar');
// ['foo' => 'bar']

Learn/frameworkmethods

# Métodos do Framework

Flight é projetado para ser fácil de usar e entender. O seguinte é o conjunto completo
de métodos para o framework. Consiste em métodos principais, que são métodos estáticos regulares,
e métodos extensíveis, que são métodos mapeados que podem ser filtrados
ou substituídos.

## Métodos Principais

```php
Flight::map(string $name, callable $callback, bool $pass_route = false) // Cria um método de framework personalizado.
Flight::register(string $name, string $class, array $params = [], ?callable $callback = null) // Registra uma classe a um método de framework.
Flight::before(string $name, callable $callback) // Adiciona um filtro antes de um método de framework.
Flight::after(string $name, callable $callback) // Adiciona um filtro após um método de framework.
Flight::path(string $path) // Adiciona um caminho para carregar classes automaticamente.
Flight::get(string $key) // Obtém uma variável.
Flight::set(string $key, mixed $value) // Define uma variável.
Flight::has(string $key) // Verifica se uma variável está definida.
Flight::clear(array|string $key = []) // Limpa uma variável.
Flight::init() // Inicializa o framework com suas configurações padrão.
Flight::app() // Obtém a instância do objeto de aplicativo

Métodos Extensíveis

Flight::start() // Inicia o framework.
Flight::stop() // Para o framework e envia uma resposta.
Flight::halt(int $code = 200, string $message = '') // Para o framework com um código de status e mensagem opcionais.
Flight::route(string $pattern, callable $callback, bool $pass_route = false) // Mapeia um padrão de URL para um retorno de chamada.
Flight::group(string $pattern, callable $callback) // Cria agrupamento para urls, o padrão deve ser uma string.
Flight::redirect(string $url, int $code) // Redireciona para outra URL.
Flight::render(string $file, array $data, ?string $key = null) // Renderiza um arquivo de modelo.
Flight::error(Throwable $error) // Envia uma resposta HTTP 500.
Flight::notFound() // Envia uma resposta HTTP 404.
Flight::etag(string $id, string $type = 'string') // Realiza o cache do HTTP ETag.
Flight::lastModified(int $time) // Realiza o cache do HTTP de última modificação.
Flight::json(mixed $data, int $code = 200, bool $encode = true, string $charset = 'utf8', int $option) // Envia uma resposta JSON.
Flight::jsonp(mixed $data, string $param = 'jsonp', int $code = 200, bool $encode = true, string $charset = 'utf8', int $option) // Envia uma resposta JSONP.

Quaisquer métodos personalizados adicionados com map e register também podem ser filtrados.

Learn/api

Métodos da API do Framework

Flight foi projetado para ser fácil de usar e entender. A seguir está o conjunto completo de métodos para o framework. Ele consiste em métodos principais, que são métodos estáticos regulares, e métodos extensíveis, que são métodos mapeados que podem ser filtrados ou anulados.

Métodos Principais

Estes métodos são essenciais para o framework e não podem ser anulados.

Flight::map(string $nome, callable $retorno, bool $pass_route = false) // Cria um método personalizado para o framework.
Flight::register(string $nome, string $classe, array $params = [], ?callable $retorno = null) // Registra uma classe para um método do framework.
Flight::unregister(string $nome) // Anula uma classe de um método do framework.
Flight::before(string $nome, callable $retorno) // Adiciona um filtro antes de um método do framework.
Flight::after(string $nome, callable $retorno) // Adiciona um filtro após um método do framework.
Flight::path(string $caminho) // Adiciona um caminho para o carregamento automático de classes.
Flight::get(string $chave) // Obtém uma variável definida por Flight::set().
Flight::set(string $chave, mixed $valor) // Define uma variável dentro do mecanismo do Flight.
Flight::has(string $chave) // Verifica se uma variável está definida.
Flight::clear(array|string $chave = []) // Limpa uma variável.
Flight::init() // Inicializa o framework com as configurações padrão.
Flight::app() // Obtém a instância do objeto de aplicativo
Flight::request() // Obtém a instância do objeto de solicitação
Flight::response() // Obtém a instância do objeto de resposta
Flight::router() // Obtém a instância do objeto de roteador
Flight::view() // Obtém a instância do objeto de visualização

Métodos Extensíveis

Flight::start() // Inicia o framework.
Flight::stop() // Interrompe o framework e envia uma resposta.
Flight::halt(int $code = 200, string $message = '') // Interrompe o framework com um código de status e mensagem opcional.
Flight::route(string $padrão, callable $retorno, bool $pass_route = false, string $alias = '') // Mapeia um padrão de URL para um retorno.
Flight::post(string $padrão, callable $retorno, bool $pass_route = false, string $alias = '') // Mapeia um padrão de URL de solicitação POST para um retorno.
Flight::put(string $padrão, callable $retorno, bool $pass_route = false, string $alias = '') // Mapeia um padrão de URL de solicitação PUT para um retorno.
Flight::patch(string $padrão, callable $retorno, bool $pass_route = false, string $alias = '') // Mapeia um padrão de URL de solicitação PATCH para um retorno.
Flight::delete(string $padrão, callable $retorno, bool $pass_route = false, string $alias = '') // Mapeia um padrão de URL de solicitação DELETE para um retorno.
Flight::group(string $padrão, callable $retorno) // Cria agrupamento para URLs, o padrão deve ser uma string.
Flight::getUrl(string $nome, array $params = []) // Gera uma URL com base em um alias de rota.
Flight::redirect(string $url, int $code) // Redireciona para outra URL.
Flight::download(string $caminhoArquivo) // Faz o download de um arquivo.
Flight::render(string $arquivo, array $dados, ?string $chave = null) // Renderiza um arquivo de modelo.
Flight::error(Throwable $erro) // Envia uma resposta HTTP 500.
Flight::notFound() // Envia uma resposta HTTP 404.
Flight::etag(string $id, string $tipo = 'string') // Executa o cacheamento HTTP ETag.
Flight::lastModified(int $tempo) // Executa o cacheamento HTTP da última modificação.
Flight::json(mixed $dados, int $code = 200, bool $encode = true, string $charset = 'utf8', int $opção) // Envia uma resposta JSON.
Flight::jsonp(mixed $dados, string $param = 'jsonp', int $code = 200, bool $encode = true, string $charset = 'utf8', int $opção) // Envia uma resposta JSONP.
Flight::jsonHalt(mixed $dados, int $code = 200, bool $encode = true, string $charset = 'utf8', int $opção) // Envia uma resposta JSON e interrompe o framework.

Quaisquer métodos personalizados adicionados com map e register também podem ser filtrados. Para exemplos de como mapear esses métodos, consulte o guia Estendendo o Flight.

Learn/why_frameworks

Por que um Framework?

Alguns programadores são veementemente contra o uso de frameworks. Eles argumentam que os frameworks são inflados, lentos e difíceis de aprender. Dizem que os frameworks são desnecessários e que você pode escrever um código melhor sem eles. Certamente, há alguns pontos válidos a serem considerados sobre as desvantagens do uso de frameworks. No entanto, também existem muitas vantagens em usar frameworks.

Motivos para Usar um Framework

Aqui estão algumas razões pelas quais você pode querer considerar o uso de um framework:

• Desenvolvimento Rápido: Os frameworks fornecem muita funcionalidade pronta para uso. Isso significa que você pode construir aplicações web mais rapidamente. Você não precisa escrever tanto código, pois o framework fornece grande parte da funcionalidade necessária.
• Consistência: Os frameworks fornecem uma forma consistente de fazer as coisas. Isso facilita a compreensão de como o código funciona e torna mais fácil para outros desenvolvedores entenderem o seu código. Se você o tem script por script, pode perder a consistência entre scripts, especialmente se estiver trabalhando com uma equipe de desenvolvedores.
• Segurança: Os frameworks oferecem recursos de segurança que ajudam a proteger suas aplicações web contra ameaças de segurança comuns. Isso significa que você não precisa se preocupar tanto com a segurança, pois o framework cuida de grande parte disso para você.
• Comunidade: Os frameworks têm grandes comunidades de desenvolvedores que contribuem para o framework. Isso significa que você pode obter ajuda de outros desenvolvedores quando tiver perguntas ou problemas. Também significa que há muitos recursos disponíveis para ajudá-lo a aprender como usar o framework.
• Melhores Práticas: Os frameworks são construídos seguindo as melhores práticas. Isso significa que você pode aprender com o framework e usar as mesmas melhores práticas em seu próprio código. Isso pode ajudá-lo a se tornar um melhor programador. Às vezes, você não sabe o que não sabe e isso pode prejudicá-lo no final.
• Extensibilidade: Os frameworks são projetados para serem estendidos. Isso significa que você pode adicionar sua própria funcionalidade ao framework. Isso permite que você construa aplicações web adaptadas às suas necessidades específicas.

Flight é um micro-framework. Isso significa que ele é pequeno e leve. Ele não fornece tanta funcionalidade quanto frameworks maiores como Laravel ou Symfony. No entanto, ele fornece muita da funcionalidade necessária para construir aplicações web. É também fácil de aprender e usar. Isso o torna uma boa escolha para construir aplicações web rapidamente e facilmente. Se você é novo em frameworks, o Flight é um ótimo framework para iniciantes a começar. Vai ajudá-lo a entender as vantagens de usar frameworks sem sobrecarregá-lo com muita complexidade. Depois de adquirir alguma experiência com o Flight, será mais fácil passar para frameworks mais complexos como Laravel ou Symfony, no entanto, o Flight ainda pode criar um aplicativo robusto e bem-sucedido.

O Que é Roteamento?

O roteamento é o núcleo do framework Flight, mas o que é exatamente? Roteamento é o processo de pegar uma URL e correspondê-la a uma função específica em seu código. É assim que você pode fazer seu site fazer coisas diferentes com base na URL solicitada. Por exemplo, você pode querer mostrar o perfil de um usuário quando ele visita /user/1234, mas mostrar uma lista de todos os usuários quando eles visitam /users. Tudo isso é feito por meio do roteamento.

Pode funcionar algo assim:

• Um usuário vai para o seu navegador e digita http://exemplo.com/user/1234.
• O servidor recebe a solicitação, olha para a URL e a passa para o seu código de aplicativo Flight.
• Digamos que em seu código Flight você tenha algo como Flight::route('/user/@id', [ 'ControladorDeUsuario', 'verPerfilDoUsuario' ]);. Seu código de aplicativo Flight olha a URL e percebe que corresponde a uma rota que você definiu, e então executa o código que você definiu para essa rota.
• O roteador do Flight vai então chamar o método verPerfilDoUsuario($id) na classe ControladorDeUsuario, passando o 1234 como argumento $id no método.
• O código em seu método verPerfilDoUsuario() então vai rodar e fazer o que você mandou fazer. Você pode acabar ecoando um pouco de HTML para a página do perfil do usuário, ou se isso for uma API RESTful, você pode ecoar uma resposta JSON com a informação do usuário.
• O Flight embrulha isso em um laço bonito, gera os cabeçalhos de resposta e envia de volta para o navegador do usuário.
• O usuário fica cheio de alegria e dá a si mesmo um caloroso abraço!

E Por que é Importante?

Ter um roteador centralizado apropriado pode realmente tornar sua vida dramaticamente mais fácil! Pode ser difícil ver isso à primeira vista. Aqui estão algumas razões:

• Roteamento Centralizado: Você pode manter todas as suas rotas em um só lugar. Isso torna mais fácil ver quais rotas você tem e o que elas fazem. Também facilita alterá-las, se necessário.
• Parâmetros de Rota: Você pode usar parâmetros de rota para passar dados para seus métodos de rota. Esta é uma ótima maneira de manter seu código limpo e organizado.
• Grupos de Rotas: Você pode agrupar rotas juntas. Isso é ótimo para manter seu código organizado e para aplicar middleware a um grupo de rotas.
• Alias de Rota: Você pode atribuir um alias a uma rota, para que a URL possa ser gerada dinamicamente mais tarde em seu código (como um modelo, por exemplo). Ex: em vez de codificar /user/1234 no seu código, você poderia referenciar o alias user_view e passar o id como parâmetro. Isso é maravilhoso no caso de decidir alterá-lo para /admin/user/1234 posteriormente. Você não precisará mudar todas as suas URLs codificadas, apenas a URL associada à rota.
• Middleware de Rota: Você pode adicionar middleware às suas rotas. O middleware é incrivelmente poderoso para adicionar comportamentos específicos à sua aplicação, como autenticar que um determinado usuário pode acessar uma rota ou grupo de rotas.

Tenho certeza de que você está familiarizado com a maneira script por script de criar um site. Você pode ter um arquivo chamado index.php que possui um monte de declarações if para verificar a URL e em seguida executar uma função específica com base na URL. Isso é uma forma de roteamento, mas não é muito organizado e pode sair do controle rapidamente. O sistema de roteamento do Flight é uma maneira muito mais organizada e poderosa de lidar com o roteamento.

Isto?

// /user/view_profile.php?id=1234
if ($_GET['id']) {
    $id = $_GET['id'];
    viewUserProfile($id);
}

// /user/edit_profile.php?id=1234
if ($_GET['id']) {
    $id = $_GET['id'];
    editUserProfile($id);
}

// etc...

Ou isso?

// index.php
Flight::route('/user/@id', [ 'ControladorDeUsuario', 'verPerfilDoUsuario' ]);
Flight::route('/user/@id/edit', [ 'ControladorDeUsuario', 'editarPerfilDoUsuario' ]);

// Em talvez o seu app/controllers/ControladorDeUsuario.php
class ControladorDeUsuario {
    public function verPerfilDoUsuario($id) {
        // faça algo
    }

    public function editarPerfilDoUsuario($id) {
        // faça algo
    }
}

Espero que você comece a ver os benefícios de usar um sistema de roteamento centralizado. É muito mais fácil de gerenciar e entender a longo prazo!

Solicitações e Respostas

O Flight oferece uma maneira simples e fácil de lidar com solicitações e respostas. Este é o núcleo do que um framework web faz. Ele recebe uma solicitação de um navegador de um usuário, a processa e envia de volta uma resposta. Com isso, você pode construir aplicações web que realizem tarefas como mostrar o perfil de um usuário, permitir que um usuário faça login, ou permitir que um usuário poste uma nova postagem em um blog.

Solicitações

Uma solicitação é o que o navegador de um usuário envia para o seu servidor quando eles visitam o seu site. Esta solicitação contém informações sobre o que o usuário quer fazer. Por exemplo, ela pode conter informações sobre qual URL o usuário deseja visitar, quais dados o usuário deseja enviar para o seu servidor, ou que tipo de dados o usuário deseja receber do seu servidor. É importante saber que uma solicitação é somente leitura. Você não pode alterar a solicitação, mas pode lê-la.

O Flight fornece uma maneira simples de acessar informações sobre a solicitação. Você pode acessar informações sobre a solicitação usando o método Flight::request(). Este método retorna um objeto Request que contém informações sobre a solicitação. Você pode usar esse objeto para acessar informações sobre a solicitação, como a URL, o método, ou os dados que o usuário enviou para o seu servidor.

Respostas

Uma resposta é o que o seu servidor envia de volta para o navegador de um usuário quando eles visitam o seu site. Esta resposta contém informações sobre o que o seu servidor quer fazer. Por exemplo, ela pode conter informações sobre que tipo de dados o seu servidor quer enviar para o usuário, que tipo de dados seu servidor quer receber do usuário, ou que tipo de dados seu servidor quer armazenar no computador do usuário.

O Flight fornece uma maneira simples de enviar uma resposta para o navegador do usuário. Você pode enviar uma resposta usando o método Flight::response(). Este método recebe um objeto Response como argumento e envia a resposta para o navegador do usuário. Você pode usar este objeto para enviar uma resposta para o navegador do usuário, como HTML, JSON, ou um arquivo. O Flight ajuda a gerar automaticamente algumas partes da resposta para facilitar as coisas, mas, em última instância, você tem controle sobre o que enviar de volta para o usuário.

Learn/httpcaching

Caching HTTP

Voo fornece suporte embutido para o caching de nível HTTP. Se a condição de caching for atendida, Voo retornará uma resposta 304 Not Modified HTTP. Da próxima vez que o cliente solicitar o mesmo recurso, eles serão convidados a usar sua versão em cache localmente.

Última Modificação

Você pode usar o método lastModified e passar um carimbo de data/hora UNIX para definir a data e hora em que a página foi modificada pela última vez. O cliente continuará a usar seu cache até que o valor da última modificação seja alterado.

Flight::route('/noticias', function () {
  Flight::lastModified(1234567890);
  echo 'Este conteúdo será armazenado em cache.';
});

ETag

O caching ETag é semelhante ao Última Modificação, exceto que você pode especificar qualquer ID que desejar para o recurso:

Flight::route('/noticias', function () {
  Flight::etag('meu-id-único');
  echo 'Este conteúdo será armazenado em cache.';
});

Tenha em mente que chamar lastModified ou etag definirá e verificará o valor do cache. Se o valor do cache for o mesmo entre as solicitações, Voo enviará imediatamente uma resposta HTTP 304 e interromperá o processamento.

Learn/responses

Respostas

O Flight ajuda a gerar parte dos cabeçalhos de resposta para você, mas você tem a maior parte do controle sobre o que envia de volta para o usuário. Às vezes você pode acessar o objeto Response diretamente, mas na maioria das vezes você usará a instância Flight para enviar uma resposta.

Enviando uma Resposta Básica

O Flight usa ob_start() para armazenar em buffer a saída. Isso significa que você pode usar echo ou print para enviar uma resposta ao usuário e o Flight irá capturá-la e enviá-la de volta ao usuário com os cabeçalhos apropriados.

// Isto enviará "Olá, Mundo!" para o navegador do usuário
Flight::route('/', function() {
    echo "Olá, Mundo!";
});

// HTTP/1.1 200 OK
// Content-Type: text/html
//
// Olá, Mundo!

Como alternativa, você pode chamar o método write() para adicionar ao corpo também.

// Isto enviará "Olá, Mundo!" para o navegador do usuário
Flight::route('/', function() {
    // verboso, mas resolve o problema às vezes quando você precisa
    Flight::response()->write("Olá, Mundo!");

    // se você quiser recuperar o corpo que definiu neste ponto
    // você pode fazer assim
    $body = Flight::response()->getBody();
});

Códigos de Status

Você pode definir o código de status da resposta usando o método status:

Flight::route('/@id', function($id) {
    if($id == 123) {
        Flight::response()->status(200);
        echo "Olá, Mundo!";
    } else {
        Flight::response()->status(403);
        echo "Proibido";
    }
});

Se quiser obter o código de status atual, pode usar o método status sem nenhum argumento:

Flight::response()->status(); // 200

Definindo um Corpo de Resposta

Você pode definir o corpo da resposta usando o método write, no entanto, se você usar echo ou print em qualquer coisa, será capturado e enviado como o corpo de resposta via armazenamento em buffer de saída.

Flight::route('/', function() {
    Flight::response()->write("Olá, Mundo!");
});

// mesmo que

Flight::route('/', function() {
    echo "Olá, Mundo!";
});

Limpando um Corpo de Resposta

Se quiser limpar o corpo da resposta, pode usar o método clearBody:

Flight::route('/', function() {
    if($algumaCondicao) {
        Flight::response()->write("Olá, Mundo!");
    } else {
        Flight::response()->clearBody();
    }
});

Executando um Callback no Corpo de Resposta

Você pode executar um callback no corpo de resposta usando o método addResponseBodyCallback:

Flight::route('/usuarios', function() {
    $bd = Flight::bd();
    $usuarios = $bd->fetchAll("SELECIONAR * FROM usuarios");
    Flight::render('tabela_usuarios', ['usuarios' => $usuarios]);
});

// Isto irá compactar todas as respostas para qualquer rota
Flight::response()->addResponseBodyCallback(function($corpo) {
    return gzencode($corpo, 9);
});

Você pode adicionar vários callbacks e eles serão executados na ordem em que foram adicionados. Porque isso pode aceitar qualquer chamável, pode aceitar um array de classe [ $classe, 'método' ], um fechamento $strReplace = function($corpo) { str_replace('oi', 'olá', $corpo); };, ou um nome de função 'minify' se você tiver uma função para minificar seu código html, por exemplo.

Nota: Os callbacks de rota não funcionarão se você estiver usando a opção de configuração flight.v2.output_buffering.

Callback de Rota Específica

Se desejar que isso se aplique apenas a uma rota específica, poderá adicionar o callback na própria rota:

Flight::route('/usuarios', function() {
    $bd = Flight::bd();
    $usuarios = $bd->fetchAll("SELECIONAR * FROM usuarios");
    Flight::render('tabela_usuarios', ['usuarios' => $usuarios]);

    // Isto compactará apenas a resposta para esta rota
    Flight::response()->addResponseBodyCallback(function($corpo) {
        return gzencode($corpo, 9);
    });
});

Opção de Middleware

Você também pode usar middleware para aplicar o callback a todas as rotas via middleware:

// MinifyMiddleware.php
class MinifyMiddleware {
    public function before() {
        // Aplique o callback aqui no objeto response().
        Flight::response()->addResponseBodyCallback(function($corpo) {
            return $this->minify($corpo);
        });
    }

    protected function minify(string $corpo): string {
        // minimize o corpo de alguma forma
        return $corpo;
    }
}

// index.php
Flight::group('/usuarios', function() {
    Flight::route('', function() { /* ... */ });
    Flight::route('/@id', function($id) { /* ... */ });
}, [ new MinifyMiddleware() ]);

Definindo um Cabeçalho de Resposta

Você pode configurar um cabeçalho, como o tipo de conteúdo da resposta, usando o método header:

// Isto enviará "Olá, Mundo!" para o navegador do usuário em texto simples
Flight::route('/', function() {
    Flight::response()->header('Content-Type', 'text/plain');
    // ou
    Flight::response()->setHeader('Content-Type', 'text/plain');
    echo "Olá, Mundo!";
});

JSON

O Flight fornece suporte para envio de respostas JSON e JSONP. Para enviar uma resposta JSON você passa alguns dados para serem codificados em JSON:

Flight::json(['id' => 123]);

JSON com Código de Status

Você também pode passar um código de status como segundo argumento:

Flight::json(['id' => 123], 201);

JSON com Impressão Bonita

Você também pode passar um argumento na última posição para habilitar a impressão bonita:

Flight::json(['id' => 123], 200, true, 'utf-8', JSON_PRETTY_PRINT);

Se estiver alterando as opções passadas para Flight::json() e desejar uma sintaxe mais simples, pode remapear o método JSON:

Flight::map('json', function($dados, $código = 200, $opções = 0) {
    Flight::_json($dados, $código, true, 'utf-8', $opções);
}

// E agora pode ser usado assim
Flight::json(['id' => 123], 200, JSON_PRETTY_PRINT);

JSON e Interromper a Execução (v3.10.0)

Se desejar enviar uma resposta JSON e interromper a execução, pode usar o método jsonHalt. Isso é útil para casos em que você está verificando talvez algum tipo de autorização e se o usuário não estiver autorizado, você pode enviar imediatamente uma resposta JSON, limpar o conteúdo do corpo existente e interromper a execução.

Flight::route('/usuarios', function() {
    $autorizado = algumaVerificaçãoDeAutorização();
    // Verifique se o usuário está autorizado
    if($autorizado === falso) {
        Flight::jsonHalt(['erro' => 'Não autorizado'], 401);
    }

    // Continue com o restante da rota
});

Antes da v3.10.0, você teria que fazer algo assim:

Flight::route('/usuarios', function() {
    $autorizado = algumaVerificaçãoDeAutorização();
    // Verifique se o usuário está autorizado
    if($autorizado === falso) {
        Flight::haltar(401, json_encode(['erro' => 'Não autorizado']));
    }

    // Continue com o restante da rota
});

JSONP

Para requisições JSONP, você pode opcionalmente passar o nome do parâmetro da query que você está usando para definir sua função de retorno de chamada:

Flight::jsonp(['id' => 123], 'q');

Portanto, ao fazer uma solicitação GET usando ?q=my_func, você deverá receber a saída:

my_func({"id":123});

Se você não passar um nome de parâmetro de query, ele será padrão para jsonp.

Redirecionar para outra URL

Você pode redirecionar a solicitação atual usando o método redirect() e passando uma nova URL:

Flight::redirect('/nova/localização');

Por padrão, o Flight enviará um código de status HTTP 303 ("See Other"). Você pode opcionalmente definir um código personalizado:

Flight::redirect('/nova/localização', 401);

Parando

Você pode parar o framework a qualquer momento chamando o método halt:

Flight::halt();

Você também pode especificar um código de HTTP opcional e mensagem:

Flight::halt(200, 'Já volto...');

Chamar halt descartará qualquer conteúdo de resposta até esse ponto. Se quiser parar o framework e enviar a resposta atual, use o método stop:

Flight::stop();

Limpar Dados de Resposta

Você pode limpar o corpo e os cabeçalhos da resposta usando o método clear(). Isto limpará quaisquer cabeçalhos atribuídos à resposta, limpará o corpo da resposta e definirá o código de status para 200.

Flight::response()->clear();

Limpar Somente o Corpo da Resposta

Se quiser limpar apenas o corpo da resposta, pode usar o método clearBody():

// Isto ainda manterá quaisquer cabeçalhos definidos no objeto response().
Flight::response()->clearBody();

Cache HTTP

O Flight fornece suporte embutido para caching a nível HTTP. Se a condição de cache for atendida, o Flight retornará uma resposta HTTP 304 Not Modified. Da próxima vez que o cliente solicitar o mesmo recurso, será solicitado a usar sua versão em cache local.

Cache a Nível de Rota

Se desejar armazenar em cache toda a sua resposta, pode usar o método cache() e passar o tempo de cacheamento.

// Isto vai armazenar em cache a resposta por 5 minutos
Flight::route('/notícias', function () {
  Flight::response()->cache(time() + 300);
  echo 'Este conteúdo será armazenado em cache.';
});

// Alternativamente, você pode usar uma string que passaria
// para o método strtotime()
Flight::route('/notícias', function () {
  Flight::response()->cache('+5 minutos');
  echo 'Este conteúdo será armazenado em cache.';
});

Última Modificação

Você pode usar o método lastModified e passar um carimbo de data UNIX para definir a data e hora em que uma página foi modificada pela última vez. O cliente continuará usando seu cache até o valor da última modificação ser alterado.

Flight::route('/notícias', function () {
  Flight::lastModified(1234567890);
  echo 'Este conteúdo será armazenado em cache.';
});

ETag

O cache do ETag é semelhante ao Última Modificação, exceto que você pode especificar qualquer identificador desejado para o recurso:

Flight::route('/notícias', function () {
  Flight::etag('meu-id-único');
  echo 'Este conteúdo será armazenado em cache.';
});

Lembre-se que chamar lastModified ou etag definirá e verificará o valor em cache. Se o valor em cache for o mesmo entre as solicitações, o Flight enviará imediatamente uma resposta HTTP 304 e interromperá o processamento.

Baixar um Arquivo

Há um método auxiliar para baixar um arquivo. Você pode usar o método download e passar o caminho.

Flight::route('/baixar', function () {
  Flight::download('/caminho/para/arquivo.txt');
});

Learn/frameworkinstance

Instância do Framework

Em vez de executar o Flight como uma classe estática global, você pode executá-lo opcionalmente como uma instância de objeto.

require 'flight/autoload.php';

$app = Flight::app();

$app->route('/', function () {
  echo 'olá mundo!';
});

$app->start();

Portanto, em vez de chamar o método estático, você chamaria o método de instância com o mesmo nome no objeto Engine.

Learn/redirects

Redirecionamentos

Você pode redirecionar a solicitação atual usando o método redirect e passando uma nova URL:

Flight::redirect('/novo/local');

Por padrão, o Flight envia um código de status HTTP 303. Você pode opcionalmente definir um código personalizado:

Flight::redirect('/novo/local', 401);

Learn/views

Vistas

Flight fornece alguma funcionalidade básica de modelagem por padrão. Para exibir uma vista chame o método render com o nome do arquivo de modelo e dados de modelo opcionais:

Flight::render('hello.php', ['name' => 'Bob']);

Os dados do modelo que você passa são automaticamente injetados no modelo e podem ser referenciados como uma variável local. Os arquivos de modelo são simplesmente arquivos PHP. Se o conteúdo do arquivo de modelo hello.php for:

Olá, <?= $name ?>!

A saída seria:

Olá, Bob!

Você também pode definir manualmente variáveis de visualização usando o método set:

Flight::view()->set('name', 'Bob');

A variável name agora está disponível em todas as suas visualizações. Então você pode simplesmente fazer:

Flight::render('hello');

Observe que ao especificar o nome do modelo no método render, você pode omitir a extensão .php.

Por padrão, o Flight procurará um diretório views para arquivos de modelo. Você pode definir um caminho alternativo para seus modelos configurando o seguinte:

Flight::set('flight.views.path', '/caminho/para/views');

Layouts

É comum que sites tenham um único arquivo de modelo de layout com conteúdo alternante. Para renderizar conteúdo a ser usado em um layout, você pode passar um parâmetro opcional para o método render.

Flight::render('header', ['heading' => 'Olá'], 'headerContent');
Flight::render('body', ['body' => 'Mundo'], 'bodyContent');

Sua visualização então terá variáveis salvas chamadas headerContent e bodyContent. Você pode então renderizar seu layout fazendo:

Flight::render('layout', ['title' => 'Página Inicial']);

Se os arquivos de modelo forem assim:

header.php:

<h1><?= $heading ?></h1>

body.php:

<div><?= $body ?></div>

layout.php:

<html>
  <head>
    <title><?= $title ?></title>
  </head>
  <body>
    <?= $headerContent ?>
    <?= $bodyContent ?>
  </body>
</html>

A saída seria:

<html>
  <head>
    <title>Página Inicial</title>
  </head>
  <body>
    <h1>Olá</h1>
    <div>Mundo</div>
  </body>
</html>

Vistas Personalizadas

O Flight permite que você substitua a engine de visualização padrão simplesmente registrando sua própria classe de visualização. Veja como você usaria o Smarty template engine para suas visualizações:

// Carregar biblioteca do Smarty
require './Smarty/libs/Smarty.class.php';

// Registrar Smarty como a classe de visualização
// Também passar uma função de retorno de chamada para configurar o Smarty ao carregar
Flight::register('view', Smarty::class, [], function (Smarty $smarty) {
  $smarty->setTemplateDir('./templates/');
  $smarty->setCompileDir('./templates_c/');
  $smarty->setConfigDir('./config/');
  $smarty->setCacheDir('./cache/');
});

// Atribuir dados do modelo
Flight::view()->assign('name', 'Bob');

// Exibir o modelo
Flight::view()->display('hello.tpl');

Para completude, você também deve substituir o método de renderização padrão do Flight:

Flight::map('render', function(string $template, array $data): void {
  Flight::view()->assign($data);
  Flight::view()->display($template);
});

Learn/templates

Vistas HTML y Plantillas

Flight proporciona por defecto alguna funcionalidad básica de plantillas.

Si necesita necesidades de plantillas más complejas, consulte los ejemplos de Smarty y Latte en la sección de Vistas Personalizadas.

Motor de Vistas por Defecto

Para mostrar una plantilla de vista, llame al método render con el nombre del archivo de la plantilla y datos de plantilla opcionales:

Flight::render('hello.php', ['name' => 'Bob']);

Los datos de plantilla que pasa 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:

¡Hola, <?= $name ?>!

La salida sería:

¡Hola, Bob!

También puede establecer manualmente las 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:

Flight::render('hello');

Tenga en cuenta que al especificar el nombre de la plantilla en el método de representación, puede omitir la extensión .php.

De forma predeterminada, Flight buscará un directorio views para archivos de plantilla. Puede establecer una ruta alternativa para sus plantillas configurando lo siguiente:

Flight::set('flight.views.path', '/ruta/a/views');

Diseños

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');

Entonces su vista tendrá variables guardadas llamadas headerContent y bodyContent. Luego puede renderizar su diseño haciendo:

Flight::render('layout', ['title' => 'Página de inicio']);

Si los archivos de plantilla se ven así:

header.php:

<h1><?= $heading ?></h1>

body.php:

<div><?= $body ?></div>

layout.php:

<html>
  <head>
    <title><?= $title ?></title>
  </head>
  <body>
    <?= $heaterContent ?>
    <?= $bodyContent ?>
  </body>
</html>

La salida sería:

<html>
  <head>
    <title>Página de inicio</title>
  </head>
  <body>
    <h1>Hola</h1>
    <div>Mundo</div>
  </body>
</html>

Motores de Vistas Personalizadas

Flight le permite cambiar el motor de vista predeterminado simplemente registrando su propia clase de vista.

Smarty

Así es como usaría el Smarty motor de plantillas para sus vistas:

// Cargar biblioteca de Smarty
require './Smarty/libs/Smarty.class.php';

// Registrar Smarty como la 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/');
});

// Asignar datos de plantilla
Flight::view()->assign('name', 'Bob');

// Mostrar la plantilla
Flight::view()->display('hello.tpl');

Para completar, también debe anular el método de representación predeterminado de Flight:

Flight::map('render', function(string $template, array $data): void {
  Flight::view()->assign($data);
  Flight::view()->display($template);
});

Latte

Así es como usaría el Latte motor de plantillas para sus vistas:

// Registrar Latte como la clase de vista
// También pase una función de devolución de llamada para configurar Latte al cargar
Flight::register('view', Latte\Engine::class, [], function (Latte\Engine $latte) {
  // Aquí es donde Latte almacenará en caché sus plantillas para acelerar las cosas
  // ¡Una característica interesante de Latte es que actualiza automáticamente su
  // caché cuando realiza cambios en sus plantillas!
  $latte->setTempDirectory(__DIR__ . '/../cache/');

  // Indique a Latte dónde estará el directorio raíz de sus vistas.
  $latte->setLoader(new \Latte\Loaders\FileLoader(__DIR__ . '/../views/'));
});

// Y envuélvalo para que pueda 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);
});

Learn/flight_vs_fat_free

Voo vs Sem Gordura

O que é Fat-Free?

Sem Gordura (afetuosamente conhecido como SG) é um microframework PHP poderoso, mas fácil de usar, projetado para ajudá-lo a construir aplicativos web dinâmicos e robustos - rapidamente!

Voo se compara com Sem Gordura de muitas maneiras e provavelmente é o parente mais próximo em termos de recursos e simplicidade. Sem Gordura tem muitos recursos que Voo não tem, mas também tem muitos recursos que Voo tem. Sem Gordura está começando a mostrar sua idade e não é tão popular quanto já foi.

As atualizações estão se tornando menos frequentes e a comunidade não é mais tão ativa quanto já foi. O código é simples o suficiente, mas às vezes a falta de disciplina sintática pode tornar difícil de ler e entender. Ele funciona para o PHP 8.3, mas o código em si ainda parece que pertence ao PHP 5.3.

Prós em comparação com Voo

• Sem Gordura tem um pouco mais de estrelas no GitHub do que Voo.
• Sem Gordura tem uma documentação decente, mas falta clareza em algumas áreas.
• Sem Gordura tem alguns recursos escassos como tutoriais do YouTube e artigos online que podem ser usados para aprender o framework.
• Sem Gordura tem alguns plugins úteis integrados que às vezes são úteis.
• Sem Gordura tem um ORM integrado chamado Mapper que pode ser usado para interagir com seu banco de dados. Voo tem active-record.
• Sem Gordura tem Sessões, Cache e localização embutidos. Voo requer que você use bibliotecas de terceiros, mas está coberto na documentação.
• Sem Gordura tem um pequeno grupo de plugins criados pela comunidade que podem ser usados para estender o framework. Voo tem alguns cobertos na documentação e páginas de exemplos.
• Sem Gordura assim como Voo não possui dependências.
• Sem Gordura assim como Voo é voltado para dar ao desenvolvedor controle sobre seu aplicativo e uma experiência de desenvolvedor simples.
• Sem Gordura mantém compatibilidade com versões anteriores como Voo faz (parcialmente porque as atualizações estão se tornando menos frequentes menos frequentes).
• Sem Gordura assim como Voo é destinado a desenvolvedores que estão se aventurando no mundo dos frameworks pela primeira vez.
• Sem Gordura tem um mecanismo de modelo integrado que é mais robusto do que o mecanismo de modelo do Voo. Voo recomenda Latte para realizar isso.
• Sem Gordura possui um comando de tipo CLI único "route" onde você pode construir aplicativos CLI dentro do próprio Sem Gordura e tratá-lo como uma solicitação GET. Voo realiza isso com runway.

Contras em comparação com Voo

• Sem Gordura tem alguns testes de implementação e até possui sua própria classe de teste que é muito básica. No entanto, não é 100% testado unitariamente como Voo é.
• Você precisa usar um mecanismo de busca como o Google para realmente pesquisar o site de documentação.
• Voo tem modo escuro em seu site de documentação. (microfone derrubado)
• Sem Gordura tem alguns módulos que são lamentavelmente não mantidos.
• Voo tem um PdoWrapper simples que é um pouco mais simples do que a classe DB\SQL integrada do Sem Gordura.
• Voo tem um plugin de permissões que pode ser usado para proteger seu aplicativo. Slim requer que você use uma biblioteca de terceiros.
• Voo tem um ORM chamado active-record que parece mais com um ORM do que o Mapper do Sem Gordura. O benefício adicional do active-record é que você pode definir relacionamentos entre registros para junções automáticas onde o Mapper do Sem Gordura requer que você crie visualizações SQL.
• Surpreendentemente, Sem Gordura não tem um espaço de nomes raiz. Voo tem espaço de nomes o tempo todo para não colidir com seu próprio código. a classe Cache é o maior infrator aqui.
• Sem Gordura não possui middleware. Em vez disso, existem ganchos beforeroute e afterroute que podem ser usados para filtrar solicitações e respostas em controladores.
• Sem Gordura não pode agrupar rotas.
• Sem Gordura possui um manipulador de contêiner de injeção de dependência, mas a documentação é incrivelmente escassa sobre como usá-lo.
• Depurar pode ficar um pouco complicado, uma vez que basicamente tudo é armazenado no que é chamado de HIVE

Learn/extending

Extensão

Flight é projetado para ser um framework extensível. O framework vem com um conjunto de métodos e componentes padrão, mas permite que você mapeie seus próprios métodos, registre suas próprias classes ou até mesmo substitua classes e métodos existentes.

Se você está procurando por um DIC (Dependency Injection Container), vá para a página Dependency Injection Container.

Mapeamento de Métodos

Para mapear seu próprio método personalizado simples, você usa a função map:

// Mapeie seu método
Flight::map('hello', function (string $name) {
  echo "olá $name!";
});

// Chame seu método personalizado
Flight::hello('Bob');

Embora seja possível criar métodos personalizados simples, é recomendado apenas criar funções padrão em PHP. Isso tem autocompletar em IDEs e é mais fácil de ler. O equivalente do código acima seria:

function hello(string $name) {
  echo "olá $name!";
}

hello('Bob');

Isso é mais utilizado quando você precisa passar variáveis para o método para obter um valor esperado. Usando o método register() como mostrado abaixo é mais para passar configuração e então chamar sua classe pré-configurada.

Registrando Classes

Para registrar sua própria classe e configurá-la, você usa a função register:

// Registre sua classe
Flight::register('user', User::class);

// Obtenha uma instância de sua classe
$user = Flight::user();

O método de registro também permite que você passe parâmetros para o construtor de sua classe Assim, quando você carrega sua classe personalizada, ela será pré-inicializada. Você pode definir os parâmetros do construtor passando um array adicional. Aqui está um exemplo de carregar uma conexão de banco de dados:

// Registrar classe com parâmetros do construtor
Flight::register('db', PDO::class, ['mysql:host=localhost;dbname=test', 'user', 'pass']);

// Obtenha uma instância de sua classe
// Isso criará um objeto com os parâmetros definidos
//
// new PDO('mysql:host=localhost;dbname=test','user','pass');
//
$db = Flight::db();

// e se você precisasse mais tarde em seu código, basta chamar o mesmo método novamente
class SomeController {
  public function __construct() {
    $this->db = Flight::db();
  }
}

Se você passar um parâmetro de retorno de chamada adicional, ele será executado imediatamente após a construção da classe. Isso permite que você execute quaisquer procedimentos de configuração para o novo objeto. A função de retorno de chamada recebe um parâmetro, uma instância do novo objeto.

// O retorno de chamada receberá o objeto que foi construído
Flight::register(
  'db',
  PDO::class,
  ['mysql:host=localhost;dbname=test', 'user', 'pass'],
  function (PDO $db) {
    $db->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
  }
);

Por padrão, toda vez que você carrega sua classe, você obterá uma instância compartilhada. Para obter uma nova instância de uma classe, basta passar false como parâmetro:

// Instância compartilhada da classe
$compartilhado = Flight::db();

// Nova instância da classe
$nova = Flight::db(false);

Lembre-se de que os métodos mapeados têm precedência sobre as classes registradas. Se você declarar ambos com o mesmo nome, apenas o método mapeado será invocado.

Sobrepondo Métodos do Framework

Flight permite que você sobreponha sua funcionalidade padrão para atender às suas próprias necessidades, sem ter que modificar nenhum código. Você pode ver todos os métodos que você pode sobrepor aqui.

Por exemplo, quando o Flight não consegue corresponder uma URL a uma rota, ele invoca o método notFound que envia uma resposta genérica de HTTP 404. Você pode substituir esse comportamento usando o método map:

Flight::map('notFound', function() {
  // Mostrar página de erro personalizada 404
  include 'errors/404.html';
});

Flight também permite que você substitua componentes centrais do framework. Por exemplo, você pode substituir a classe de Router padrão por sua própria classe personalizada:

// Registre sua classe personalizada
Flight::register('router', MyRouter::class);

// Quando o Flight carrega a instância do Router, ele carregará sua classe
$myrouter = Flight::router();

Métodos do Framework como map e register não podem ser sobrepostos. Você irá receber um erro se tentar fazer isso.

Learn/json

# JSON

Flight fornece suporte para o envio de respostas JSON e JSONP. Para enviar uma resposta JSON, você
passa alguns dados a serem codificados em JSON:

```php
Flight::json(['id' => 123]);

Para solicitações JSONP, você pode passar opcionalmente o nome do parâmetro de consulta que está usando para definir sua função de retorno de chamada:

Flight::jsonp(['id' => 123], 'q');

Portanto, ao fazer uma solicitação GET usando ?q=my_func, você deve receber a saída:

my_func({"id":123});

Se você não passar um nome de parâmetro de consulta, ele será padrão para jsonp.

Learn/flight_vs_slim

Comparação entre Flight e Slim

O que é o Slim?

Slim é um microframework PHP que ajuda você a escrever rapidamente aplicações web e APIs simples, porém poderosas.

Muita da inspiração para algumas das funcionalidades da versão 3 do Flight na verdade veio do Slim. Agrupar rotas e executar middleware em uma ordem específica são duas funcionalidades que foram inspiradas pelo Slim. O Slim v3 foi lançado voltado para a simplicidade, mas houve críticas mistas em relação ao v4.

Prós em comparação com o Flight

• O Slim tem uma comunidade maior de desenvolvedores, que por sua vez criam módulos úteis para ajudar você a não reinventar a roda.
• O Slim segue muitas interfaces e padrões comuns na comunidade PHP, o que aumenta a interoperabilidade.
• O Slim possui documentação decente e tutoriais que podem ser usados para aprender o framework (nada comparado ao Laravel ou Symfony, no entanto).
• O Slim possui diversos recursos como tutoriais no YouTube e artigos online que podem ser usados para aprender o framework.
• O Slim permite que você use os componentes que desejar para lidar com as funcionalidades de roteamento principais, pois é compatível com PSR-7.

Contras em comparação com o Flight

• Surpreendentemente, o Slim não é tão rápido quanto você imagina que seria para um microframework. Consulte os testes do TechEmpower para obter mais informações.
• O Flight é voltado para um desenvolvedor que deseja construir uma aplicação web leve, rápida e fácil de usar.
• O Flight não possui dependências, enquanto que o Slim possui algumas dependências que você precisa instalar.
• O Flight é direcionado para a simplicidade e facilidade de uso.
• Uma das funcionalidades principais do Flight é fazer o melhor possível para manter a compatibilidade com versões anteriores. A transição do Slim da v3 para a v4 foi uma mudança drástica.
• O Flight é destinado a desenvolvedores que estão se aventurando no mundo dos frameworks pela primeira vez.
• O Flight também pode lidar com aplicações de nível empresarial, mas não possui tantos exemplos e tutoriais quanto o Slim. Também exigirá mais disciplina por parte do desenvolvedor para manter as coisas organizadas e bem estruturadas.
• O Flight dá mais controle ao desenvolvedor sobre a aplicação, enquanto que o Slim pode introduzir alguma mágica nos bastidores.
• O Flight possui um simples PdoWrapper que pode ser usado para interagir com seu banco de dados. O Slim exige que você utilize uma biblioteca de terceiros.
• O Flight possui um plugin de permissões que pode ser usado para proteger sua aplicação. O Slim exige que você utilize uma biblioteca de terceiros.
• O Flight possui um ORM chamado active-record que pode ser usado para interagir com seu banco de dados. O Slim exige que você utilize uma biblioteca de terceiros.
• O Flight possui uma aplicação CLI chamada runway que pode ser usada para executar sua aplicação a partir da linha de comando. O Slim não possui.

Learn/autoloading

Carregamento Automático

O carregamento automático é um conceito em PHP onde você especifica um diretório ou diretórios para carregar classes. Isso é muito mais benéfico do que usar require ou include para carregar classes. Também é um requisito para usar pacotes do Composer.

Por padrão, qualquer classe Flight é carregada automaticamente graças ao Composer. No entanto, se você deseja carregar suas próprias classes, pode usar o método Flight::path() para especificar um diretório para carregar classes.

Exemplo Básico

Vamos assumir que temos uma estrutura de diretórios como a seguinte:

# Caminho de Exemplo
/home/user/project/my-flight-project/
├── app
│   ├── cache
│   ├── config
│   ├── controllers - contém os controladores para este projeto
│   ├── translations
│   ├── UTILS - contém classes apenas para esta aplicação (tudo em maiúsculas de propósito para um exemplo posterior)
│   └── views
└── public
    └── css
    └── js
    └── index.php

Você pode especificar cada diretório a ser carregado da seguinte maneira:

/**
 * public/index.php
 */

// Adicionar um caminho ao carregador automático
Flight::path(__DIR__.'/../app/controllers/');
Flight::path(__DIR__.'/../app/utils/');

/**
 * app/controllers/MyController.php
 */

// sem necessidade de namespace

// Todas as classes carregadas automaticamente são recomendadas a serem em Pascal Case (cada palavra capitalizada, sem espaços)
// A partir da versão 3.7.2, você pode usar Pascal_Snake_Case para os nomes de suas classes executando Loader::setV2ClassLoading(false);
class MyController {

    public function index() {
        // fazer algo
    }
}

Namespaces

Se você tiver namespaces, na verdade se torna muito fácil implementar isso. Você deve usar o método Flight::path() para especificar o diretório raiz (não o diretório do documento ou pasta public/) de sua aplicação.

/**
 * public/index.php
 */

// Adicionar um caminho ao carregador automático
Flight::path(__DIR__.'/../');

Agora, veja como seu controlador poderia ser. Observe o exemplo abaixo, mas preste atenção aos comentários para informações importantes.

/**
 * app/controllers/MyController.php
 */

// namespaces são necessários
// os namespaces são iguais à estrutura de diretórios
// os namespaces devem seguir o mesmo padrão de caso que a estrutura de diretórios
// os namespaces e diretórios não podem ter nenhum sublinhado (a menos que Loader::setV2ClassLoading(false) seja definido)
namespace app\controllers;

// Todas as classes carregadas automaticamente são recomendadas a serem em Pascal Case (cada palavra capitalizada, sem espaços)
// A partir da versão 3.7.2, você pode usar Pascal_Snake_Case para os nomes de suas classes executando Loader::setV2ClassLoading(false);
class MyController {

    public function index() {
        // fazer algo
    }
}

E se você quiser carregar automaticamente uma classe em seu diretório de utils, você faria basicamente a mesma coisa:

/**
 * app/UTILS/ArrayHelperUtil.php
 */

// o namespace deve corresponder à estrutura de diretórios e caso (observe que o diretório UTILS está todo em maiúsculas
//     como na árvore de arquivos acima)
namespace app\UTILS;

class ArrayHelperUtil {

    public function changeArrayCase(array $array) {
        // fazer algo
    }
}

Sublinhados em Nomes de Classe

A partir da versão 3.7.2, você pode usar Pascal_Snake_Case para os nomes de suas classes executando Loader::setV2ClassLoading(false);. Isso permitirá que você use sublinhados em seus nomes de classe. Isso não é recomendado, mas está disponível para aqueles que precisam.

/**
 * public/index.php
 */

// Adicionar um caminho ao carregador automático
Flight::path(__DIR__.'/../app/controllers/');
Flight::path(__DIR__.'/../app/utils/');
Loader::setV2ClassLoading(false);

/**
 * app/controllers/My_Controller.php
 */

// sem necessidade de namespace

class My_Controller {

    public function index() {
        // fazer algo
    }
}

Learn/troubleshooting

# Solução de problemas

Esta página irá ajudá-lo a resolver problemas comuns que você pode encontrar ao usar o Flight.

## Problemas Comuns

### 404 Não Encontrado ou Comportamento de Rota Inesperado

Se você estiver vendo um erro 404 Não Encontrado (mas jura pela sua vida que está realmente lá e não é um erro de digitação) isso poderia 
realmente ser um problema com você retornando um valor no ponto final da sua rota em vez de apenas ecoá-lo. A razão para isso é intencional, 
mas pode pegar alguns desenvolvedores de surpresa.

```php

Flight::route('/hello', function(){
    // Isso pode causar um erro 404 Não Encontrado
    return 'Olá Mundo';
});

// O que você provavelmente quer
Flight::route('/hello', function(){
    echo 'Olá Mundo';
});

A razão para isso é por causa de um mecanismo especial incorporado no roteador que trata a saída de retorno como um sinal para "ir para a próxima rota". Você pode ver o comportamento documentado na seção de Roteamento.

Classe Não Encontrada (autoload não funcionando)

Podem haver algumas razões para isso não estar funcionando. Abaixo estão alguns exemplos, mas certifique-se também de verificar a seção de autoload.

Nome do Arquivo Incorreto

O mais comum é que o nome da classe não corresponda ao nome do arquivo.

Se você tem uma classe chamada MyClass, então o arquivo deve ser chamado MyClass.php. Se você tem uma classe chamada MyClass e o arquivo é chamado myclass.php então o autoload não será capaz de encontrá-lo.

Namespace Incorreto

Se estiver usando namespaces, então o namespace deve corresponder à estrutura de diretórios.

// código

// se o seu MyController estiver no diretório app/controllers e estiver em um namespace
// isso não funcionará
Flight::route('/hello', 'MyController->hello');

// você precisará escolher uma dessas opções
Flight::route('/hello', 'app\controllers\MyController->hello');
// ou se você tiver um comando use no topo

use app\controllers\MyController;

Flight::route('/hello', [ MyController::class, 'hello' ]);
// também pode ser escrito
Flight::route('/hello', MyController::class.'->hello');
// também...
Flight::route('/hello', [ 'app\controllers\MyController', 'hello' ]);

path() não definido

No aplicativo skeleton, isso é definido dentro do arquivo config.php, mas para que suas classes sejam encontradas, você precisa garantir que o método path() esteja definido (provavelmente na raiz do seu diretório) antes de tentar usá-lo.

// Adicione um caminho ao autoload
Flight::path(__DIR__.'/../');

Install

Instalação

Baixe os arquivos.

Se estiver a usar Composer, pode executar o seguinte comando:

composer require flightphp/core

OU então pode baixar os arquivos diretamente e extrair para o seu diretório web.

Configure o seu servidor web.

Apache

Para o Apache, edite o seu ficheiro .htaccess com o seguinte:

RewriteEngine On
RewriteCond %{REQUEST_FILENAME} !-f
RewriteCond %{REQUEST_FILENAME} !-d
RewriteRule ^(.*)$ index.php [QSA,L]

Nota: Se necessitar de utilizar o Flight numa subpasta, adicione a linha RewriteBase /subdir/ logo após RewriteEngine On.

Nota: Se quiser proteger todos os ficheiros do servidor, como um ficheiro de bd ou env. Coloque isto no seu ficheiro .htaccess:

RewriteEngine On
RewriteRule ^(.*)$ index.php

Nginx

Para o Nginx, adicione o seguinte à declaração do seu servidor:

server {
  location / {
    try_files $uri $uri/ /index.php;
  }
}

Crie o seu ficheiro index.php.

<?php

// Se estiver a usar o Composer, requer o autoloader.
require 'vendor/autoload.php';
// se não estiver a usar o Composer, carregue o framework diretamente
// require 'flight/Flight.php';

// Depois defina uma rota e atribua uma função para lidar com o pedido.
Flight::route('/', function () {
  echo 'hello world!';
});

// Por fim, inicie o framework.
Flight::start();

License

The MIT License (MIT)

Direitos de autor © 2024 @mikecao, @n0nag0n

É concedida permissão, gratuitamente, a qualquer pessoa que obtenha uma cópia deste software e documentação associada (arquivo PDF), para lidar com o software sem restrições, incluindo, sem limitação, os direitos de usar, copiar, modificar, mesclar, publicar, distribuir, sublicenciar e/ou vender cópias do software, e permitir que as pessoas a quem o software é fornecido o façam, sujeito às seguintes condições:

O aviso de direitos de autor acima e este aviso de permissão devem ser incluídos em todas as cópias ou partes substanciais do software.

O SOFTWARE É FORNECIDO "COMO ESTÁ", SEM GARANTIA DE QUALQUER TIPO, EXPRESSA OU IMPLÍCITA, INCLUINDO, MAS NÃO SE LIMITANDO ÀS GARANTIAS DE COMERCIALIZAÇÃO, ADEQUAÇÃO A UM FIM ESPECÍFICO E NÃO VIOLAÇÃO. EM NENHUM CASO OS AUTORES OU DETENTORES DE DIREITOS AUTORAIS SERÃO RESPONSÁVEIS POR QUALQUER REIVINDICAÇÃO, DANOS OU OUTRA RESPONSABILIDADE, SEJA EM UMA AÇÃO DE CONTRATO, DELITO OU DE OUTRA FORMA, DECORRENTE DE, FORA DE OU EM CONEXÃO COM O SOFTWARE OU O USO OU OUTROS ACORDOS NO SOFTWARE.

About

O que é o Flight?

Flight é um framework rápido, simples e extensível para PHP. É bastante versátil e pode ser usado para construir qualquer tipo de aplicação web. É construído com simplicidade em mente e é escrito de uma forma que é fácil de entender e utilizar.

Flight é um ótimo framework para iniciantes que são novos no PHP e desejam aprender como construir aplicações web. Também é um ótimo framework para desenvolvedores experientes que desejam ter mais controle sobre suas aplicações web. É projetado para construir facilmente uma API RESTful, uma aplicação web simples ou uma aplicação web complexa.

Início Rápido

<?php

// se instalado com composer
require 'vendor/autoload.php';
// ou se instalado manualmente por arquivo zip
// require 'flight/Flight.php';

Flight::route('/', function() {
  echo 'olá mundo!';
});

Flight::route('/json', function() {
  Flight::json(['hello' => 'world']);
});

Flight::start();

Simples o suficiente, certo? Saiba mais sobre o Flight na documentação!

App Esqueleto/Boilerplate

Há um app de exemplo que pode ajudá-lo a começar com o Framework Flight. Acesse flightphp/skeleton para instruções sobre como começar! Você também pode visitar a página exemplos para se inspirar em algumas das coisas que você pode fazer com o Flight.

Comunidade

Estamos no Chat do Matrix, converse conosco em #flight-php-framework:matrix.org.

Contribuição

Existem duas maneiras pelas quais você pode contribuir com o Flight:

1. Você pode contribuir com o framework central visitando o repositório principal.
2. Você pode contribuir com a documentação. Este site de documentação é hospedado no Github. Se você notar um erro ou quiser aprimorar algo, sinta-se à vontade para corrigir e enviar um pull request! Tentamos acompanhar as coisas, mas atualizações e traduções de idiomas são bem-vindas.

Requisitos

Flight requer PHP 7.4 ou superior.

Nota: PHP 7.4 é suportado porque no momento atual da escrita (2024), o PHP 7.4 é a versão padrão para algumas distribuições LTS do Linux. Forçar a migração para o PHP >8 causaria muitos problemas para esses usuários. O framework também suporta PHP >8.

Licença

O Flight é lançado sob a licença MIT.

Awesome-plugins/php_cookie

Cookies

overclokk/cookie é uma biblioteca simples para gerenciar cookies em seu aplicativo.

Instalação

A instalação é simples com o composer.

composer require overclokk/cookie

Uso

O uso é tão simples quanto registrar um novo método na classe Flight.

use Overclokk\Cookie\Cookie;

/*
 * Defina em seu arquivo de inicialização ou public/index.php
 */

Flight::register('cookie', Cookie::class);

/**
 * ExampleController.php
 */

class ExampleController {
    public function login() {
        // Defina um cookie

        // você vai querer que isso seja falso para obter uma nova instância
        // use o comentário abaixo se quiser autocompletar
        /** @var \Overclokk\Cookie\Cookie $cookie */
        $cookie = Flight::cookie(false);
        $cookie->set(
            'stay_logged_in', // nome do cookie
            '1', // o valor que você deseja definir
            86400, // número de segundos que o cookie deve durar
            '/', // caminho em que o cookie estará disponível
            'example.com', // domínio em que o cookie estará disponível
            true, // o cookie só será transmitido por uma conexão HTTPS segura
            true // o cookie só estará disponível por meio do protocolo HTTP
        );

        // opcionalmente, se você quiser manter os valores padrão
        // e ter uma maneira rápida de definir um cookie por um longo tempo
        $cookie->forever('stay_logged_in', '1');
    }

    public function home() {
        // Verifique se você tem o cookie
        if (Flight::cookie()->has('stay_logged_in')) {
            // colocá-los na área do painel, por exemplo.
            Flight::redirect('/dashboard');
        }
    }
}

Awesome-plugins/php_encryption

Criptografia PHP

defuse/php-encryption é uma biblioteca que pode ser usada para criptografar e descriptografar dados. Começar a usar é bastante simples para começar a criptografar e descriptografar dados. Eles têm um ótimo tutorial que ajuda a explicar o básico de como usar a biblioteca, bem como importantes implicações de segurança relacionadas à criptografia.

Instalação

A instalação é simples com o composer.

composer require defuse/php-encryption

Configuração

Em seguida, você precisará gerar uma chave de criptografia.

vendor/bin/generate-defuse-key

Isso vai gerar uma chave que você precisará manter em segurança. Você poderia guardar a chave em seu arquivo app/config/config.php no array no final do arquivo. Embora não seja o local perfeito, é pelo menos algo.

Uso

Agora que você tem a biblioteca e uma chave de criptografia, você pode começar a criptografar e descriptografar dados.

use Defuse\Crypto\Crypto;
use Defuse\Crypto\Key;

/*
 * Defina em seu arquivo de inicialização ou public/index.php
 */

// Método de criptografia
Flight::map('encrypt', function($dados_brutos) {
    $chave_criptografia = /* $config['encryption_key'] ou um file_get_contents de onde você colocou a chave */;
    return Crypto::encrypt($dados_brutos, Key::loadFromAsciiSafeString($chave_criptografia));
});

// Método de descriptografia
Flight::map('decrypt', function($dados_criptografados) {
    $chave_criptografia = /* $config['encryption_key'] ou um file_get_contents de onde você colocou a chave */;
    try {
        $dados_brutos = Crypto::decrypt($dados_criptografados, Key::loadFromAsciiSafeString($chave_criptografia));
    } catch (Defuse\Crypto\Exception\WrongKeyOrModifiedCiphertextException $ex) {
        // Um ataque! Ou a chave errada foi carregada, ou o texto cifrado foi
        // alterado desde que foi criado - corrompido no banco de dados ou
        // intencionalmente modificado por Eve tentando realizar um ataque.

        // ... trate este caso de uma maneira adequada à sua aplicação ...
    }
    return $dados_brutos;
});

Flight::route('/encrypt', function() {
    $dados_criptografados = Flight::encrypt('Isto é um segredo');
    echo $dados_criptografados;
});

Flight::route('/decrypt', function() {
    $dados_criptografados = '...'; // Obtenha os dados criptografados de algum lugar
    $dados_descriptografados = Flight::decrypt($dados_criptografados);
    echo $dados_descriptografados;
});

Awesome-plugins/php_file_cache

Wruczek/PHP-File-Cache

Classe standalone de cache de arquivo PHP leve e simples

Vantagens

• Leve, standalone e simples
• Todo código em um único arquivo - sem drivers desnecessários.
• Seguro - cada arquivo de cache gerado possui um cabeçalho php com die, tornando o acesso direto impossível mesmo se alguém conhecer o caminho e seu servidor não estiver configurado corretamente
• Bem documentado e testado
• Manipula corretamente a concorrência via flock
• Suporta PHP 5.4.0 - 7.1+
• Gratuito sob uma licença MIT

Clique aqui para visualizar o código.

Instalação

Instale via composer:

composer require wruczek/php-file-cache

Uso

O uso é bastante direto.

use Wruczek\PhpFileCache\PhpFileCache;

$app = Flight::app();

// Você passa o diretório no qual o cache será armazenado para o construtor
$app->register('cache', PhpFileCache::class, [ __DIR__ . '/../cache/' ], function(PhpFileCache $cache) {

    // Isso garante que o cache seja usado apenas no modo de produção
    // AMBIENTE é uma constante definida em seu arquivo de inicialização ou em outro lugar de seu aplicativo
    $cache->setDevMode(ENVIRONMENT === 'development');
});

Então você pode usá-lo em seu código assim:

// Obter instância de cache
$cache = Flight::cache();
$data = $cache->refreshIfExpired('simple-cache-test', function () {
    return date("H:i:s"); // retornar dados a serem armazenados em cache
}, 10); // 10 segundos

// ou
$data = $cache->retrieve('simple-cache-test');
if(empty($data)) {
    $data = date("H:i:s");
    $cache->store('simple-cache-test', $data, 10); // 10 segundos
}

Documentação

Visite https://github.com/Wruczek/PHP-File-Cache para ver a documentação completa e certifique-se de ver a pasta de exemplos.

Awesome-plugins/permissions

FlightPHP/Permissões

Este é um módulo de permissões que pode ser usado em seus projetos se você tiver vários papéis em seu aplicativo e cada papel tiver funcionalidades um pouco diferentes. Este módulo permite que você defina permissões para cada papel e depois verifique se o usuário atual tem permissão para acessar uma determinada página ou realizar uma determinada ação.

Clique aqui para acessar o repositório no GitHub.

Instalação

Execute composer require flightphp/permissions e pronto!

Uso

Primeiro, você precisa configurar suas permissões e, em seguida, informar ao seu aplicativo o que as permissões significam. Por fim, você verificará suas permissões com $Permissions->has(), ->can() ou is(). has() e can() têm a mesma funcionalidade, mas têm nomes diferentes para tornar seu código mais legível.

Exemplo Básico

Vamos supor que você tenha um recurso em seu aplicativo que verifica se um usuário está conectado. Você pode criar um objeto de permissões assim:

// index.php
require 'vendor/autoload.php';

// algum código 

// então você provavelmente tem algo que diz qual é o papel atual da pessoa
// provavelmente você tem algo que puxa o papel atual
// de uma variável de sessão que define isso
// depois que alguém faz o login, caso contrário eles terão um papel 'convidado' ou 'público'.
$current_role = 'admin';

// configurar permissões
$permission = new \flight\Permission($current_role);
$permission->defineRule('conectado', function($current_role) {
    return $current_role !== 'convidado';
});

// Você provavelmente vai querer persistir este objeto em algum lugar do Flight
Flight::set('permissão', $permissão);

Então em um controlador em algum lugar, você pode ter algo assim.

<?php

// algum controlador
class AlgunsController {
    public function algumaAção() {
        $permissão = Flight::get('permissão');
        if ($permissão->has('conectado')) {
            // faça algo
        } else {
            // faça algo diferente
        }
    }
}

Você também pode usar isso para rastrear se têm permissão para fazer algo em seu aplicativo. Por exemplo, se você tiver uma forma dos usuários interagirem com postagens em seu software, você pode verificar se eles têm permissão para realizar certas ações.

$current_role = 'admin';

// configurar permissões
$permission = new \flight\Permission($current_role);
$permission->defineRule('postagem', function($current_role) {
    if($current_role === 'admin') {
        $permissões = ['criar', 'ler', 'atualizar', 'apagar'];
    } else if($current_role === 'editor') {
        $permissões = ['criar', 'ler', 'atualizar'];
    } else if($current_role === 'autor') {
        $permissões = ['criar', 'ler'];
    } else if($current_role === 'contribuidor') {
        $permissões = ['criar'];
    } else {
        $permissões = [];
    }
    return $permissões;
});
Flight::set('permissão', $permissão);

Então em um controlador em algum lugar...

class ControladorDePostagem {
    public function criar() {
        $permissão = Flight::get('permissão');
        if ($permissão->can('postagem.criar')) {
            // faça algo
        } else {
            // faça algo diferente
        }
    }
}

Injetando dependências

Você pode injetar dependências no fechamento que define as permissões. Isso é útil se você tiver algum tipo de alternância, id ou qualquer outro ponto de dados que deseja verificar. O mesmo funciona para chamadas de Tipo Classe->Método, exceto que você define os argumentos no método.

Fechamentos

$Permission->defineRule('pedido', function(string $current_role, MyDependency $MyDependency = null) {
    // ... código
});

// em seu arquivo de controlador
public function criarPedido() {
    $MyDependency = Flight::myDependency();
    $permissão = Flight::get('permissão');
    if ($permissão->can('pedido.criar', $MyDependency)) {
        // faça algo
    } else {
        // faça algo diferente
    }
}

Classes

namespace MyApp;

class Permissões {

    public function pedido(string $current_role, MyDependency $MyDependency = null) {
        // ... código
    }
}

Atalho para definir permissões com classes

Você também pode usar classes para definir suas permissões. Isso é útil se você tiver muitas permissões e quiser manter seu código limpo. Você pode fazer algo assim:

<?php

// código de inicialização
$Permissões = new \flight\Permission($current_role);
$Permissões->defineRule('pedido', 'MyApp\Permissões->pedido');

// myapp/Permissões.php
namespace MyApp;

class Permissões {

    public function pedido(string $current_role, int $id_usuario) {
        // Pressupondo que você configurou isso antecipadamente
        /** @var \flight\database\PdoWrapper $db */
        $db = Flight::db();
        $permissões_permitidas = [ 'ler' ]; // todos podem visualizar um pedido
        if($current_role === 'gerente') {
            $permissões_permitidas[] = 'criar'; // gerentes podem criar pedidos
        }
        $alguma_alternancia_especial_do_db = $db->fetchField('SELECT alguma_alternancia_especial FROM ajustes WHERE id = ?', [ $id_usuario ]);
        if($alguma_alternancia_especial_do_db) {
            $permissões_permitidas[] = 'atualizar'; // se o usuário tiver uma alternância especial, ele pode atualizar pedidos
        }
        if($current_role === 'admin') {
            $permissões_permitidas[] = 'apagar'; // administradores podem excluir pedidos
        }
        return $permissões_permitidas;
    }
}

A parte legal é que também há um atalho que você pode usar (que também pode ser cacheado!!!) onde você apenas diz à classe de permissões para mapear todos os métodos de uma classe em permissões. Portanto, se você tiver um método chamado pedido() e um método chamado empresa(), esses serão mapeados automaticamente para que você possa simplesmente executar $Permissões->has('pedido.ler') ou `$Permissões->has('empresa.ler') e isso funcionará. Definir isso é muito difícil, então fique comigo aqui. Você só precisa fazer o seguinte:

Crie a classe de permissões que deseja agrupar.

class MinhasPermissões {
    public function pedido(string $current_role, int $id_pedido = 0): array {
        // código para determinar permissões
        return $array_de_permissoes;
    }

    public function empresa(string $current_role, int $id_empresa): array {
        // código para determinar permissões
        return $array_de_permissoes;
    }
}

Em seguida, torne as permissões descobríveis usando esta biblioteca.

$Permissões = new \flight\Permission($current_role);
$Permissões->defineRulesFromClassMethods(MyApp\Permissões::class);
Flight::set('permissões', $Permissões);

Finalmente, chame a permissão em sua base de código para verificar se o usuário tem permissão para realizar uma determinada permissão.

class AlgunsControlador {
    public function criarPedido() {
        if(Flight::get('permissões')->can('pedido.criar') === false) {
            die('Você não pode criar um pedido. Desculpe!');
        }
    }
}

Cache

Para habilitar o cache, consulte a simples biblioteca wruczak/phpfilecache. Um exemplo de habilitação está abaixo.

// este $app pode fazer parte do seu código, ou
// você pode simplesmente passar null e ele irá
// puxar de Flight::app() no construtor
$app = Flight::app();

// Por enquanto, aceita isso como um cache de arquivo. Outros podem ser facilmente
// adicionados no futuro. 
$Cache = new Wruczek\PhpFileCache\PhpFileCache;

$Permissões = new \flight\Permission($current_role, $app, $Cache);
$Permissões->defineRulesFromClassMethods(MyApp\Permissões::class, 3600); // 3600 é quantos segundos para armazenar em cache. Deixe isso de fora para não usar o cache

Awesome-plugins/index

Plugins Incríveis

O Flight é incrivelmente extensível. Existem vários plugins que podem ser usados para adicionar funcionalidades à sua aplicação Flight. Alguns são oficialmente suportados pela Equipe do Flight e outros são bibliotecas micro/lite para ajudá-lo a começar.

Caching

O armazenamento em cache é uma ótima maneira de acelerar a sua aplicação. Existem diversas bibliotecas de cache que podem ser usadas com o Flight.

• Wruczek/PHP-File-Cache - Classe de armazenamento em arquivo PHP leve, simples e independente.

Debugging

Depurar é crucial quando você está desenvolvendo no seu ambiente local. Existem alguns plugins que podem aprimorar a sua experiência de depuração.

• tracy/tracy - Este é um manipulador de erros completo que pode ser usado com o Flight. Possui várias painéis que podem ajudá-lo a depurar a sua aplicação. Também é muito fácil de estender e adicionar os seus próprios painéis.
• flightphp/tracy-extensions - Usado com o manipulador de erros Tracy, este plugin adiciona alguns painéis extras para ajudar na depuração especificamente em projetos do Flight.

Bancos de Dados

Os bancos de dados são a base da maioria das aplicações. É assim que você armazena e recupera dados. Algumas bibliotecas de banco de dados são simplesmente wrappers para escrever consultas e outras são ORMs completos.

• flightphp/core PdoWrapper - Wrapper PDO Oficial do Flight que faz parte do core. Este é um wrapper simples para ajudar a simplificar o processo de escrever consultas e executá-las. Não é um ORM.
• flightphp/active-record - ORM/Mapper Active Record oficial do Flight. Ótima pequena biblioteca para recuperar e armazenar dados facilmente no seu banco de dados.

Sessão

As sessões não são realmente úteis para APIs, mas para desenvolver uma aplicação web, as sessões podem ser cruciais para manter o estado e as informações de login.

• Ghostff/Session - Gerenciador de Sessão PHP (não bloqueante, flash, segmento, criptografia de sessão). Usa o open_ssl do PHP para criptografar/criptografar opcionalmente os dados da sessão.

Templating

A criação de modelos é essencial para qualquer aplicação web com uma interface de usuário. Existem várias engines de templates que podem ser usadas com o Flight.

• flightphp/core View - Esta é uma engine de templates muito básica que faz parte do core. Não é recomendado para uso se você tiver mais do que algumas páginas no seu projeto.
• latte/latte - Latte é uma engine de templates completa que é muito fácil de usar e se aproxima mais de uma sintaxe PHP do que Twig ou Smarty. Também é muito fácil de estender e adicionar os seus próprios filtros e funções.

Contribuindo

Tem um plugin que gostaria de compartilhar? Envie uma solicitação pull para adicioná-lo à lista!

Awesome-plugins/pdo_wrapper

Awesome-plugins/session

Ghostff/Session

Gerenciador de Sessão PHP (não bloqueante, flash, segmento, criptografia de sessão). Usa PHP open_ssl para criptografia/descriptografia opcional de dados de sessão. Suporta Arquivo, MySQL, Redis e Memcached.

Clique aqui para visualizar o código.

Instalação

Instale com o compositor.

composer require ghostff/session

Configuração Básica

Não é necessário passar nada para usar as configurações padrão com sua sessão. Você pode ler sobre mais configurações no [README do Github] (https://github.com/Ghostff/Session).

use Ghostff\Session\Session;

require 'vendor/autoload.php';

$app = Flight::app();

$app->register('session', Session::class);

// uma coisa a lembrar é que você deve confirmar sua sessão em cada carregamento de página
// ou você precisará executar auto_commit em sua configuração.

Exemplo Simples

Aqui está um exemplo simples de como você pode usar isso.

Flight::route('POST /login', function() {
    $session = Flight::session();

    // faça sua lógica de login aqui
    // validar senha, etc.

    // se o login for bem-sucedido
    $session->set('is_logged_in', true);
    $session->set('user', $user);

    // toda vez que você escreve na sessão, deve confirmá-la deliberadamente.
    $session->commit();
});

// Esta verificação pode estar na lógica da página restrita ou envolvida com middleware.
Flight::route('/alguma-pagina-restrita', function() {
    $session = Flight::session();

    if(!$session->get('is_logged_in')) {
        Flight::redirect('/login');
    }

    // faça sua lógica de página restrita aqui
});

// a versão do middleware
Flight::route('/alguma-pagina-restrita', function() {
    // lógica regular da página
})->addMiddleware(function() {
    $session = Flight::session();

    if(!$session->get('is_logged_in')) {
        Flight::redirect('/login');
    }
});

Exemplo Mais Complexo

Aqui está um exemplo mais complexo de como você pode usar isso.

use Ghostff\Session\Session;

require 'vendor/autoload.php';

$app = Flight::app();

// defina um caminho personalizado para o arquivo de configuração da sessão e forneça uma string aleatória para o id da sessão
$app->register('session', Session::class, [ 'caminho/para/session_config.php', bin2hex(random_bytes(32)) ], function(Session $session) {
        // ou você pode substituir manualmente as opções de configuração
        $session->updateConfiguration([
            // se deseja armazenar seus dados de sessão em um banco de dados (bom se deseja algo como, "sair de todos os dispositivos" funcionalidade)
            Session::CONFIG_DRIVER        => Ghostff\Session\Drivers\MySql::class,
            Session::CONFIG_ENCRYPT_DATA  => true,
            Session::CONFIG_SALT_KEY      => hash('sha256', 'minha-super-senha-S3CR3TA'), // por favor, mude isso para ser algo diferente
            Session::CONFIG_AUTO_COMMIT   => true, // faça isso apenas se for necessário e/ou for difícil confirmar() sua sessão.
                                                   // adicionalmente você poderia fazer Flight::after('start', function() { Flight::session()->commit(); });
            Session::CONFIG_MYSQL_DS         => [
                'driver'    => 'mysql',             # Driver de banco de dados para o dns do PDO, por exemplo (mysql:host=...;dbname=...)
                'host'      => '127.0.0.1',         # Host do banco de dados
                'db_name'   => 'meu_banco_de_dados_do_aplicativo',   # Nome do banco de dados
                'db_table'  => 'sessoes',          # Tabela do banco de dados
                'db_user'   => 'root',              # Nome de usuário do banco de dados
                'db_pass'   => '',                  # Senha do banco de dados
                'persistent_conn'=> false,          # Evite o overhead de estabelecer uma nova conexão toda vez que um script precisa se comunicar com um banco de dados, resultando em uma aplicação web mais rápida. ENCONTRE O LADO NEGATIVO VOCÊ MESMO
            ]
        ]);
    }
);

Ajuda! Meus Dados de Sessão não Estão Persistindo!

Você está definindo seus dados de sessão e eles não estão persistindo entre as solicitações? Você pode ter esquecido de confirmar seus dados de sessão. Você pode fazer isso chamando $session->commit() depois de definir seus dados de sessão.

Flight::route('POST /login', function() {
    $session = Flight::session();

    // faça sua lógica de login aqui
    // validar senha, etc.

    // se o login for bem-sucedido
    $session->set('is_logged_in', true);
    $session->set('user', $user);

    // toda vez que você escreve na sessão, deve confirmá-la deliberadamente.
    $session->commit();
});

A outra maneira de contornar isso é ao configurar seu serviço de sessão, você tem que definir auto_commit como true em sua configuração. Isso irá confirmar automaticamente seus dados de sessão após cada solicitação.

$app->register('session', Session::class, [ 'caminho/para/session_config.php', bin2hex(random_bytes(32)) ], function(Session $session) {
        $session->updateConfiguration([
            Session::CONFIG_AUTO_COMMIT   => true,
        ]);
    }
);

Além disso, você poderia fazer Flight::after('start', function() { Flight::session()->commit(); }); para confirmar seus dados de sessão após cada solicitação.

Documentação

Visite o README do Github para documentação completa. As opções de configuração são bem documentadas no arquivo default_config.php em si. O código é simples de entender se você quiser examinar este pacote por conta própria.

Awesome-plugins/runway

Pista

A Pista é uma aplicação CLI que ajuda a gerenciar suas aplicações Flight. Ela pode gerar controladores, exibir todas as rotas e mais. É baseada na excelente biblioteca adhocore/php-cli.

Clique aqui para visualizar o código.

Instalação

Instale com o composer.

composer require flightphp/runway

Configuração Básica

Na primeira execução da Pista, ela guiará você por um processo de configuração e criará um arquivo de configuração .runway.json na raiz do seu projeto. Este arquivo conterá algumas configurações necessárias para que a Pista funcione corretamente.

Utilização

A Pista possui vários comandos que você pode usar para gerenciar sua aplicação Flight. Existem duas maneiras fáceis de usar a Pista.

1. Se estiver usando o projeto esqueleto, você pode executar php runway [comando] a partir da raiz do seu projeto.
2. Se estiver usando a Pista como um pacote instalado via composer, você pode executar vendor/bin/runway [comando] a partir da raiz do seu projeto.

Para qualquer comando, você pode inserir a flag --help para obter mais informações sobre como utilizar o comando.

php runway routes --help

Aqui estão alguns exemplos:

Gerar um Controlador

Com base na configuração em seu arquivo .runway.json, a localização padrão gerará um controlador para você no diretório app/controllers/.

php runway make:controller MeuControlador

Gerar um Modelo Active Record

Com base na configuração em seu arquivo .runway.json, a localização padrão gerará um controlador para você no diretório app/records/.

php runway make:record usuários

Se por acaso você tiver a tabela usuários com o seguinte esquema: id, nome, email, criado_em, atualizado_em, um arquivo semelhante ao seguinte será criado no arquivo app/records/RegistroUsuario.php:

<?php

declare(strict_types=1);

namespace app\records;

/**
 * Classe Active Record para a tabela de usuários.
 * @link https://docs.flightphp.com/awesome-plugins/active-record
 * 
 * @property int $id
 * @property string $nome
 * @property string $email
 * @property string $criado_em
 * @property string $atualizado_em
 * // você também pode adicionar relacionamentos aqui uma vez que os definir no array $relações
 * @property RegistroEmpresa $empresa Exemplo de um relacionamento
 */
class RegistroUsuario extends \flight\ActiveRecord
{
    /**
     * @var array $relações Define os relacionamentos para o modelo
     *   https://docs.flightphp.com/awesome-plugins/active-record#relationships
     */
    protected array $relações = [];

    /**
     * Construtor
     * @param mixed $conexãoBancoDados A conexão com o banco de dados
     */
    public function __construct($conexãoBancoDados)
    {
        parent::__construct($conexãoBancoDados, 'usuários');
    }
}

Exibir Todas as Rotas

Isso exibirá todas as rotas atualmente registradas com o Flight.

php runway routes

Se desejar visualizar apenas rotas específicas, você pode inserir uma flag para filtrar as rotas.

# Exibir apenas rotas GET
php runway routes --get

# Exibir apenas rotas POST
php runway routes --post

# etc.

Personalizando a Pista

Se você está criando um pacote para o Flight ou deseja adicionar seus próprios comandos personalizados ao seu projeto, pode fazer isso criando um diretório src/commands/, flight/commands/, app/commands/ ou commands/ para o seu projeto/pacote.

Para criar um comando, você simplesmente estende a classe AbstractBaseCommand e implementa, no mínimo, um método __construct e um método execute.

<?php

declare(strict_types=1);

namespace flight\commands;

class ComandoExemplo extends AbstractBaseCommand
{
    /**
     * Construtor
     *
     * @param array<string,mixed> $config Configuração JSON de .runway-config.json
     */
    public function __construct(array $config)
    {
        parent::__construct('make:example', 'Criar um exemplo para a documentação', $config);
        $this->argument('<gif-engracado>', 'O nome do gif engraçado');
    }

    /**
     * Executa a função
     *
     * @return void
     */
    public function execute(string $controlador)
    {
        $io = $this->app()->io();

        $io->info('Criando exemplo...');

        // Faça algo aqui

        $io->ok('Exemplo criado!');
    }
}

Consulte a Documentação do adhocore/php-cli para mais informações sobre como criar seus próprios comandos personalizados em sua aplicação Flight!

Awesome-plugins/tracy_extensions

Tracy Painel de Extensões

Este é um conjunto de extensões para tornar o trabalho com o Flight um pouco mais rico.

• Flight - Analisar todas as variáveis do Flight.
• Banco de Dados - Analisar todas as consultas que foram executadas na página (se você iniciar corretamente a conexão com o banco de dados)
• Requisição - Analisar todas as variáveis $_SERVER e examinar todos os payloads globais ($_GET, $_POST, $_FILES)
• Sessão - Analisar todas as variáveis $_SESSION se as sessões estiverem ativas.

Este é o Painel

E cada painel exibe informações muito úteis sobre sua aplicação!

Clique aqui para visualizar o código.

Instalação

Execute composer require flightphp/tracy-extensions --dev e está tudo pronto!

Configuração

Há muito pouca configuração que você precisa fazer para começar. Você precisará iniciar o depurador Tracy antes de usar isso https://tracy.nette.org/en/guide:

<?php

use Tracy\Debugger;
use flight\debug\tracy\TracyExtensionLoader;

// código de inicialização
require __DIR__ . '/vendor/autoload.php';

Debugger::enable();
// Talvez você precise especificar seu ambiente com Debugger::enable(Debugger::DEVELOPMENT)

// se você usa conexões de banco de dados em seu aplicativo, há
// um wrapper PDO obrigatório para usar APENAS EM DESENVOLVIMENTO (não em produção por favor!)
// Tem os mesmos parâmetros que uma conexão PDO regular
$pdo = new PdoQueryCapture('sqlite:test.db', 'user', 'pass');
// ou se você anexar isso ao framework Flight
Flight::register('db', PdoQueryCapture::class, ['sqlite:test.db', 'user', 'pass']);
// agora, sempre que você fizer uma consulta, ela capturará o tempo, a consulta e os parâmetros

// Isso conecta os pontos
if(Debugger::$showBar === true) {
    // Isto precisa ser falso ou Tracy não pode renderizar de fato :(
    Flight::set('flight.content_length', false);
    new TracyExtensionLoader(Flight::app());
}

// mais código

Flight::start();

Configuração Adicional

Dados da Sessão

Se você tiver um manipulador de sessão personalizado (como ghostff/session), você pode passar qualquer array de dados de sessão para Tracy e ele os exibirá automaticamente para você. Você passa com a chave session_data no segundo parâmetro do construtor TracyExtensionLoader.

use Ghostff\Session\Session;

require 'vendor/autoload.php';

$app = Flight::app();

$app->register('session', Session::class);

if(Debugger::$showBar === true) {
    // Isto precisa ser falso ou Tracy não pode renderizar de fato :(
    Flight::set('flight.content_length', false);
    new TracyExtensionLoader(Flight::app(), [ 'session_data' => Flight::session()->getAll() ]);
}

// rotas e outras coisas...

Flight::start();

Latte

Se você tiver o Latte instalado em seu projeto, você pode usar o painel do Latte para analisar seus modelos. Você pode passar a instância do Latte para o construtor TracyExtensionLoader com a chave latte no segundo parâmetro.

use Latte\Engine;

require 'vendor/autoload.php';

$app = Flight::app();

$app->register('latte', Engine::class, [], function($latte) {
    $latte->setTempDirectory(__DIR__ . '/temp');

    // aqui é onde você adiciona o Painel do Latte ao Tracy
    $latte->addExtension(new Latte\Bridges\Tracy\TracyExtension);
});

if(Debugger::$showBar === true) {
    // Isto precisa ser falso ou Tracy não pode renderizar de fato :(
    Flight::set('flight.content_length', false);
    new TracyExtensionLoader(Flight::app());
}

Awesome-plugins/tracy

Tracy

Tracy é um incrível manipulador de erros que pode ser usado com Flight. Possui vários painéis que podem ajudá-lo a depurar sua aplicação. É também muito fácil de estender e adicionar seus próprios painéis. A equipe do Flight criou alguns painéis especificamente para projetos do Flight com o plugin flightphp/tracy-extensions.

Instalação

Instale com o compositor. E na verdade, você vai querer instalar isso sem a versão de desenvolvimento, já que o Tracy vem com um componente de tratamento de erros de produção.

composer require tracy/tracy

Configuração Básica

Existem algumas opções de configuração básicas para começar. Você pode ler mais sobre elas na Documentação do Tracy.

require 'vendor/autoload.php';

use Tracy\Debugger;

// Habilitar Tracy
Debugger::enable();
// Debugger::enable(Debugger::DEVELOPMENT) // às vezes você precisa ser explícito (também Debugger::PRODUCTION)
// Debugger::enable('23.75.345.200'); // você também pode fornecer um array de endereços IP

// Aqui é onde os erros e exceções serão registrados. Certifique-se de que este diretório exista e seja gravável.
Debugger::$logDirectory = __DIR__ . '/../log/';
Debugger::$strictMode = true; // exibir todos os erros
// Debugger::$strictMode = E_ALL & ~E_DEPRECATED & ~E_USER_DEPRECATED; // todos os erros exceto avisos obsoletos
if (Debugger::$showBar) {
    $app->set('flight.content_length', false); // se a barra do Debugger estiver visível, então o comprimento do conteúdo não pode ser definido pelo Flight

    // Isso é específico para a Extensão do Tracy para o Flight se você incluiu isso
    // caso contrário, comente isso.
    new TracyExtensionLoader($app);
}

Dicas Úteis

Ao depurar seu código, existem algumas funções muito úteis para exibir dados para você.

• bdump($var) - Isso irá despejar a variável na Barra do Tracy em um painel separado.
• dumpe($var) - Isso irá despejar a variável e então cessar imediatamente.

Awesome-plugins/active_record

Flight Active Record

Um registro ativo é mapear uma entidade de banco de dados para um objeto PHP. Falando claramente, se você tem uma tabela de usuários no seu banco de dados, você pode "traduzir" uma linha nessa tabela para uma classe User e um objeto $user em sua base de código. Veja exemplo básico.

Clique aqui para o repositório no GitHub.

Exemplo Básico

Vamos supor que você tenha a seguinte tabela:

CREATE TABLE users (
    id INTEGER PRIMARY KEY, 
    name TEXT, 
    password TEXT 
);

Agora você pode configurar uma nova classe para representar essa tabela:

/**
 * Uma classe ActiveRecord é geralmente singular
 * 
 * É altamente recomendável adicionar as propriedades da tabela como comentários aqui
 * 
 * @property int    $id
 * @property string $name
 * @property string $password
 */ 
class User extends flight\ActiveRecord {
    public function __construct($conexão_banco_de_dados)
    {
        // você pode defini-la assim
        parent::__construct($conexão_banco_de_dados, 'users');
        // ou desta forma
        parent::__construct($conexão_banco_de_dados, null, [ 'table' => 'users']);
    }
}

Agora veja a mágica acontecer!

// para sqlite
$conexão_banco_de_dados = new PDO('sqlite:test.db'); // isso é apenas um exemplo, provavelmente você usaria uma conexão de banco de dados real

// para mysql
$conexão_banco_de_dados = new PDO('mysql:host=localhost;dbname=test_db&charset=utf8bm4', 'nome_de_usuário', 'senha');

// ou mysqli
$conexão_banco_de_dados = new mysqli('localhost', 'nome_de_usuário', 'senha', 'test_db');
// ou mysqli com criação não baseada em objeto
$conexão_banco_de_dados = mysqli_connect('localhost', 'nome_de_usuário', 'senha', 'test_db');

$user = new User($conexão_banco_de_dados);
$user->name = 'Bobby Tables';
$user->password = password_hash('alguma senha legal');
$user->insert();
// ou $user->save();

echo $user->id; // 1

$user->name = 'Joseph Mamma';
$user->password = password_hash('outra senha legal novamente!!!');
$user->insert();
// não é possível usar $user->save() aqui senão pensará que é uma atualização!

echo $user->id; // 2

E foi tão fácil adicionar um novo usuário! Agora que há uma linha de usuário no banco de dados, como você a extrai?

$user->find(1); // encontre id = 1 no banco de dados e retorne
echo $user->name; // 'Bobby Tables'

E se você quiser encontrar todos os usuários?

$users = $user->findAll();

E com uma determinada condição?

$users = $user->like('name', '%mamma%')->findAll();

Veja como isso é divertido? Vamos instalar e começar!

Instalação

Basta instalar com o Composer

composer require flightphp/active-record 

Uso

Isso pode ser usado como uma biblioteca independente ou com o Framework PHP Flight. Totalmente com você.

Independente

Apenas certifique-se de passar uma conexão PDO para o construtor.

$conexão_pdo = new PDO('sqlite:test.db'); // isso é apenas um exemplo, provavelmente você usaria uma conexão de banco de dados real

$User = new User($conexão_pdo);

Não quer sempre definir sua conexão de banco de dados no construtor? Veja Gerenciamento de Conexão de Banco de Dados para outras ideias!

Registrar como um método no Flight

Se estiver usando o Framework PHP Flight, você pode registrar a classe ActiveRecord como serviço, mas honestamente não precisa.

Flight::register('user', 'User', [ $conexão_pdo ]);

// e então você pode usar assim em um controlador, uma função, etc.

Flight::user()->find(1);

Métodos runway

runway é uma ferramenta CLI para o Flight que possui um comando personalizado para esta biblioteca.

# Uso
php runway make:record nome_tabela_banco_dados [nome_classe]

# Exemplo
php runway make:record users

Isso criará uma nova classe no diretório app/records/ como UserRecord.php com o seguinte conteúdo:

<?php

declare(strict_types=1);

namespace app\records;

/**
 * Classe ActiveRecord para a tabela de usuários.
 * @link https://docs.flightphp.com/awesome-plugins/active-record
 *
 * @property int $id
 * @property string $username
 * @property string $email
 * @property string $password_hash
 * @property string $created_dt
 */
class UserRecord extends \flight\ActiveRecord
{
    /**
     * @var array $relations Define os relacionamentos para o modelo
     *   https://docs.flightphp.com/awesome-plugins/active-record#relationships
     */
    protected array $relations = [
        // 'nome_relacao' => [ self::HAS_MANY, 'ClasseRelacionada', 'chave_estrang.'],
    ];

    /**
     * Constructor
     * @param mixed $databaseConnection A conexão com o banco de dados
     */
    public function __construct($databaseConnection)
    {
        parent::__construct($databaseConnection, 'users');
    }
}

Funções CRUD

find($id = null) : boolean|ActiveRecord

Encontre um registro e o atribua ao objeto atual. Se você passar um $id de algum tipo, ele fará uma busca na chave primária com esse valor. Se nada for passado, encontrará apenas o primeiro registro na tabela.

Além disso, você pode passar outros métodos auxiliares para consultar sua tabela.

// encontrar um registro com algumas condições antecipadas
$user->notNull('password')->orderBy('id DESC')->find();

// encontrar um registro por um id específico
$id = 123;
$user->find($id);

findAll(): array<int,ActiveRecord>

Encontra todos os registros na tabela que você especificar.

$user->findAll();

isHydrated(): boolean (v0.4.0)

Retorna true se o registro atual foi hidratado (obtido do banco de dados).

$user->find(1);
// se um registro for encontrado com dados...
$user->isHydrated(); // true

insert(): boolean|ActiveRecord

Insere o registro atual no banco de dados.

$user = new User($conexão_banco_de_dados);
$user->name = 'demo';
$user->password = md5('demo');
$user->insert();

Chaves Primárias Baseadas em Texto

Se você tiver uma chave primária baseada em texto (como um UUID), você pode definir o valor da chave primária antes de inserir de duas maneiras.

$user = new User($conexão_banco_de_dados, [ 'primaryKey' => 'uuid' ]);
$user->uuid = 'some-uuid';
$user->name = 'demo';
$user->password = md5('demo');
$user->insert(); // ou $user->save();

ou você pode ter a chave primária gerada automaticamente para você por meio de eventos.

class User extends flight\ActiveRecord {
    public function __construct($conexão_banco_de_dados)
    {
        parent::__construct($conexão_banco_de_dados, 'users', [ 'primaryKey' => 'uuid' ]);
        // você também pode definir a chave primária assim em vez do array acima.
        $this->primaryKey = 'uuid';
    }

    protected function beforeInsert(self $self) {
        $self->uuid = uniqid(); // ou como você precisa gerar seus ids únicos
    }
}

Se você não definir a chave primária antes de inserir, ela será definida como o rowid e o banco de dados a gerará para você, mas não será persistida porque esse campo pode não existir em sua tabela. É por isso que é recomendado usar o evento para lidar automaticamente com isso para você.

update(): boolean|ActiveRecord

Atualiza o registro atual no banco de dados.

$user->greaterThan('id', 0)->orderBy('id desc')->find();
$user->email = 'test@example.com';
$user->update();

save(): boolean|ActiveRecord

Insere ou atualiza o registro atual no banco de dados. Se o registro tiver um id, ele atualizará, caso contrário, ele inserirá.

$user = new User($conexão_banco_de_dados);
$user->name = 'demo';
$user->password = md5('demo');
$user->save();

Nota: Se você tiver relacionamentos definidos na classe, ele salvará recursivamente essas relações também se elas tiverem sido definidas, instanciadas e tiverem dados sujos para atualizar. (v0.4.0 e acima)

delete(): boolean

Exclui o registro atual do banco de dados.

$user->gt('id', 0)->orderBy('id desc')->find();
$user->delete();

Você também pode excluir vários registros executando uma busca antes.

$user->like('name', 'Bob%')->delete();

dirty(array $dirty = []): ActiveRecord

Dados sujos se referem aos dados que foram alterados em um registro.

$user->greaterThan('id', 0)->orderBy('id desc')->find();

// nada está "sujo" até este ponto.

$user->email = 'test@example.com'; // agora o email é considerado "sujo" porque foi alterado.
$user->update();
// agora não há dados sujos porque foram atualizados e persistidos no banco de dados

$user->password = password_hash()'nova senha'); // agora isso é sujo
$user->dirty(); // passando nada limpará todas as entradas sujas.
$user->update(); // nada será atualizado porque nada foi considerado sujo.

$user->dirty([ 'name' => 'algo', 'password' => password_hash('uma senha diferente') ]);
$user->update(); // tanto o nome quanto a senha são atualizados.

copyFrom(array $data): ActiveRecord (v0.4.0)

Isso é um alias para o método dirty(). É um pouco mais claro o que você está fazendo.

$user->copyFrom([ 'name' => 'algo', 'password' => password_hash('uma senha diferente') ]);
$user->update(); // tanto o nome quanto a senha são atualizados.

isDirty(): boolean (v0.4.0)

Retorna true se o registro atual foi alterado.

$user->greaterThan('id', 0)->orderBy('id desc')->find();
$user->email = 'test@email.com';
$user->isDirty(); // true

reset(bool $include_query_data = true): ActiveRecord

Redefine o registro atual para seu estado inicial. Isso é realmente útil para usar em comportamentos de loop. Se você passar true, também redefinirá os dados da consulta que foram usados para encontrar o objeto atual (comportamento padrão).

$users = $user->greaterThan('id', 0)->orderBy('id desc')->find();
$user_company = new UserCompany($conexão_banco_de_dados);

foreach($users as $user) {
    $user_company->reset(); // comece com uma tela limpa
    $user_company->user_id = $user->id;
    $user_company->company_id = $some_company_id;
    $user_company->insert();
}

getBuiltSql(): string (v0.4.1)

Depois de executar um método find(), findAll(), insert(), update() ou save(), você pode obter o SQL que foi construído e usá-lo para fins de depuração.

Métodos de Consulta SQL

select(string $campo1 [, string $campo2 ... ])

Você pode selecionar apenas alguns dos campos em uma tabela, se desejar (é mais eficiente em tabelas realmente largas com muitas colunas)

$user->select('id', 'name')->find();

from(string $tabela)

Você tecnicamente pode escolher outra tabela também! Por que não?!

$user->select('id', 'name')->from('user')->find();

join(string $nome_tabela, string $condição_junção)

Você pode até juntar-se a outra tabela no banco de dados.

$user->join('contatos', 'contatos.user_id = users.id')->find();

where(string $condições_where)

Você pode definir alguns argumentos where personalizados (você não pode definir parâmetros nesta declaração where)

$user->where('id=1 AND name="demo"')->find();

Nota de Segurança - Você pode ser tentado a fazer algo como $user->where("id = '{$id}' AND name = '{$name}'")->find();. Por favor, NÃO FAÇA ISSO!!! Isso é susceptível a ataques de injeção de SQL. Há muitos artigos online, por favor, procure por "e...

Awesome-plugins/latte

Latte

Latte é um mecanismo de modelo completo que é muito fácil de usar e se sente mais próximo de uma sintaxe PHP do que Twig ou Smarty. Também é muito fácil de estender e adicionar seus próprios filtros e funções.

Instalação

Instale com o composer.

composer require latte/latte

Configuração Básica

Existem algumas opções de configuração básicas para começar. Você pode ler mais sobre elas na Documentação do Latte.

use Latte\Engine as LatteEngine;

require 'vendor/autoload.php';

$app = Flight::app();

$app->register('latte', LatteEngine::class, [], function(LatteEngine $latte) use ($app) {

    // Aqui é onde o Latte irá armazenar em cache seus modelos para acelerar as coisas
    // Uma coisa legal sobre o Latte é que ele atualiza automaticamente seu
    // cache quando você faz alterações nos seus modelos!
    $latte->setTempDirectory(__DIR__ . '/../cache/');

    // Diga ao Latte onde o diretório raiz para suas visualizações estará
    // $app->get('flight.views.path') é definido no arquivo config.php
    //   Você também pode fazer algo como `__DIR__ . '/../views/'`
    $latte->setLoader(new \Latte\Loaders\FileLoader($app->get('flight.views.path')));
});

Exemplo de Layout Simples

Aqui está um exemplo simples de um arquivo de layout. Este é o arquivo que será usado para envolver todas as suas outras visualizações.

<!-- app/views/layout.latte -->
<!doctype html>
<html lang="en">
    <head>
        <title>{$title ? $title . ' - '}My App</title>
        <link rel="stylesheet" href="style.css">
    </head>
    <body>
        <header>
            <nav>
                <!-- seus elementos de navegação aqui -->
            </nav>
        </header>
        <div id="content">
            <!-- Aqui está a mágica -->
            {block content}{/block}
        </div>
        <div id="footer">
            &copy; Direitos autorais
        </div>
    </body>
</html>

E agora temos seu arquivo que será renderizado dentro desse bloco de conteúdo:

<!-- app/views/home.latte -->
<!-- Isso diz ao Latte que este arquivo está "dentro" do arquivo layout.latte -->
{extends layout.latte}

<!-- Este é o conteúdo que será renderizado dentro do layout dentro do bloco de conteúdo -->
{block content}
    <h1>Página Inicial</h1>
    <p>Bem-vindo ao meu aplicativo!</p>
{/block}

Então, quando você for renderizar isso dentro da sua função ou controlador, você faria algo assim:

// rota simples
Flight::route('/', function () {
    Flight::latte()->render('home.latte', [
        'title' => 'Página Inicial'
    ]);
});

// ou se estiver usando um controlador
Flight::route('/', [HomeController::class, 'index']);

// HomeController.php
class HomeController
{
    public function index()
    {
        Flight::latte()->render('home.latte', [
            'title' => 'Página Inicial'
        ]);
    }
}

Veja a Documentação do Latte para mais informações sobre como usar o Latte em todo o seu potencial!

Awesome-plugins/awesome_plugins

Plugins Incríveis

Flight é incrivelmente extensível. Existem vários plugins que podem ser usados para adicionar funcionalidades à sua aplicação Flight. Alguns são oficialmente suportados pela Equipe do Flight e outros são bibliotecas micro/lite para ajudá-lo a começar.

Autenticação/Autorização

A autenticação e autorização são cruciais para qualquer aplicação que requer controles para determinar quem pode acessar o quê.

• flightphp/permissions - Biblioteca Oficial de Permissões do Flight. Esta biblioteca é uma maneira simples de adicionar permissões de nível de usuário e aplicativo à sua aplicação.

Armazenamento em Cache

O armazenamento em cache é uma ótima maneira de acelerar sua aplicação. Existem várias bibliotecas de armazenamento em cache que podem ser usadas com o Flight.

• Wruczek/PHP-File-Cache - Light, simples e classe de armazenamento em arquivo PHP independente.

CLI

Aplicações CLI são uma ótima maneira de interagir com sua aplicação. Você pode usá-las para gerar controladores, exibir todas as rotas e muito mais.

• flightphp/runway - Runway é uma aplicação CLI que ajuda a gerenciar suas aplicações Flight.

Cookies

Cookies são uma ótima maneira de armazenar pequenos pedaços de dados no lado do cliente. Eles podem ser usados para armazenar preferências do usuário, configurações da aplicação e muito mais.

• overclokk/cookie - PHP Cookie é uma biblioteca PHP que fornece uma maneira simples e eficaz de gerenciar cookies.

Depuração

A depuração é crucial ao desenvolver em seu ambiente local. Existem alguns plugins que podem aprimorar sua experiência de depuração.

• tracy/tracy - Este é um manipulador de erros completo que pode ser usado com o Flight. Possui vários painéis que podem ajudá-lo a depurar sua aplicação. Também é muito fácil de estender e adicionar seus próprios painéis.
• flightphp/tracy-extensions - Usado com o manipulador de erros Tracy, este plugin adiciona alguns painéis extras para ajudar na depuração especificamente em projetos Flight.

Bancos de Dados

Bancos de dados são essenciais para a maioria das aplicações. É assim que você armazena e recupera dados. Algumas bibliotecas de banco de dados são simplesmente wrappers para escrever consultas e outras são ORMs completos.

• flightphp/core PdoWrapper - Wrapper PDO Oficial do Flight que faz parte do núcleo. É um simples wrapper para ajudar a simplificar o processo de escrever consultas e executá-las. Não é um ORM.
• flightphp/active-record - ORM/Mapper Ativo do Flight Oficial. Ótima pequena biblioteca para recuperar e armazenar dados facilmente em seu banco de dados.

Criptografia

Criptografia é crucial para qualquer aplicação que armazena dados sensíveis. Criptografar e descriptografar os dados não é tão difícil, mas armazenar corretamente a chave de criptografia pode ser difícil. A coisa mais importante é nunca armazenar sua chave de criptografia em um diretório público ou commitá-la em seu repositório de código.

• defuse/php-encryption - Esta é uma biblioteca que pode ser usada para criptografar e descriptografar dados. Começar a criptografar e descriptografar dados é bastante simples.

Sessão

As sessões não são realmente úteis para APIs, mas para o desenvolvimento de aplicações web, as sessões podem ser cruciais para manter o estado e as informações de login.

• Ghostff/Session - Gerenciador de Sessão PHP (não bloqueante, flash, segmento, criptografia de sessão). Usa open_ssl do PHP para criptografar/descriptografar opcionalmente os dados da sessão.

Modelagem

A modelagem é essencial para qualquer aplicação web com uma UI. Existem várias engines de modelagem que podem ser usadas com o Flight.

• flightphp/core View - Esta é uma engine de modelagem muito básica que faz parte do núcleo. Não é recomendado usar se você tem mais do que algumas páginas em seu projeto.
• latte/latte - Latte é uma engine de modelagem completa e fácil de usar que se sente mais próxima de uma sintaxe PHP do que Twig ou Smarty. Também é muito fácil de estender e adicionar seus próprios filtros e funções.

Contribuição

Tem um plugin que você gostaria de compartilhar? Envie um pull request para adicioná-lo à lista!

Media

Mídia

Tentamos rastrear o que podemos dos vários tipos de mídia pela internet sobre o Flight. Veja abaixo diferentes recursos que você pode usar para aprender mais sobre o Flight.

Artigos

• Melhores Micro Frameworks PHP para 2024 por n0nag0n (2024)
• Criando uma API RESTful com o Flight Framework por n0nag0n (2024)
• Construindo um Blog Simples com Flight Parte 2 por n0nag0n (2024)
• Construindo um Blog Simples com Flight Parte 1 por n0nag0n (2024)
• 🚀 Crie uma API CRUD Simples em PHP com o Flight Framework por soheil-khaledabadi (2024)
• Construindo uma Aplicação Web PHP com o Micro-framework Flight por Arthur C. Codex (2023)
• Melhores Frameworks PHP para Desenvolvimento Web em 2024 por Ravikiran A S (2023)
• Top 12 Frameworks PHP: Um Guia Abrangente para 2023 por marketing kbk (2023)
• 5 Frameworks PHP que Você (Provavelmente) Nunca Ouviu Falar por n0nag0n (2022)
• 12 principais frameworks PHP para desenvolvedores web considerarem em 2023 por Anna Monus (2022)
• Os Melhores Microframeworks PHP em um Servidor Cloud por Shahzeb Ahmed (2021)
• Framework PHP: Os 15 mais poderosos para o seu desenvolvimento web por AHT Tech (2020)
• Roteamento PHP Fácil com FlightPHP por Lucas Conceição (2019)
• Testando Novo Framework PHP (Flight) por Leon (2017)
• Configurando o FlightPHP para trabalhar com Backbonejs por Timothy Tocci (2015)

Vídeos

• Vídeo Introdutório Simples do PHP Flight Framework por n0nag0n (2024)
• Definir código de cabeçalho HTTP no Flightphp (3 Soluções!!) por Roel Van de Paar (2024)
• Tutorial do PHP Flight Framework. Projeto de API super fácil! por n0nag0n (2022)
• Aplicação web CRUD com php e mysql e bootstrap usando flight por Devlopteca - Oscar Uh (2021)
• DevOps & SysAdmins: Regra de reescrita lighttpd para o microframework PHP Flight por Roel Van de Paar (2021)
• Tutorial REST API Flight PHP #PARTE2 INSERIR TABELA Info #Código (Tagalog) por Info Singkat Official (2020)
• Tutorial REST API Flight PHP #PARTE1 Info #Código (Tagalog) por Info Singkat Official (2020)
• Como Criar uma API REST JSON EM PHP - Parte 2 por Codewife (2018)
• Como Criar uma API REST JSON EM PHP - Parte 1 por Codewife (2018)
• Teste Micro Frameworks PHP - Flight PHP, Lumen, Slim 3 e Laravel por Codemarket (2016)
• Tutorial 1 Flight PHP - Instalação por absagg (2014)
• Tutorial 2 Flight PHP - Rota parte 1 por absagg (2014)

Examples

Precisa de um início rápido?

Você tem duas opções para começar com o Flight:

• Esqueleto de Arquivo Único: Um único arquivo que inclui tudo o que você precisa para executar seu aplicativo em um único arquivo simples.
• Esqueleto Completo: Um exemplo mais completo com controladores e visualizações.

Precisa de Inspiração?

Embora esses não sejam oficialmente patrocinados pela equipe do Flight, eles podem te dar ideias sobre como estruturar seus próprios projetos construídos com o Flight!

• Blog de Exemplo do Flight - Flight v3 com Middleware, Controladores, Active Record e Latte.
• API RESTful CRUD do Flight - Projeto simples de API CRUD usando o framework Flight, que fornece uma estrutura básica para novos usuários configurarem rapidamente uma aplicação PHP com operações CRUD e conectividade de banco de dados. O projeto demonstra como usar o Flight para desenvolvimento de API RESTful, tornando-se uma ferramenta de aprendizado ideal para iniciantes e um kit inicial útil para desenvolvedores mais experientes.
• Sistema de Gestão Escolar do Flight - Flight v3
• Paste Bin com Comentários - Flight v3
• Aplicativo Básico Esquelético
• Wiki de Exemplo
• Aplicação do Framework PHP IT-Innovator
• LittleEducationalCMS (Espanhol)
• API das Páginas Amarelas Italianas
• Sistema de Gestão de Conteúdo Genérico (com... muito pouca documentação)
• Um pequeno framework php baseado em Flight e medoo.
• Aplicação MVC de Exemplo

Quer Compartilhar Seu Próprio Exemplo?

Se você tem um projeto que deseja compartilhar, envie um pull request para adicioná-lo a esta lista!

Install/install

Instalação

Baixar os arquivos

Certifique-se de ter o PHP instalado em seu sistema. Caso contrário, clique aqui para obter instruções sobre como instalá-lo em seu sistema.

Se estiver usando Composer, você pode executar o seguinte comando:

composer require flightphp/core

OU você pode baixar os arquivos diretamente e extrair para o diretório da web.

Configurar seu Servidor Web

Servidor de Desenvolvimento PHP Integrado

Esta é de longe a maneira mais simples de começar. Você pode usar o servidor integrado para executar sua aplicação e até mesmo usar SQLite para um banco de dados (desde que o sqlite3 esteja instalado em seu sistema) e não exigir muito! Basta executar o seguinte comando uma vez que o PHP estiver instalado:

php -S localhost:8000

Em seguida, abra seu navegador e vá para http://localhost:8000.

Se quiser definir o diretório raiz do seu projeto como um diretório diferente (Por ex: seu projeto é ~/myproject, mas sua raiz do documento é ~/myproject/public/), você pode executar o seguinte comando uma vez que estiver no diretório ~/myproject:

php -S localhost:8000 -t public/

Então, abra seu navegador e vá para http://localhost:8000.

Apache

Certifique-se de que o Apache já esteja instalado em seu sistema. Caso contrário, pesquise como instalar o Apache em seu sistema.

Para o Apache, edite seu arquivo .htaccess com o seguinte:

RewriteEngine On
RewriteCond %{REQUEST_FILENAME} !-f
RewriteCond %{REQUEST_FILENAME} !-d
RewriteRule ^(.*)$ index.php [QSA,L]

Nota: Se precisar usar o flight em um subdiretório, adicione a linha RewriteBase /subdir/ logo após RewriteEngine On.

Nota: Se desejar proteger todos os arquivos do servidor, como um arquivo db ou env. Coloque isso em seu arquivo .htaccess:

RewriteEngine On
RewriteRule ^(.*)$ index.php

Nginx

Certifique-se de que o Nginx já esteja instalado em seu sistema. Caso contrário, pesquise como instalar o Nginx em seu sistema.

Para o Nginx, adicione o seguinte à declaração do seu servidor:

server {
  location / {
    try_files $uri $uri/ /index.php;
  }
}

Crie seu arquivo index.php

<?php

// Se estiver usando o Composer, requer o autoloader.
require 'vendor/autoload.php';
// se não estiver usando o Composer, carregue o framework diretamente
// require 'flight/Flight.php';

// Em seguida, defina uma rota e atribua uma função para lidar com a solicitação.
Flight::route('/', function () {
  echo 'olá mundo!';
});

// Por fim, inicie o framework.
Flight::start();

Instalando o PHP

Se você já tem o php instalado em seu sistema, vá em frente e pule estas instruções e vá para a seção de download

Claro! Aqui estão as instruções para instalar o PHP no macOS, Windows 10/11, Ubuntu e Rocky Linux. Também incluirei detalhes sobre como instalar diferentes versões do PHP.

macOS

Instalando o PHP usando o Homebrew

1. Instalar o Homebrew (caso ainda não esteja instalado):

   • Abra o Terminal e execute:

     /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

2. Instalar o PHP:

   • Instalar a versão mais recente:

     brew install php

   • Para instalar uma versão específica, por exemplo, PHP 8.1:

     brew tap shivammathur/php
     brew install shivammathur/php/php@8.1

3. Alternar entre versões do PHP:

   • Desvincule a versão atual e vincule a versão desejada:

     brew unlink php
     brew link --overwrite --force php@8.1

   • Verifique a versão instalada:

     php -v

Windows 10/11

Instalando o PHP manualmente

1. Baixar o PHP:

   • Visite PHP for Windows e baixe a versão mais recente ou uma versão específica (por ex., 7.4, 8.0) como um arquivo zip não seguro para threads.

2. Extrair o PHP:

   • Extraia o arquivo zip baixado para C:\php.

3. Adicionar o PHP ao PATH do sistema:

   • Vá para Propriedades do Sistema > Variáveis de Ambiente.
   • Em Variáveis do Sistema, encontre Path e clique em Editar.
   • Adicione o caminho C:\php (ou onde você extraiu o PHP).
   • Clique em OK para fechar todas as janelas.

4. Configurar o PHP:

   • Copie php.ini-development para php.ini.
   • Edite php.ini para configurar o PHP conforme necessário (por ex., definindo extension_dir, habilitando extensões).

5. Verificar a instalação do PHP:

   • Abra o Prompt de Comando e execute:

     php -v

Instalando Múltiplas Versões do PHP

1. Repita os passos acima para cada versão, colocando cada uma em um diretório separado (por ex., C:\php7, C:\php8).

2. Alternar entre as versões ajustando a variável PATH do sistema para apontar para o diretório da versão desejada.

Ubuntu (20.04, 22.04, etc.)

Instalando o PHP usando apt

1. Atualizar listas de pacotes:

   • Abra o Terminal e execute:

     sudo apt update

2. Instalar o PHP:

   • Instalar a versão mais recente do PHP:

     sudo apt install php

   • Para instalar uma versão específica, por exemplo, PHP 8.1:

     sudo apt install php8.1

3. Instalar módulos adicionais (opcional):

   • Por exemplo, para instalar suporte ao MySQL:

     sudo apt install php8.1-mysql

4. Alternar entre as versões do PHP:

   • Usar update-alternatives:

     sudo update-alternatives --set php /usr/bin/php8.1

5. Verificar a versão instalada:

   • Execute:

     php -v

Rocky Linux

Instalando o PHP usando yum/dnf

1. Ativar o repositório EPEL:

   • Abra o Terminal e execute:

     sudo dnf install epel-release

2. Instalar o repositório do Remi:

   • Execute:

     sudo dnf install https://rpms.remirepo.net/enterprise/remi-release-8.rpm
     sudo dnf module reset php

3. Instalar o PHP:

   • Para instalar a versão padrão:

     sudo dnf install php

   • Para instalar uma versão específica, por exemplo, PHP 7.4:

     sudo dnf module install php:remi-7.4

4. Alternar entre as versões do PHP:

   • Usar o comando de módulo dnf:

     sudo dnf module reset php
     sudo dnf module enable php:remi-8.0
     sudo dnf install php

5. Verificar a versão instalada:

   • Execute:

     php -v

Notas Gerais

• Para ambientes de desenvolvimento, é importante configurar as configurações do PHP conforme os requisitos do seu projeto.
• Ao alternar entre as versões do PHP, assegure-se de que todas as extensões relevantes do PHP estejam instaladas para a versão específica que pretende usar.
• Reinicie seu servidor web (Apache, Nginx, etc.) após alternar entre as versões do PHP ou atualizar as configurações para aplicar as alterações.