Rotas
Aprenda como criar rotas com correspondência baseada em padrões para closures, funções, métodos e controladores, e como isolar rotas em escopos distintos.
Para criar uma nova rota, edite o system/main.php arquivo. Se desejar que a rota esteja disponível apenas no modo de desenvolvimento, edite o system/dev.php arquivo correspondente.
Criar rotas
A criação de uma rota deve ser feita utilizando:
$app->action(array | string $methods, string $path, $callback);
Utilizando função anônima (closure)
$app->action('GET', '/closure', function () {
return 'Hello "closure"!';
});
Utilizando funções com um nome específico
function sample() {
echo 'Hour server: ', date('h:i:s');
}
$app->action('GET', '/hour', 'sample');
Utilizando o método de uma instância
class Sample {
public function method() {
echo 'Hello!';
}
}
$instance = new Sample();
$app->action('ANY', '/', [$instance, 'method']);
Utilizando rotas com múltiplos métodos HTTP
$app->action(['GET', 'HEAD', 'POST'], '/foo', function () {
...
});
$app->action(['PATCH', 'PUT'], '/bar', function () {
...
});
Utilizando controladores
Para melhor compreender isso na prática, crie um arquivo system/Controllers/Blog/Post.php com o seguinte conteúdo:
<?php
namespace Controllers\Blog;
class Post {
public function list($app) {
return 'Coming soon';
}
public function read($app, $params) {
$id = $params['id'];
return "ID: {$id}";
}
}
Em seguida, crie as rotas (não é necessário incluir o Controllers prefixo do namespace — o framework o adiciona automaticamente), por exemplo:
$app->action('GET', '/blog/posts', 'Blog\Home::list');
$app->action('GET', '/blog/posts/<id>', 'Blog\Home::post');
Agrupamento de rotas (escopo)
O sistema de agrupamento de rotas (escopo) é simples e flexível. Ele se baseia na URL ou caminho completo e suporta o * caractere curinga, bem como os mesmos padrões disponíveis para rotas. Um exemplo de rota só será adicionado se o caminho começar com /blog/:
/*
* http://localhost:5000/blog/
* http://localhost:5000/blog/post
* http://localhost:5000/blog/search
*/
$app->scope('/blog/', function ($app, $params) {
$app->action('GET', '/', function () { ... });
$app->action('POST', '/post', function () { ... });
$app->action('GET', '/search', function () { ... });
});
Restringir rotas a um escopo que aceite apenas HTTPS ou HTTP
As rotas só serão adicionadas se você estiver acessando via HTTPS:
$app->scope('https://*', function ($app, $params) {
...
});
As rotas só serão adicionadas se você estiver acessando via HTTP:
$app->scope('http://*', function ($app, $params) {
...
});
Restringir rotas para que sejam acessíveis apenas dentro de um domínio específico.
As rotas só serão adicionadas quando o host da solicitação for example.com
$app->scope('*://example.com/', function ($app, $params) {
...
});
Restringir rotas a um escopo por subdomínio
As rotas só serão adicionadas se você estiver acessando um subdomínio de example.com, por exemplo,site1.example.com
$app->scope('*://*.example.com/', function ($app, $params) {
...
});
Utilizando um padrão para capturar o subdomínio:
$app->scope('*://<subdomain>.example.com/', function ($app, $params) {
$subdomain = $params['subdomain'];
...
});
Rotas e escopos com padrões de URL
Utilizando um padrão que espera um caminho com um ID id de qualquer formato:
$app->action('GET', '/users/<id>/<user>', function ($app, $params) {
$id = $params['id'];
$username = $params['user'];
...
});
Utilizando um padrão que espera um caminho com um nome id em formato UUID:
$app->action('GET', '/users/<id:uuid>/<user>', function ($app, $params) {
$id = $params['id'];
$username = $params['user'];
...
});
Padrões padrão:
| Tipo | Exemplo | Descrição |
|---|---|---|
alnum |
$app->action('GET', '/baz/<video:alnum>', ...); |
Aceita apenas parâmetros alfanuméricos; $params retorna ['video' => ...] |
alpha |
$app->action('GET', '/foo/bar/<name:alpha>', ...); |
Aceita apenas parâmetros alfabéticos; $params retorna ['name' => ...] |
decimal |
$app->action('GET', '/baz/<price:decimal>', ...); |
Aceita apenas parâmetros numéricos decimais; $params retorna ['price' => ...] |
num |
$app->action('GET', '/foo/<id:num>', ...); |
Aceita apenas parâmetros inteiros; $params retorna ['id' => ...] |
nospace |
$app->action('GET', '/foo/<nospace:nospace>', ...); |
Aceita qualquer caractere, exceto espaços, como %20 tabulações (veja o \S padrão regex) |
uuid |
$app->action('GET', '/bar/<barcode:uuid>', ...); |
Aceita parâmetros formatados em UUID; $params retorna ['barcode' => ...] |
version |
$app->action('GET', '/baz/<api:version>', ...); |
Aceita parâmetros no formato Semantic Versioning 2.0.0 (SemVer) ; $params retorna ['api' => ...] |
Os padrões são muito flexíveis, permitindo que sejam modificados usando uma expressão regular personalizada. Substitua o formato SemVer pelo <major>.<minor>.<revision>.<build> formato:
$app->action('GET', '/download/<foobar:version>/<user>', function ($app, $params) {
$version = $params['foobar'];
...
});
$app->setPattern('version', '\d+\.\d+\.\d+\.\d+');
Substitua o formato SemVer pelo <major>.<minor> formato (útil para APIs da web):
$app->action('GET', '/api/<foobar:version>/<user>', function ($app, $params) {
$version = $params['foobar'];
...
});
$app->setPattern('version', '\d+\.\d+');
Compartilhamento de dados
A flexibilidade da classe Inphinit\App permite definir propriedades dinamicamente, proporcionando acesso conveniente a informações dentro de controladores ou funções de retorno de chamada de rotas. Exemplo:
$app->scope('https://api.example.com/', function ($app, $params) {
$app->userInfo = authUserInfoContext();
$app->customers = customersContext();
Response::type('application/json');
$app->action('GET', '/me', function ($app, $params) {
return json_encode($app->userInfo->get());
});
$app->action('GET', '/customers', 'Api\\Clients::list');
$app->action('GET', '/customers/<id:uuid>/orders', 'Api\\Clients::orders');
});
Exemplo de utilização de dados compartilhados no Controlador:
<?php
namespace Controllers;
class FooBar
{
public function list($app, $params)
{
return json_encode($app->customers->all());
}
public function orders($app, $params)
{
$customerId = $params['id'];
$customer = $app->customers->find($customerId);
return json_encode($customer->orders());
}
}
Usando filtros
Os filtros de rota são similares aos sistemas de middleware, permitindo controlar as requisições no escopo principal ou em outros escopos, liberado ou bloqueando acesso as rotas. Este recurso permite criar sistemas de autenticação ou permissão para rotas especificas.
Um exemplo ficticio para demonstrar exemplos de uso dos filtros em diferentes escopos:
use Inphinit\Http\Request;
// Aplica filtro em todos escopos
$app->useFilter(function ($app, $method, $path, $params) {
if (country_allowed() === false) {
// Envia HTTP 401 para informar ao cliente browser/cliente
Request::status(401);
// Bloqueia acesso as rotas em todos escopos
return false;
}
return true;
});
// Aplica filtro em todos escopos
$app->useFilter(function ($app, $method, $path, $params) {
// In fictional code checks if HTTP is allowed
return allowed_http_method($method);
});
$app->scope('https://api.example.com/', function ($app, $params) {
Response::type('application/json');
// Aplica filtro somente neste escopos
$app->useFilter(function () {
// Verifica se a requisição (hipotéticamente) veio de um navegador
if (is_web_browser()) {
Request::status(403);
return false;
}
return true;
});
$app->action('GET', '/delivery', 'Api\\Delivery::list');
$app->action('GET', '/delivery/<id:uuid>/orders', 'Api\\Delivery::orders');
});
// Apenas os filtros no escopo principal principal serão executado ao acessar essa rota:
$app->action('GET', '/about', 'Homepage::about');