php crud api
v2.14.29
Script PHP de arquivo único que adiciona uma API REST a um banco de dados MySQL/MariaDB, PostgreSQL, SQL Server ou SQLite.
Howto: Faça upload de " api.php " para seu servidor web, configure-o para se conectar ao seu banco de dados, tenha uma API REST instantânea e completa.
NB: Esta é a implementação de referência TreeQL em PHP.
PHP 7.2 ou superior com drivers PDO habilitados para um destes sistemas de banco de dados:
MySQL 5.7/MariaDB 10.0 ou superior para recursos espaciais no MySQL
PostgreSQL 9.5 ou superior com PostGIS 2.2 ou superior para recursos espaciais
SQL Server 2017 ou superior (2019 também tem suporte para Linux)
SQLite 3.16 ou superior (recursos espaciais NÃO suportados)
Baixe o arquivo " api.php " da versão mais recente:
https://github.com/mevdschee/php-crud-api/releases/latest ou direto de:
https://raw.githubusercontent.com/mevdschee/php-crud-api/main/api.php
Este é um aplicativo de arquivo único! Carregue " api.php " em algum lugar e divirta-se!
Para desenvolvimento local você pode executar o servidor web integrado do PHP:
php -S localhost:8080
Teste o script abrindo o seguinte URL:
http://localhost:8080/api.php/records/posts/1
Não se esqueça de modificar a configuração na parte inferior do arquivo.
Alternativamente você pode integrar este projeto no framework web de sua escolha, veja:
API REST automática para Laravel
API REST automática para Symfony 4
API REST automática para SlimPHP 4
Nessas integrações o Composer é usado para carregar este projeto como uma dependência.
Para quem não usa o compositor, o arquivo " api.include.php " é fornecido. Este arquivo contém tudo de " api.php " exceto a configuração de " src/index.php " e pode ser usado pela função "include" do PHP.
Edite as seguintes linhas no final do arquivo " api.php ":
$config = new Config([ 'username' => 'xxx', 'password' => 'xxx', 'database' => 'xxx', ]);
Estas são todas as opções de configuração e seus valores padrão entre colchetes:
"driver": mysql , pgsql , sqlsrv ou sqlite ( mysql )
"address": Nome do host (ou nome do arquivo) do servidor de banco de dados ( localhost )
"porta": porta TCP do servidor de banco de dados (o padrão é o padrão do driver)
"username": Nome de usuário do usuário que se conecta ao banco de dados (sem padrão)
"password": Senha do usuário que se conecta ao banco de dados (sem padrão)
"database": Banco de dados ao qual a conexão é feita (sem padrão)
"command": SQL extra para inicializar a conexão com o banco de dados (nenhum)
"tables": lista separada por vírgulas de tabelas para publicar (o padrão é 'all')
"mapping": lista separada por vírgulas de mapeamentos de tabela/coluna (sem mapeamento)
"geometrySrid": SRID assumido ao converter de WKT para geometria ( 4326 )
"middlewares": Lista de middlewares para carregar ( cors )
"controllers": Lista de controladores para carregar ( records,geojson,openapi,status )
"customControllers": Lista de controladores personalizados do usuário para carregar (sem padrão)
"openApiBase": informações da OpenAPI ( {"info":{"title":"PHP-CRUD-API","version":"1.0.0"}} )
"cacheType": TempFile , Redis , Memcache , Memcached ou NoCache ( TempFile )
"cachePath": Caminho/endereço do cache (o padrão é o diretório temporário do sistema)
"cacheTime": Número de segundos que o cache é válido ( 10 )
"jsonOptions": Opções usadas para codificação JSON ( JSON_UNESCAPED_UNICODE )
"debug": Mostra erros nos cabeçalhos "X-Exception" ( false )
"basePath": caminho base do URI da API (determinado usando PATH_INFO por padrão)
Todas as opções de configuração também estão disponíveis como variáveis de ambiente. Escreva a opção de configuração com letras maiúsculas, um prefixo "PHP_CRUD_API_" e sublinhados para quebras de palavras, por exemplo:
PHP_CRUD_API_DRIVER=mysql
PHP_CRUD_API_ADDRESS=localhost
PHP_CRUD_API_PORT=3306
PHP_CRUD_API_DATABASE=php-crud-api
PHP_CRUD_API_USERNAME=php-crud-api
PHP_CRUD_API_PASSWORD=php-crud-api
PHP_CRUD_API_DEBUG=1
As variáveis de ambiente têm precedência sobre a configuração do PHP.
Estas limitações e restrições se aplicam:
As chaves primárias devem ser de incremento automático (de 1 a 2 ^ 53) ou UUID
Chaves primárias e estrangeiras compostas não são suportadas
Gravações complexas (transações) não são suportadas
Consultas complexas que chamam funções (como "concat" ou "sum") não são suportadas
O banco de dados deve suportar e definir restrições de chave estrangeira
SQLite não pode ter chaves primárias de incremento automático digitadas em bigint
SQLite não suporta alteração de colunas de tabela (estrutura)
Os seguintes recursos são suportados:
Instalação do Composer ou arquivo PHP único, fácil de implantar.
Muito pouco código, fácil de adaptar e manter
Suporta variáveis POST como entrada (x-www-form-urlencoded)
Suporta um objeto JSON como entrada
Suporta uma matriz JSON como entrada (inserção em lote)
Limpe e valide a entrada usando regras de tipo e retornos de chamada
Sistema de permissão para bancos de dados, tabelas, colunas e registros
Layouts de banco de dados único e multilocatário multilocatários são suportados
Suporte CORS de vários domínios para solicitações entre domínios
Suporte para leitura de resultados unidos de múltiplas tabelas
Suporte de pesquisa em vários critérios
Paginação, classificação, lista N superior e seleção de colunas
Detecção de relação com resultados aninhados (belongsTo, hasMany e HABTM)
Suporte a incremento atômico via PATCH (para contadores)
Campos binários suportados com codificação base64
Campos e filtros espaciais/GIS compatíveis com WKT e GeoJSON
Mapeando nomes de tabelas e colunas para oferecer suporte a sistemas legados
Gere documentação de API usando ferramentas OpenAPI
Autenticação via chave API, token JWT ou nome de usuário/senha
Os parâmetros de conexão do banco de dados podem depender da autenticação
Suporte para leitura da estrutura do banco de dados em JSON
Suporte para modificação da estrutura do banco de dados usando endpoint REST
Middleware de aprimoramento de segurança está incluído
Compatível com padrão: PSR-4, PSR-7, PSR-12, PSR-15 e PSR-17
Projetos relacionados:
Início rápido do PHP-CRUD-API: um arquivo docker compose personalizável e pronto para uso com PHP-CRUD-API.
Gerador de filtros PHP-CRUD-API: Uma biblioteca JavaScript que cria filtros PHP-CRUD-API a partir de expressões.
JS-CRUD-API: Uma biblioteca cliente JavaScript para a API do PHP-CRUD-API
PHP-API-AUTH: Script PHP de arquivo único que é um provedor de autenticação para PHP-CRUD-API
PHP-CRUD-UI: Script PHP de arquivo único que adiciona uma UI a um projeto PHP-CRUD-API.
PHP-CRUD-ADMIN: Script PHP de arquivo único que adiciona uma interface de administração de banco de dados a um projeto PHP-CRUD-API.
PHP-SP-API: Script PHP de arquivo único que adiciona uma API REST a um banco de dados SQL.
dexie-mysql-sync: Sincronização entre IndexedDB local e banco de dados MySQL.
ra-data-treeql: pacote NPM que fornece um provedor de dados para React Admin.
scriptPilot/vueuse: Vue Composables além de VueUse.org (que suporta PHP-CRUD-API).
scriptPilot/add-php-backend: Adicione MySQL, phpMyAdmin e PHP-CRUD-API ao seu ambiente de desenvolvimento.
VUE-CRUD-UI: script Vue.js de arquivo único que adiciona uma UI a um projeto PHP-CRUD-API.
Também existem portas deste script em:
Go-CRUD-API (trabalho em andamento)
Java JDBC por Ivan Kolchagov (v1)
Java Spring Boot + jOOQ (v2: trabalho em andamento)
Existem também portas de prova de conceito deste script que suportam apenas funcionalidades REST CRUD básicas em: PHP, Java, Go, C# .net core, Node.js e Python.
Você pode instalar todas as dependências deste projeto usando o seguinte comando:
php install.php
Você pode compilar todos os arquivos em um único arquivo " api.php " usando:
php build.php
Observe que você não usa compilação ao integrar este projeto em outro projeto ou estrutura (em vez disso, use o Composer).
Você pode acessar o código não compilado na URL:
http://localhost:8080/src/records/posts/1
O código não compilado reside nos diretórios " src " e " vendor ". O diretório " vendor " contém as dependências.
Você pode atualizar todas as dependências deste projeto usando o seguinte comando:
php update.php
Este script irá instalar e executar o Composer para atualizar as dependências.
NB: O script de atualização corrigirá as dependências no diretório do fornecedor para compatibilidade com PHP 7.0.
TreeQL permite que você crie uma "árvore" de objetos JSON com base na estrutura do seu banco de dados SQL (relações) e na sua consulta.
É vagamente baseado no padrão REST e também inspirado em json:api.
A tabela de postagens de exemplo possui apenas alguns campos:
posts ======= id title content created
As operações CRUD + List abaixo atuam nesta tabela.
Se você deseja criar um registro, a solicitação pode ser escrita em formato URL como:
POST /records/posts
Você deve enviar um corpo contendo:
{
"title": "Black is the new red",
"content": "This is the second post.",
"created": "2018-03-06T21:34:01Z"
}E retornará o valor da chave primária do registro recém-criado:
2
Para ler um registro desta tabela a solicitação pode ser escrita em formato URL como:
GET /records/posts/1
Onde “1” é o valor da chave primária do registro que você deseja ler. Ele retornará:
{
"id": 1
"title": "Hello world!",
"content": "Welcome to the first post.",
"created": "2018-03-05T20:12:56Z"
}Nas operações de leitura você pode aplicar junções.
Para atualizar um registro nesta tabela a solicitação pode ser escrita em formato URL como:
PUT /records/posts/1
Onde “1” é o valor da chave primária do registro que você deseja atualizar. Enviar como corpo:
{
"title": "Adjusted title!"
}Isso ajusta o título da postagem. E o valor de retorno é o número de linhas definidas:
1
Se você deseja excluir um registro desta tabela, a solicitação pode ser escrita no formato URL como:
DELETE /records/posts/1
E retornará o número de linhas excluídas:
1
Para listar os registros desta tabela a solicitação pode ser escrita em formato URL como:
GET /records/posts
Ele retornará:
{
"records":[
{
"id": 1,
"title": "Hello world!",
"content": "Welcome to the first post.",
"created": "2018-03-05T20:12:56Z"
}
]
}Nas operações de lista você pode aplicar filtros e junções.
Os filtros fornecem funcionalidade de pesquisa, em chamadas de lista, usando o parâmetro "filter". Você precisa especificar o nome da coluna, uma vírgula, o tipo de correspondência, outra vírgula e o valor que deseja filtrar. Estes são os tipos de correspondência suportados:
"cs": contém string (string contém valor)
"sw": comece com (string começa com valor)
"ew": final com (string final com valor)
"eq": igual (string ou número corresponde exatamente)
"lt": menor que (o número é menor que o valor)
"le": menor ou igual (o número é menor ou igual ao valor)
"ge": maior ou igual (o número é maior ou igual ao valor)
"gt": maior que (o número é maior que o valor)
"bt": entre (o número está entre dois valores separados por vírgula)
"in": in (número ou string está em uma lista de valores separados por vírgula)
"is": é nulo (o campo contém o valor "NULL")
Você pode negar todos os filtros acrescentando um caractere "n", para que "eq" se torne "neq". Exemplos de uso de filtro são:
GET /records/categories?filter=name,eq,Internet GET /records/categories?filter=name,sw,Inter GET /records/categories?filter=id,le,1 GET /records/categories?filter=id,ngt,1 GET /records/categories?filter=id,bt,0,1 GET /records/categories?filter=id,in,0,1
Saída:
{
"records":[
{
"id": 1
"name": "Internet"
}
]
}Na próxima seção, nos aprofundaremos em como você pode aplicar vários filtros em uma única chamada de lista.
Os filtros podem ser aplicados repetindo o parâmetro "filter" na URL. Por exemplo, o seguinte URL:
GET /records/categories?filter=id,gt,1&filter=id,lt,3
solicitará todas as categorias "onde id> 1 e id <3". Se você quisesse "where id = 2 ou id = 4" você deveria escrever:
GET /records/categories?filter1=id,eq,2&filter2=id,eq,4
Como você pode ver, adicionamos um número ao parâmetro "filter" para indicar que "OR" em vez de "AND" deve ser aplicado. Observe que você também pode repetir "filter1" e criar um "AND" dentro de um "OR". Como você também pode ir um nível mais fundo adicionando uma letra (af), você pode criar quase qualquer árvore de condições razoavelmente complexa.
NB: Você só pode filtrar na tabela solicitada (não nas tabelas incluídas) e os filtros são aplicados apenas nas chamadas de lista.
Por padrão, todas as colunas estão selecionadas. Com o parâmetro "include" você pode selecionar colunas específicas. Você pode usar um ponto para separar o nome da tabela do nome da coluna. Várias colunas devem ser separadas por vírgulas. Um asterisco ("*") pode ser usado como curinga para indicar "todas as colunas". Semelhante a "incluir", você pode usar o parâmetro "excluir" para remover determinadas colunas:
GET /records/categories/1?include=name GET /records/categories/1?include=categories.name GET /records/categories/1?exclude=categories.id
Saída:
{
"name": "Internet"
}NB: As colunas usadas para incluir entidades relacionadas são adicionadas automaticamente e não podem ser deixadas de fora da saída.
Com o parâmetro "order" você pode classificar. Por padrão, a classificação está em ordem crescente, mas especificando "desc" isso pode ser revertido:
GET /records/categories?order=name,desc GET /records/categories?order=id,desc&order=name
Saída:
{
"records":[
{
"id": 3
"name": "Web development"
},
{
"id": 1
"name": "Internet"
}
]
}NB: Você pode classificar vários campos usando vários parâmetros de "ordem". Você não pode ordenar colunas "unidas".
O parâmetro "size" limita o número de registros retornados. Isso pode ser usado para as N principais listas junto com o parâmetro "ordem" (use ordem decrescente).
GET /records/categories?order=id,desc&size=1
Saída:
{
"records":[
{
"id": 3
"name": "Web development"
}
]
}NB: Se você também deseja saber o número total de registros você pode usar o parâmetro "página".
O parâmetro "page" contém a página solicitada. O tamanho de página padrão é 20, mas pode ser ajustado (por exemplo, para 50).
GET /records/categories?order=id&page=1 GET /records/categories?order=id&page=1,50
Saída:
{
"records":[
{
"id": 1
"name": "Internet"
},
{
"id": 3
"name": "Web development"
}
],
"results": 2
}O elemento "resultados" refere-se ao número total de registros na tabela, que seria retornado se nenhuma paginação fosse usada.
NB: Como as páginas que não estão ordenadas não podem ser paginadas, as páginas serão ordenadas por chave primária.
Digamos que você tenha uma tabela de posts que contém comentários (feitos por usuários) e os posts podem ter tags.
posts comments users post_tags tags ======= ======== ======= ========= ======= id id id id id title post_id username post_id name content user_id phone tag_id created message
Quando você quiser listar postagens com seus comentários, usuários e tags, você pode solicitar dois caminhos de "árvore":
posts -> comments -> users posts -> post_tags -> tags
Esses caminhos têm a mesma raiz e esta solicitação pode ser escrita em formato URL como:
GET /records/posts?join=comments,users&join=tags
Aqui você pode deixar de fora a tabela intermediária que vincula as postagens às tags. Neste exemplo você vê todos os três tipos de relação de tabela (hasMany, pertenceTo e hasAndBelongsToMany) em vigor:
"post" tem muitos "comentários"
"comentário" pertence a "usuário"
"post" tem e pertence a muitas "tags"
Isso pode levar aos seguintes dados JSON:
{
"records":[
{
"id": 1,
"title": "Hello world!",
"content": "Welcome to the first post.",
"created": "2018-03-05T20:12:56Z",
"comments": [
{
id: 1,
post_id: 1,
user_id: {
id: 1,
username: "mevdschee",
phone: null,
},
message: "Hi!"
},
{
id: 2,
post_id: 1,
user_id: {
id: 1,
username: "mevdschee",
phone: null,
},
message: "Hi again!"
}
],
"tags": []
},
{
"id": 2,
"title": "Black is the new red",
"content": "This is the second post.",
"created": "2018-03-06T21:34:01Z",
"comments": [],
"tags": [
{
id: 1,
message: "Funny"
},
{
id: 2,
message: "Informational"
}
]
}
]
}Você vê que os relacionamentos "belongsTo" são detectados e o valor da chave estrangeira é substituído pelo objeto referenciado. No caso de "hasMany" e "hasAndBelongsToMany" o nome da tabela é utilizado como uma nova propriedade no objeto.
Quando quiser criar, ler, atualizar ou excluir, você pode especificar vários valores de chave primária na URL. Você também precisa enviar um array em vez de um objeto no corpo da solicitação para criação e atualização.
Para ler um registro desta tabela a solicitação pode ser escrita em formato URL como:
GET /records/posts/1,2
O resultado pode ser:
[
{
"id": 1,
"title": "Hello world!",
"content": "Welcome to the first post.",
"created": "2018-03-05T20:12:56Z"
},
{
"id": 2,
"title": "Black is the new red",
"content": "This is the second post.",
"created": "2018-03-06T21:34:01Z"
}
]Da mesma forma, quando você deseja fazer uma atualização em lote, a solicitação no formato URL é escrita como:
PUT /records/posts/1,2
Onde “1” e “2” são os valores das chaves primárias dos registros que você deseja atualizar. O corpo deve conter o mesmo número de objetos que as chaves primárias na URL:
[
{
"title": "Adjusted title for ID 1"
},
{
"title": "Adjusted title for ID 2"
}
]Isso ajusta os títulos das postagens. E os valores de retorno são o número de linhas definidas:
[1,1]
O que significa que houve duas operações de atualização e cada uma delas definiu uma linha. As operações em lote usam transações de banco de dados, portanto, todas são bem-sucedidas ou falham (as bem-sucedidas são revertidas). Se falharem, o corpo conterá a lista de documentos de erro. Na resposta a seguir, a primeira operação foi bem-sucedida e a segunda operação do lote falhou devido a uma violação de integridade:
[
{
"code": 0,
"message": "Success"
},
{
"code": 1010,
"message": "Data integrity violation"
}
]O código de status de resposta será sempre 424 (dependência com falha) em caso de falha em uma das operações em lote.
Para inserir vários registros nesta tabela, a solicitação pode ser escrita em formato URL como:
POST /records/posts
O corpo deve conter um array de registros a serem inseridos:
[
{
"title": "Hello world!",
"content": "Welcome to the first post.",
"created": "2018-03-05T20:12:56Z"
},
{
"title": "Black is the new red",
"content": "This is the second post.",
"created": "2018-03-06T21:34:01Z"
}
]O valor de retorno também é um array contendo as chaves primárias dos registros recém-inseridos:
[1,2]
Observe que a operação em lote para DELETE segue o mesmo padrão de PUT, mas sem corpo.
Para suporte espacial existe um conjunto extra de filtros que podem ser aplicados em colunas geométricas e que começam com um "s":
"sco": contém espacial (a geometria contém outra)
"scr": cruzamentos espaciais (a geometria cruza outra)
"sdi": disjunção espacial (a geometria é disjunta de outra)
"seq": igual espacial (a geometria é igual a outra)
"pecado": intersecção espacial (a geometria cruza outra)
"sov": sobreposições espaciais (a geometria se sobrepõe a outra)
"sto": toques espaciais (a geometria toca outra)
"swi": espacial dentro (a geometria está dentro de outra)
"sic": espacial é fechado (a geometria é fechada e simples)
"sis": espacial é simples (a geometria é simples)
"siv": espacial é válido (geometria é válida)
Esses filtros são baseados nos padrões OGC, assim como na especificação WKT na qual as colunas geométricas são representadas. Observe que o SRID assumido ao converter de WKT para geometria é especificado pela variável de configuração geometrySrid e o padrão é 4326 (WGS 84).
O suporte GeoJSON é uma visualização somente leitura das tabelas e registros no formato GeoJSON. Estas solicitações são suportadas:
method path - operation - description
----------------------------------------------------------------------------------------
GET /geojson/{table} - list - lists records as a GeoJSON FeatureCollection
GET /geojson/{table}/{id} - read - reads a record by primary key as a GeoJSON Feature O endpoint " /geojson " usa o endpoint " /records " internamente e herda todas as funcionalidades, como junções e filtros. Também suporta um parâmetro "geometria" para indicar o nome da coluna geométrica caso a tabela tenha mais de uma. Para visualizações de mapas, ele suporta o parâmetro "bbox", no qual você pode especificar as coordenadas superior esquerda e inferior direita (separadas por vírgula). Os seguintes tipos de Geometria são suportados pela implementação GeoJSON:
Apontar
Multiponto
LinhaString
MultiLineString
Polígono
Multipolígono
A funcionalidade GeoJSON está habilitada por padrão, mas pode ser desabilitada usando a configuração "controladores".
Para suportar a criação de uma API para (parte de) um sistema legado (como Wordpress), você pode querer mapear os nomes das tabelas e colunas, pois não é possível melhorá-los sem alterar o software, enquanto os nomes podem precisar de algumas melhorias para consistência. A configuração permite renomear tabelas e colunas com uma lista de mapeamentos separados por vírgulas que são divididos com um sinal de igual, assim:
'mapping' => 'wp_posts=posts,wp_posts.ID=posts.id',
Este exemplo específico irá expor a tabela " wp_posts " em um ponto final " posts " (em vez de " wp_posts ") e a coluna " ID " dentro dessa tabela como a propriedade " id " (em letras minúsculas em vez de maiúsculas).
NB: Dado que estes dois mapeamentos se sobrepõem, o primeiro mapeamento (menos específico) pode ser omitido.
Você pode habilitar o seguinte middleware usando o parâmetro de configuração "middlewares":
"firewall": Limita o acesso a endereços IP específicos
"sslRedirect": Força conexão por HTTPS em vez de HTTP
"cors": Suporte para solicitações CORS (habilitado por padrão)
"xsrf": Bloqueie ataques XSRF usando o método 'Double Submit Cookie'
"ajaxOnly": Restringe solicitações não AJAX para evitar ataques XSRF
"apiKeyAuth": Suporte para "Autenticação de chave API"
"apiKeyDbAuth": Suporte para "Autenticação de banco de dados de chaves de API"
"dbAuth": Suporte para "Autenticação de banco de dados"
"wpAuth": Suporte para "Autenticação Wordpress"
"jwtAuth": Suporte para "Autenticação JWT"
"basicAuth": Suporte para "Autenticação Básica"
"reconnect": reconecta ao banco de dados com parâmetros diferentes
"autorização": Restringir o acesso a determinadas tabelas ou colunas
"validação": Retorna erros de validação de entrada para regras personalizadas e regras de tipo padrão
"ipAddress": Preencha um campo protegido com o endereço IP ao criar
"saneamento": Aplicar saneamento de entrada na criação e atualização
"multiTenancy": Restringe o acesso dos locatários em um cenário multilocatário
"pageLimits": restringe as operações da lista para evitar a extração do banco de dados
"joinLimits": Restringe os parâmetros de junção para evitar a raspagem do banco de dados
"textSearch": Pesquise em todos os campos de texto com um parâmetro simples
"customização": Fornece manipuladores para personalização de solicitação e resposta
"json": suporta leitura/gravação de strings JSON como objetos/matrizes JSON
"xml": traduz todas as entradas e saídas de JSON para XML
O parâmetro de configuração "middlewares" é uma lista separada por vírgulas de middlewares habilitados. Você pode ajustar o comportamento do middleware usando parâmetros de configuração específicos do middleware:
"firewall.reverseProxy": definido como "true" quando um proxy reverso é usado ("")
"firewall.allowedIpAddresses": Lista de endereços IP que têm permissão para se conectar ("")
"cors.allowedOrigins": as origens permitidas nos cabeçalhos CORS ("*")
"cors.allowHeaders": Os cabeçalhos permitidos na solicitação CORS ("Content-Type, X-XSRF-TOKEN, X-Authorization")
"cors.allowMethods": Os métodos permitidos na solicitação CORS ("OPTIONS, GET, PUT, POST, DELETE, PATCH")
"cors.allowCredentials": Para permitir credenciais na solicitação CORS ("true")
"cors.exposeHeaders": cabeçalhos da lista de permissões que os navegadores têm permissão para acessar ("")
"cors.maxAge": o tempo que a concessão CORS é válida em segundos ("1728000")
"xsrf.excludeMethods": os métodos que não requerem proteção XSRF ("OPTIONS,GET")
"xsrf.cookieName": O nome do cookie de proteção XSRF ("XSRF-TOKEN")
"xsrf.headerName": O nome do cabeçalho de proteção XSRF ("X-XSRF-TOKEN")
"ajaxOnly.excludeMethods": Os métodos que não requerem AJAX ("OPTIONS,GET")
"ajaxOnly.headerName": O nome do cabeçalho necessário ("X-Requested-With")
"ajaxOnly.headerValue": o valor do cabeçalho necessário ("XMLHttpRequest")
"apiKeyAuth.mode": Defina como "opcional" se desejar permitir acesso anônimo ("obrigatório")
"apiKeyAuth.header": o nome do cabeçalho da chave de API ("X-API-Key")
"apiKeyAuth.keys": Lista de chaves de API válidas ("")
"apiKeyDbAuth.mode": Defina como "opcional" se desejar permitir acesso anônimo ("obrigatório")
"apiKeyDbAuth.header": o nome do cabeçalho da chave API ("X-API-Key")
"apiKeyDbAuth.usersTable": a tabela usada para armazenar os usuários ("usuários")
"apiKeyDbAuth.apiKeyColumn": a coluna da tabela de usuários que contém a chave de API ("api_key")
"dbAuth.mode": Defina como "opcional" se desejar permitir acesso anônimo ("obrigatório")
"dbAuth.usersTable": A tabela usada para armazenar os usuários ("usuários")
"dbAuth.loginTable": a tabela ou visualização usada para recuperar as informações dos usuários para login ("usuários")
"dbAuth.usernameColumn": a coluna da tabela de usuários que contém nomes de usuário ("nome de usuário")
"dbAuth.passwordColumn": a coluna da tabela de usuários que contém senhas ("senha")
"dbAuth.returnedColumns": As colunas retornadas no login bem-sucedido, vazio significa 'todos' ("")
"dbAuth.usernameFormField": O nome do campo do formulário que contém o nome de usuário ("nome de usuário")
"dbAuth.passwordFormField": O nome do campo do formulário que contém a senha ("senha")
"dbAuth.newPasswordFormField": O nome do campo do formulário que contém a nova senha ("newPassword")
"dbAuth.registerUser": dados do usuário JSON (ou "1") caso você queira que o endpoint /register esteja habilitado ("")
"dbAuth.loginAfterRegistration": 1 ou zero se usuários registrados devem estar logados após o registro ("")
"dbAuth.passwordLength": Comprimento mínimo que a senha deve ter ("12")
"dbAuth.sessionName": O nome da sessão PHP que foi iniciada ("")
"wpAuth.mode": Defina como "opcional" se desejar permitir acesso anônimo ("obrigatório")
"wpAuth.wpDirectory": A pasta/caminho onde a instalação do Wordpress pode ser encontrada (".")
"wpAuth.usernameFormField": O nome do campo do formulário que contém o nome de usuário ("nome de usuário")
"wpAuth.passwordFormField": O nome do campo do formulário que contém a senha ("senha")
"jwtAuth.mode": Defina como "opcional" se desejar permitir acesso anônimo ("obrigatório")
"jwtAuth.header": Nome do cabeçalho que contém o token JWT ("X-Authorization")
"jwtAuth.leeway": o número aceitável de segundos de distorção do relógio ("5")
"jwtAuth.ttl": o número de segundos que o token é válido ("30")
"jwtAuth.secrets": o(s) segredo(s) compartilhado(s) usado(s) para assinar o token JWT com ("")
"jwtAuth.algorithms": Os algoritmos permitidos, vazio significa 'todos' ("")
"jwtAuth.audiences": os públicos permitidos, vazio significa 'todos' ("")
"jwtAuth.issuers": Os emissores permitidos, vazio significa 'todos' ("")
"jwtAuth.sessionName": O nome da sessão PHP que foi iniciada ("")
"basicAuth.mode": Defina como "opcional" se desejar permitir acesso anônimo ("obrigatório")
"basicAuth.realm": Texto a ser solicitado ao mostrar o login ("Nome de usuário e senha obrigatórios")
"basicAuth.passwordFile": o arquivo a ser lido para combinações de nome de usuário/senha (".htpasswd")
"basicAuth.sessionName": O nome da sessão PHP que foi iniciada ("")
"reconnect.driverHandler": Manipulador para implementar a recuperação do driver do banco de dados ("")
"reconnect.addressHandler": Manipulador para implementar a recuperação do endereço do banco de dados ("")
"reconnect.portHandler": Manipulador para implementar a recuperação da porta do banco de dados ("")
"reconnect.databaseHandler": Manipulador para implementar a recuperação do nome do banco de dados ("")
"reconnect.tablesHandler": Manipulador para implementar a recuperação dos nomes das tabelas ("")
"reconnect.mappingHandler": Manipulador para implementar a recuperação do mapeamento de nomes ("")
"reconnect.usernameHandler": Manipulador para implementar a recuperação do nome de usuário do banco de dados ("")
"reconnect.passwordHandler": Manipulador para implementar a recuperação da senha do banco de dados ("")
"authorization.tableHandler": Manipulador para implementar regras de autorização de tabela ("")
"authorization.columnHandler": Manipulador para implementar regras de autorização de coluna ("")
"authorization.pathHandler": Manipulador para implementar regras de autorização de caminho ("")
"authorization.recordHandler": Manipulador para implementar regras de filtro de autorização de registro ("")
"validation.handler": Manipulador para implementar regras de validação para valores de entrada ("")
"validation.types": Tipos para ativar a validação de tipo, vazio significa 'nenhum' ("todos")
"validation.tables": Tabelas para permitir a validação de tipo, vazia significa 'nenhuma' ("todas")
"ipAddress.tables": Tabelas para procurar colunas para substituir pelo endereço IP ("")
"ipAddress.columns": Colunas para proteger e substituir pelo endereço IP na criação ("")
"sanitation.handler": Manipulador para implementar regras de saneamento para valores de entrada ("")
"sanitation.types": Tipos para habilitar o tipo de saneamento, vazio significa 'nenhum' ("todos")
"sanitation.tables": Tabelas para habilitar o tipo saneamento, vazio significa 'nenhum' ("todos")
"multiTenancy.handler": Manipulador para implementar regras simples de multilocação ("")
"pageLimits.pages": o número máximo de páginas permitido por uma operação de lista ("100")
"pageLimits.records": o número máximo de registros retornados por uma operação de lista ("1000")
"joinLimits.profundidade": A profundidade máxima (comprimento) permitida em um caminho de junção ("3")
"joinLimits.tables": O número máximo de tabelas que você tem permissão para ingressar ("10")
"joinLimits.records": o número máximo de registros retornados para uma entidade associada ("1000")
"textSearch.parameter": O nome do parâmetro usado para o termo de pesquisa ("pesquisa")
"customization.beforeHandler": Manipulador para implementar personalização de solicitação ("")
"customization.afterHandler": Manipulador para implementar personalização de resposta ("")
"json.controllers": controladores para processar strings JSON para ("records,geojson")
"json.tables": Tabelas para processar strings JSON para ("todos")
"json.columns": Colunas para processar strings JSON para ("todos")
"xml.types": tipos JSON que devem ser adicionados ao atributo de tipo XML ("null,array")
Se você não especificar esses parâmetros na configuração, os valores padrão (entre colchetes) serão usados.
Nas seções abaixo você encontra mais informações sobre o middleware integrado.
Atualmente existem cinco tipos de autenticação suportados. Todos eles armazenam o usuário autenticado no super global $_SESSION . Esta variável pode ser usada nos manipuladores de autorização para decidir se alguém deve ou não ter acesso de leitura ou gravação a determinadas tabelas, colunas ou registros. A visão geral a seguir mostra os tipos de middleware de autenticação que você pode ativar.
| Nome | Middleware | Autenticado via | Os usuários são armazenados em | Variável de sessão |
|---|---|---|---|---|
| Chave de API | apiKeyAuth | Cabeçalho 'X-API-Key' | configuração | $_SESSION['apiKey'] |
| Banco de dados de chave de API | apiKeyDbAuth | Cabeçalho 'X-API-Key' | tabela de banco de dados | $_SESSION['apiUser'] |
| Banco de dados | dbAuth | Ponto de extremidade '/login' | tabela de banco de dados | $_SESSION['user'] |
| Básico | autenticação básica | Cabeçalho 'Autorização' | Arquivo '.htpasswd' | $_SESSION['username'] |
| JWT | jwtAuth | Cabeçalho 'Autorização' | provedor de identidade | $_SESSION['claims'] |
Abaixo você encontra mais informações sobre cada um dos tipos de autenticação.
A autenticação de chave de API funciona enviando uma chave de API em um cabeçalho de solicitação. O nome do cabeçalho é padronizado como "X-API-Key" e pode ser configurado usando o parâmetro de configuração 'apiKeyAuth.header'. As chaves de API válidas devem ser configuradas usando o parâmetro de configuração 'apiKeyAuth.keys' (lista separada por vírgulas).
X-API-Key: 02c042aa-c3c2-4d11-9dae-1a6e230ea95e
A chave API autenticada será armazenada na variável $_SESSION['apiKey'] .
Observe que a autenticação da chave API não requer nem usa cookies de sessão.
A autenticação do banco de dados de chaves API funciona enviando uma chave API em um cabeçalho de solicitação "X-API-Key" (o nome é configurável). As chaves API válidas são lidas no banco de dados na coluna "api_key" da tabela "users" (ambos os nomes são configuráveis).
X-API-Key: 02c042aa-c3c2-4d11-9dae-1a6e230ea95e
O usuário autenticado (com todas as suas propriedades) será armazenado na variável $_SESSION['apiUser'] .
Observe que a autenticação do banco de dados de chaves de API não requer nem usa cookies de sessão.
O middleware de autenticação de banco de dados define cinco novas rotas:
method path - parameters - description --------------------------------------------------------------------------------------------------- GET /me - - returns the user that is currently logged in POST /register - username, password - adds a user with given username and password POST /login - username, password - logs a user in by username and password POST /password - username, password, newPassword - updates the password of the logged in user POST /logout - - logs out the currently logged in user
Um usuário pode fazer login enviando seu nome de usuário e senha para o endpoint de login (no formato JSON). O usuário autenticado (com todas as suas propriedades) será armazenado na variável $_SESSION['user'] . O usuário pode ser desconectado enviando uma solicitação POST com um corpo vazio para o terminal de logout. As senhas são armazenadas como hashes na coluna de senha da tabela de usuários. Você pode registrar um novo usuário usando o endpoint de registro, mas essa funcionalidade deve ser ativada usando o parâmetro de configuração "dbAuth.registerUser".
É IMPORTANTE restringir o acesso à tabela de usuários utilizando o middleware 'autorização', caso contrário todos os usuários poderão adicionar, modificar ou excluir livremente qualquer conta! A configuração mínima é mostrada abaixo:
'middlewares' => 'dbAuth,authorization',
'authorization.tableHandler' => function ($operation, $tableName) {
return $tableName != 'users';
},Observe que este middleware usa cookies de sessão e armazena o estado de login no servidor.
Faça login usando visualizações com tabela unida
Para operações de login, é possível usar uma visualização como usersTable. Essa visualização pode retornar um resultado filtrado da tabela de usuários, por exemplo, onde ativo = verdadeiro ou também pode retornar um resultado de várias tabelas por meio de uma junção de tabela. No mínimo, a visualização deve incluir o nome de usuário e a senha e um campo denominado id .
No entanto, as visualizações com tabelas unidas não podem ser inseridas (consulte a edição 907). Como solução alternativa, use a propriedade loginTable para definir uma tabela de referência diferente para login. A usersTable ainda será definida como a tabela de usuários normal e inserível.
O middleware de autenticação Wordpress define três rotas:
method path - parameters - description --------------------------------------------------------------------------------------------------- GET /me - - returns the user that is currently logged in POST /login - username, password - logs a user in by username and password POST /logout - - logs out the currently logged in user
Um usuário pode fazer login enviando seu nome de usuário e senha para o endpoint de login (no formato JSON). O usuário pode ser desconectado enviando uma solicitação POST com um corpo vazio para o terminal de logout. Você precisa especificar o diretório de instalação do Wordpress usando o parâmetro de configuração “wpAuth.wpDirectory”. O middleware chama "wp-load.php", o que permite usar funções do Wordpress no middleware de autorização, como:
wp_get_current_user()
is_user_logged_in()
is_super_admin()
user_can(wp_get_current_user(),'edit_posts');
Observe que a variável $_SESSION não é usada por este middleware.
O tipo Básico suporta um arquivo (por padrão '.htpasswd') que contém os usuários e suas senhas (com hash) separados por dois pontos (':'). Quando as senhas são inseridas em texto simples, elas serão automaticamente criptografadas. O nome de usuário autenticado será armazenado na variável $_SESSION['username'] . Você precisa enviar um cabeçalho "Autorização" contendo uma versão codificada em url base64 do seu nome de usuário e senha separados por dois pontos, após a palavra "Básico".
Authorization: Basic dXNlcm5hbWUxOnBhc3N3b3JkMQ
Este exemplo envia a string "username1:password1".
O tipo JWT requer outro servidor (SSO/Identidade) para assinar um token que contém declarações. Ambos os servidores compartilham um segredo para que possam assinar ou verificar se a assinatura é válida. As declarações são armazenadas na variável $_SESSION['claims'] . Você precisa enviar um cabeçalho "X-Authorization" contendo um URL base64 codificado e cabeçalho de token separado por pontos, corpo e assinatura após a palavra "Bearer" (leia mais sobre JWT aqui). O padrão diz que você precisa usar o cabeçalho "Autorização", mas isso é problemático no Apache e no PHP.
X-Authorization: Bearer eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiYWRtaW4iOnRydWUsImlhdCI6IjE1MzgyMDc2MDUiLCJleHAiOjE1MzgyMDc2MzV9.Z5px_GT15TRKhJCTHhDt5Z6K6LRDSFnLj8U5ok9l7gw
Este exemplo envia as declarações assinadas:
{
"sub": "1234567890",
"name": "John Doe",
"admin": true,
"iat": "1538207605",
"exp": 1538207635
}NB: A implementação do JWT suporta apenas algoritmos baseados em RSA e HMAC.
